Glossary

Additional information added to standard design objects that carries specific semantics for one or more applications. Typically, annotations refer to information in the form of extension objects; for example, instances of oaProp, oaGroup, oaGroupMember, oaApp*Def, and oaAppObject* classes. Some types of data that appear as annotations in other APIs are formalized as standard classes in OpenAccess; for example, parasitics are implemented as a set of explicit classes. Delay information, however, must be annotated on top of existing OpenAccess objects (such as oaTerm, oaInstTerm, oaNet, and so on) using extension objects.

An acronym for application programming interface. In OpenAccess, the software function definitions, protocols, and constraints used by an OpenAccess application program to create and request services against runtime memory or to save it in persistent storage.

API is sometimes used to refer to the entire set of classes and functions, as in "the OpenAccess API." However, it is also sometimes used to refer to individual functions, as in "the APIs on oaInst."

The set of software routines and protocols that make up the OpenAccess API for OpenAccess applications, delivered as dynamically linkable libraries.

See also reference implementation.

A document defining the OpenAccess functions (methods) for each data class, including syntax, semantics, behavior, and constraints. Also called the API reference.

1. An executable program, or fragment of a program (such as a subroutine, module, or DLL) that performs a set of related logical functions in an EDA flow.



2. A program that uses the OpenAccess API (see also client).



3. The software that manages OpenAccess extension data and uses the oaApp*Def or oaAppObject* extensibility API classes.

An oaShape that is a part of an oaEllipse.

An object passed in parentheses to a function. See also parameter.

A characteristic, or piece of metadata, of an object or class.

Attribute is often used to indicate items that are built-in to the API, as opposed to a property, which is added by the caller.

1. A result that occurs without explicit action by an application, or as a consequence of a related action.



2. A side effect that the OpenAccess implementation causes as a result of some application activity. For example, when an owner (a container object, such as oaCellView) is destroyed by the application, the database automatically destroys all of its contained objects (the oaNets, oaInsts, and so on).



3. A managed OpenAccess class or object that cannot be created or destroyed by an application, but instead is created as a result of creation of another managed object. An automatic object is characterized by:
   
   
   • The lack of a public constructor or destructor and any way to create or destroy the object
   • The inability to be made persistent
   
   
   
   Some examples of automatic objects are oaBusNetBit, oaBusTermBit, oaBusNetDef, oaBusTermDef, and oaInstHeader.

The phases near the end of the design flow, such as wiring, timing, parasitic extraction, and mask generation.

See bounding box.

The smallest rectangle oriented parallel to the X and Y axes that contains all of the geometry (oaFig objects) that comprises an oaCellView or figure.

A multi-bit terminal or net consisting of a collection of terminal or net objects, respectively. Each bit object of a bundle can be a scalar or bus. A bundle name is comprised of a list of smaller bus and scalar names.

A multi-bit terminal or net consisting of a collection of single-bit terminal or net objects, respectively, where each bit is identified by a base name and an integer index. The first bit index is the start attribute of the bus. Adjacent bit indices differ by the step attribute of the bus.

An acronym for Computer Aided Design, describing software, hardware, and processes that used in modern manufacturing of a wide range of products. When applied to electronic products, the acronym EDA is often applied to constrain the scope of such products.

A logical component of a particular portion of a design, such as an AND or ADDER cell. In OpenAccess, an oaCell.

A container in an OpenAccess library that belongs to one Cell and one View. OpenAccess design and wafer databases are always stored in a cellView.

The collection of classes and methods that manipulate objects contained in an oaCellView.

A checkpoint is a mechanism that an application uses to group function calls in order to support an undo command for a task involving multiple calls.

A program, application, or code fragment that uses OpenAccess classes. A client can also be referred to as a caller, user, end-user, calling module, or calling program.

See congestion map.

A container that can be used by an application (typically a global router) to save statistics about routing density by layer and region.

A limitation or qualification on the behavior of some function or use of some object that is not implied by definition. For example, a load constraint on a pin indicates the maximum capacitance that can be added to the pin and still have the pin work correctly.

Used by databases only to mean if the database is saved, changes to contained objects become persistent. Contains is similar to owns, which in the information model means that if the owner is deleted, the owned object is implicitly deleted. Contains implies owns.

A complete specification level model of OpenAccess provided as C++ header files with embedded descriptions and constraints.

1. A manager or location of design data.



2. A synonym for the reference implementation.



3. A synonym for the persistent store of data on disk.

An acronym for Design Management; a process or system for controlling versioning, alternate representations, and concurrent access to design components.

An acronym for Design For Manufacturing (or Design for Manufacturability); analysis, modeling, and abstraction of manufacturing process parameters and effects for use by software during the design process to improve the likelihood that a design can be successfully manufactured.

A method for sharing knowledge about proven solutions to design problems. Using some notation (such as UML), a design pattern models a solution that reflects experience with the problem. A pattern expresses a relationship between a problem context, certain issues that arise repeatedly in relation to it, and a software solution that addresses these issues.

The electrical effects on a signal caused by another signal, modeled as a collection of resistor, inductor, mutual inductor, and capacitor devices connected at terminal, instTerm, pin, or instPin nodes into a parasitic network associated with a net.

An acronym for dynamically linked (or loaded) library.

1. A shared object library designed to link to a program as it is first loaded for execution. Shared libraries are re-entrant code that enables multiple executables to share a single copy.



2. A fully linked executable that can be loaded at runtime into another program (after that program has been linked, loaded, and started its execution), with any of its exported functions or variables available for use.

An acronym for Electronic Design Automation; a collective term describing software, hardware, and processes used in modern semiconductor and board-level manufacturing, and the companies involved. See also CAD.

An indication of the byte order significance of a machine hardware architecture, and the bit order significance within each byte. Big-endian machines (such as most UNIX machines) store the most significant bytes of a word in the lower address; little-endian machines (such as most PCs) store most significant bytes in the higher address. Machines such as the PowerPC are bi-endian and can understand both indications. It is also possible to have big-endian byte ordering but little-endian bit ordering within each byte, or vice-versa.

A hook, or technique, for adding objects dynamically to a schema by an application, with arbitrary semantics.

A term used to describe collectively the set of OpenAccess classes used for manipulation of application-defined extension data. Usually, this is limited to the oaApp*Def and oaAppObject* classes, but can also include the oaGroup, oaGroupMember, and oaProp* classes.

An object that has physical geometric attributes; specifically, an oaFig.

1. Fill patterns are added to meet the minimum layer density requirements for a given process.



2. Fill shapes are added to avoid Chemical Mechanical Polishing (CMP) while planerizing the oxides between the layers of metals. If there are large shapes of metal adjacent to empty areas, CMP can create divots in the oxide or begin to lift off the metals near these empty areas. Also, an uneven distribution of metal patterns can result in areas that over etch during the etching process.

A representation of a design where separate copies of each design component (nets, terminals, instances, and so on) are replicated everywhere they are used in the design.

A design step, usually preceding placement, that maps a logical netlist to a physical implementation (deciding the arrangement of blocks, location of I/O and power pads, type of power and clock distribution, and so on) in order to minimize the chip area and delay.

A method for representing design data that minimizes the redundancies of design objects characteristic of a flattened representation. In this method, collections of design objects (such as nets and terminals) that are used repeatedly are defined only once in the design (by a cellView object), and then referenced each time they are used (with an instance object).

The software that provides a common environment for EDA tools. Usually this environment enables a common "look and feel" to the tools and simplifies their integration in design flows. A framework is typically sold by a vendor, along with tools that "plug in" to it. Also called: cockpit, development environment, tool environment, API.

The phases early in a design flow, usually design using RTL and synthesis of it into a behavioral or gate-level representation.

Short for global cell, a unit of a congestion map.

The OpenAccess technique for representing a complex design in terms of smaller, more easily understood or manipulated sub-components, with each such component itself a collection of components. Each collection is considered a level in the hierarchy, with no limit on the number of levels allowed. The basic hierarchical unit in OpenAccess is the cellView.

1. Executable code.



2. The source code that provides the algorithms defining a function declared in a program or API.



3. The OpenAccess database source code or linked object code that provides all the functions of the API.

See also reference implementation.

A partial specification level model for OpenAccess that includes all classes, attributes, and associations (and their multiplicity and navigability).

1. A particular example of something.



2. An object of a class. Also called instantiation.



3. An object of the oaInst class, representing an opaque reference to an oaCellView object. Also called block, macro, inst, cell reference.

A logical point where an instance can be connected to a net.

An OpenAccess object that enables individual access to each object in a collection exactly once, although not in any particular order.

All geometric data in OpenAccess is assigned to a layer. In chip layouts, layers represent the manufacturing layers of the chip. Other layers can be created to hold data that is not manufactured with the chip.

A description for a cell in a design at the bottom of that design's hierarchy. A leaf cell contains no instances of other cells. Leaf cells are sometimes synonymous with gates (such as AND, OR, XOR, and so on), often include primitive devices such as resistors or capacitors (unless the design includes transistor-level hierarchy), and can include blocks with more sophisticated logical functions, such as latches, adders, amps, and so on. However, any cell could be a leaf cell. For example, an entire microprocessor might be instantiated into a larger design from a cell library as a "core" that is essentially invisible inside, and is merely characterized by its behavior and electrical characteristics.

Also called primitive or frontier cells.

Short for library or oaLib.

A logical collection of design data organized into cells.

An OpenAccess object for which the OpenAccess implementation is responsible for allocating and managing storage. A managed class is characterized by:

A class of objects associated with zero or more other design objects used to annotate a design. Markers are often used to indicate violations between the specified objects.

The process of allocating and de-allocating memory from a running process and (to a sometimes greater and sometimes lesser extent) monitoring proper use of such memory, such as preventing use of unallocated memory, freeing memory that is not allocated, or providing notice of such errors.

Data about data.

1. Some consider metadata to be any information that describes the contents an object, such as its condition, state or quality, but that is not part of the contents of the object. For example:



• The design information in an oaCellView is data. The version of that oaCellView is metadata.



• A file stored in a UNIX directory is data. The owner and permissions of the file are metadata.



However, such information can be modeled as merely additional attributes of the object, the contents comprising merely one or more other attributes. In the examples above, the version can be viewed as just another attribute of the oaCellView; the owner of a file is an attribute of that file, just as the bytes that make up its contents.


2. A more restrictive definition of metadata is data that is not specific to any single instance of an object class, but descriptive of the class itself. For example:



• The definition of an oaCellView



• The semantics that limit what kind of oaFig can be the figure for an oaPin

A synonym for functions that are associated with a particular class; commonly used in object-oriented languages.

A set of rules for creating and interpreting legal names within an application. The OpenAccess database supports a number of commonly used namespaces, including VHDL, Verilog, CDBA, LEF, DEF, SPEF, SPF, UNIX, and Windows, as well as the oaNative OpenAccess namespace (the internal format for oaName objects).

Short for oaNet. A design object that represents logical connectivity. All points on a net are electrically equivalent.

The logical description of a design.

1. The OpenAccess API.



2. The complete project, including the C++ API, its reference implementation, and the managed process for their maintenance and evolution.



3. The reference implementation.

A programming paradigm or design methodology characterized by the use of objects that send messages to each other. Objects are instantiations of hierarchically organized classes that represent program data. Messages are implemented via functions, or methods, that communicate data via parameters and sometimes return values. Object-oriented programming is often called data-centric and contrasted to procedural or functional paradigms. Typical features include abstraction of the interface from the implementation, inheritance, encapsulation, data-hiding, polymorphism, and overloading.

OpenAccess observers are a set of classes that allow applications to request notification when certain changes occur to the state and contents of open databases. This observer mechanism allows a complex application to keep its internal state consistent with changes made by other code in the same process.

A value that constrains the result of an expression, function call, or creation of a managed object.

1. A function argument. See also argument.



2. An oaParam or oaViaParam used to parameterize pCells or vias, or an oaConstraintParam used to add a parameter to a constraint.

Either detailed parasitics or a reduced parasitic model describing the (usually) undesirable physics of a signal interfering with the proper generation of another signal. Parasitic effects have become increasingly significant obstacles to timing closure as designs have become smaller and more densely packed.

An instance of the OpenAccess model, consisting of data values on a permanent storage device (such as magnetic disk). See also database, repository.

Short for oaPin; the physical implementation of a connection point associated with an oaTerm (the logical representation of that point) to which a wiring tool connects routes. See also terminal.

Note: In LEF and other contexts, pin refers to the logical connection point, which can be a source of confusion.

Mechanism for customizing certain OpenAccess features. Plug-ins use dynamically loaded shared libraries to select a customized implementation at run-time without requiring an application to be linked with that implementation, or to know about that implementation, when the application is compiled and linked. OpenAccess provides interface classes that you use to implement plug-ins.

An extension mechanism common to many database models, consisting primarily of a name and value pair.

A simplified representation of the detailed parasitics associated with a net.

The source code for, or linked libraries of, the implementation of the OpenAccess API that is publicly available as part of the OpenAccess distribution. OpenAccess is a public API that documents required behavior. It is possible that more than one implementation of this API could be written, perhaps by different vendors. The reference implementation is one particular implementation of the API, with publicly available source that is updated with changes to the API. See also implementation.

The location on physical storage media (the disk) where OpenAccess design data resides, or that data itself. See also database, persistent storage.

1. A wire.



2. A figure with specific geometry and location that represents the metal trace on a chip that actually implements a signal. OpenAccess routes have specific constraints and semantics designed to enable significant capacity optimization, as well as reducing the geometric analysis burden of wiring tools.

A collection of sites arranged in a linear pattern that indicate legal placement locations for instances (for those placement tools that use sites).

Synthesizable code written in a hardware description language, such as Verilog or VHDL.

An instance of the OpenAccess data model consisting of the actual data values in computer memory being used by and within the life of a single application process.

A single bit net, terminal, or instance object that has only a base name and does not include an index.

A common design testability technique in which the registers in a design are chained together so that all of their values can be scanned in and scanned out.

The meaning of an object, attribute, or relationship, including correspondences, dependencies, relationships, side effects, and constraints, that is not already defined by its syntax or notation.

An acronym for Silicon Integration Initiative, a non-profit consortium of semiconductor manufacturers, EDA vendors, and related companies. See http://www.si2.org.

Slotting provides stress relief on large metal shapes. As an IC heats and cools, the substrates, oxide, and metal materials expand and contract at different rates. Over time, this causes failures in the relatively large shapes on a mask, such as power wires. Cutting or placing holes, or slots, in the large shapes improves the structural integrity of the resulting shapes, making them less likely to fracture.

A pin not associated with a terminal or instance that is used to implement a virtual pin, which provides a form of routing control. For example, a steiner pin can be used to force nets to route through that location in the design, such as when constraining the routing of clock and power nets.

The process by which a designer is able to fully automate the contents of an integrated circuit design. Synthesis software transforms a circuit description from one level of abstraction to a lower level, usually towards some physical implementation.

Short for terminal or oaTerm.

A logical point on a net where an oaCellView allows connections from outside. (In contrast, port is used in CFI DR-PI, EDIF, and other EDA contexts.)

In OpenAccess, an oaTerm cannot exist in the absence of an oaNet on the inside of that oaTerm. Some other design data models do allow the existence of a terminal without any net.

A point-to-point delay. OpenAccess does not have formal objects for such data, but it can be annotated onto design objects (such as oaInstTerm, oaTerm, or oaNet objects) using extension objects (such as oaProp, oaApp*Def, oaAppObject).

An EDA application.

An OpenAccess object or class for which the application is responsible for allocating and managing storage. A utility class is characterized by:

• public constructors and destructor



• the fact that it is not derived from oaObject



• its inability to be made persistent

Utility objects are used for transferring attribute data to and from managed objects.

A part of a wire that spans two layers, consisting of a piece of conductor on the first layer, the cut where the insulator between layers is etched away, and the piece of conductor on the second layer.

1. One of possibly several representations for a design component corresponding to different:



• levels of abstraction (such as behavior or gate)
• design process stages (such as RTL, post-synthesis, placed, or routed)
• versions of the implementation for any given stage or abstraction level



2. An instance of the oaCellView class.



3. The oaView class or an instance of it (when in the context of the lib/cell/view design hierarchy).

A virtual pin can be placed at some location within a design to force nets to route through that location in the design, such as when constraining the routing of clock and power nets. Unlike a regular pin, a virtual pin is not associated with a terminal.

See also steiner pin.