PWCore.mesa
Copyright © 1985, 1986 by Xerox Corporation. All rights reversed.
Louis Monier February 14, 1986 11:00:35 am PST
Bertrand Serlet, March 15, 1987 10:12:15 pm PST
DIRECTORY
CD USING [Design, InterestRect, Object, Position, Rect],
Core,
CoreCreate USING [PA],
CoreGeometry,
HashTable USING [Table],
Sinix USING [Mode];
Theory
This interface defines how to generate layout attached to Core, using PatchWork (PW). Layout done by hand can also be attached. When layout is attached to Core, it is also specified how to decorate the original Core source with the interface geometry. The only way for clients to retrieve the Layout hanging on a Core CellType is Layout.
Basics
CellType: TYPE = Core.CellType;
Object: TYPE = CD.Object;
Wire: TYPE = Core.Wire;
WireSeq: TYPE = Core.WireSeq;
ROPE: TYPE = Core.ROPE;
Properties: TYPE = Core.Properties;
Wires: TYPE = Core.Wires;
Primitive operations
LayoutProc:
TYPE =
PROC [cellType: CellType]
RETURNS [obj: Object];
obj is the layout for cellType.
Identical (REF equal) cellTypes must have the same (REF equal) layout, and the same layout must correspond to the same cellType. To follow this restriction, the Layout function automatically insert one level of indirection (Indirect object).
DecorateProc:
TYPE =
PROC [cellType: CellType, obj: Object];
Decorates cellType with the geometric information derived from obj. That is decorates the atomic publics with the pins.
AttributesProc:
TYPE =
PROC [cellType: CellType];
This function allows the computation of arbitrary attributes that can be stored on the cellType for the LayoutProc.
RegisterLayoutAtom:
PROC [layoutAtom:
ATOM, layoutProc: LayoutProc, decorateProc: DecorateProc ←
NIL, attributesProc: AttributesProc ←
NIL]
RETURNS [sameAtom:
ATOM];
LayoutProcs are not directly accessible and must be associated with an atom.
This delayed generation allows description or simulation of the Core structure before any geometry is present, and lazy evaluation of the geometry improves efficiency.
decorateProc can only be NIL if layoutProc is decorating its argument.
GetLayoutAtomRegistration:
PROC [layoutAtom:
ATOM]
RETURNS [layoutProc: LayoutProc ←
NIL, decorateProc: DecorateProc ←
NIL, attributesProc: AttributesProc ←
NIL];
Retrieves the registration of layoutAtom.
Might load some program according to the ChipNDale-CD-PWCore.CDLoadList.
layoutAtomProp:
ATOM;
-- = $Layout. Property on cellTypes to specifies layoutAtoms
GetLayoutAtom:
PROC [cellType: CellType]
RETURNS [layoutAtom:
ATOM ←
NIL];
Retrieves the layoutAtom (if any) on the CellType, then on the CellClass.
Layout:
PROC [cellType: CellType]
RETURNS [obj: Object];
Retrieves the layout corresponding to a cell type by:
- fetching the layoutAtom with the function GetLayoutAtom (property layoutAtomProp), and finding the corresponding layoutProc and decorateProc,
- if that fails start all over again with the recast of cellType.
- evaluating the attributesProc,
- evaluating layoutProc,
- using the decorateProc to decorate the original cellType
- returning an indirect object of obj with a funny ExtractProc.
The result is cached, so that means that called twice with the same (REF equal) cellType, Layout will produce the same (REF equal) obj.
To follow the restriction that the same layout can not correspond to two different cellTypes, Layout automatically inserts one level of indirection (indirect object).
The extraction of the indirect object returns a CellType of class layoutClass that contains the source layout and the source CellType, and that recasts in a recordCell with only one sub cellType being the result of the extraction of the source layout.
InterestRect:
PROC [cellType: CellType]
RETURNS [ir:
CD.Rect] =
INLINE {ir ←
CD.InterestRect[Layout[cellType]]};
For backward compatibility and ease of use
Predefined layoutAtoms
Predefined layoutAtoms to be used in schematics
$Get and $GetAndFlatten: expect a $PWCoreSourceDesign property [of type CD.Design] on the cellType. The Object of name the name of the CellType concatenated with maskSuffix is fetched in the attribute Design, and is Extracted. Publics of the extracted CellType must correspond [by full name] to the original public. GetAndFlatten flattens the layout, so that corresponding transistors inter-cells are fused.
$AbutX, $AbutY, $ReverseAbutX, $ReverseAbutY: the cellType must be a recordCell. Sorts the instances according to the Sisyph decoration.
$ArrayX, $ArrayY, $ReverseArrayX, $ReverseArrayY: the cellType must be a sequenceCell.
$FlipX, $FlipY, $Rot90, $Rot180, $Rot270: the cellType must be a RecordCell with a unique instance.
Predefined layoutAtoms to be used by code
$Value: expects a $PWCoreValue property [of type Object] on the cellType. The Object is extracted, and publics of the extracted CellType must correspond [by full name] to the original public.
$RawAbutX, $RawAbutY, $RawReverseAbutX, $RawReverseAbutY: the cellType must be a recordCell. The order of the cell instances is important.
$Recast: the cellType must have a Recast proc and the recasted cellType must have layout.
maskSuffix:
ROPE;
Contains the rope that is to be concatenated to the name of a cellType to find the name of the corresponding layout cell. Used by the LayoutProc for $Get
Global Variable
A global variable is used for calling Sinix. This is going to change soon, but for now that is fine enough. Better rollback between changes, if you don't know what you are doing.
extractMode: Sinix.Mode;
Contains the mode that is to be passed to Sinix when doing extraction.
Its default is SinixOps.GetExtractMode[$cmosB].
Short cuts for the designer
SetLayout:
PROC [cellType: CellType, layoutAtom:
ATOM, userDataProp:
ATOM ←
NIL, userData:
REF ←
NIL];
Attaches the atom as a property (layoutAtomProp) of the cell type.
If the user wants to supply some data, this data is stored under the property userDataProp on the cellType.
The implementation is the following:
CoreProperties.PutCellTypeProp[cellType, layoutAtomProp, layoutAtom];
IF userDataProp#NIL THEN CoreProperties.PutCellTypeProp[cellType, userDataProp, userData];
SetGet:
PROC [cellType: CellType, source:
CD.Design] =
INLINE {SetLayout[cellType, $Get, $PWCoreSourceDesign, source]};
Fetches layout from a source design.
SetLayoutAndDecoration:
PROC [cellType: CellType, layout: Object] =
INLINE {SetLayout[cellType, $ValueNoDecorate, $PWCoreValue, layout]};
For cases when designer knows the layout of a cellType (without any lazyness), and has already decorated cellType with the interface decorations.
SetAbutX: PROC [cellType: CellType] = INLINE {SetLayout[cellType, $RawAbutX]};
SetAbutY:
PROC [cellType: CellType] =
INLINE {SetLayout[cellType, $RawAbutY]};
SetArrayX: PROC [cellType: CellType] = INLINE {SetLayout[cellType, $ArrayX]};
SetArrayY: PROC [cellType: CellType] = INLINE {SetLayout[cellType, $ArrayY]};
RotateCellType:
PROC [rotatedCellType: CellType, orientation:
ATOM]
RETURNS [cellType: CellType];
Creates a new cellType which layout is the same as the rotatedCellType, but rotated by orientation.
Help for writing DecorateProcs
SortProc:
TYPE =
PROC [
CD.Position,
CD.Position]
RETURNS [
BOOL];
Returns TRUE if the first position is "before" the second
SortInX: SortProc;
SortInY: SortProc;
ReverseSortInX: SortProc;
ReverseSortInY: SortProc;
DecorateValue: DecorateProc;
Provokes an extraction. Assumes the the full names of the publics cellType and the extracted CellType are corresponding.
DecorateAbut:
PROC [cellType: CellType, obj: Object, sort: SortProc];
Assumes that cellType is a record Cell for which each sub cell type has layout.
Assumes that obj (when expanded the appropriate number of times) is a CD Cell that contains translations of the layouts of the sub cell types.
Does not provoke an extraction.
DecorateAbutX: DecorateProc;
DecorateAbutY: DecorateProc;
DecorateReverseAbutX: DecorateProc;
DecorateReverseAbutY: DecorateProc;
DecorateRecasted: DecorateProc;
Assumes that cellType and its recast have similar public.
Copies the decorations of the recast.
Does not provoke an extraction.
DecorateRotated: DecorateProc;
Assumes that cellType is a RecordCell with a unique instance, and obj a CD Cell with a unique instance.
DecorateFlatten:
PROC [cellType: CellType, obj: Object, sort: SortProc];
Conceptually flattens obj (stopping for the cellTypes which have an associated layout), extracts it, sorts its instances, assumes they match the instances of cellType, and finally decorates cellType in accord to this sort.
Wires that have their own geometry (not part of an instance) are matched by name.
SortInstances:
PROC [decoration: CoreGeometry.Decoration, cellType: CellType, sort: SortProc];
This function modifies physically the instances of cellType, by permuting the ith and the jth instance when sort (called with the positions of the instances) returns FALSE (for i<j).
Help for regular structures
The intent of this function is to permit building regular structures while specifying the minimum amount of information. For example only topology and renaming is given when calling this function, and all the details of the strictly internal wires are not specified.
AbutInstance:
TYPE =
RECORD [object: Object, pas:
LIST
OF CoreCreate.
PA ←
NIL];
Object must be a layout cell with only atomic wires. There is no need to describe object by other means (it defines the truth!).
ATTENTION: pas should contain all bindings (no default binding when public and sub-publics have same name is happening)
AbutCell:
PROC [public: Wire, abutInstances:
LIST
OF AbutInstance, inX:
BOOL, name:
ROPE ←
NIL, props: Properties ←
NIL]
RETURNS [recordCell: CellType];
Abuts (in X or in Y depending on inX) the layout of the given abutInstances. Extracts the result using extractMode, and uses the pas (given in abutInstances) to deduce the correspondance between extracted wires and public wires.
The truth for this generated recordCell comes soforth from the layout.
Saving "Checkpoints"
This section allows the user of PWCore to insert "checkpoints", that is places where the generated layout is stored on a file.
Store:
PROC [cellType: CellType, withCuteFonts:
BOOL ←
FALSE];
Assumes that the cellType is decorated with layout.
Stores the decorated Core itself on the file named "<nameOfCellType>.core".
Stores the layout on the file named "<nameOfCellType>Layout.dale".
Stores a shell of the layout on the file named "<nameOfCellType>Shell.dale".
Retrieve:
PROC [name:
ROPE]
RETURNS [cellType: CellType];
Retrieves the decorated Core itself from the file named "<nameOfCellType>.core".
Backdoor for clients such as PWCoreLichen
layoutClass: Core.CellClass; -- data field of such objects is of type LayoutData
LayoutData:
PRIVATE
TYPE =
REF LayoutDataRec;
For information only
LayoutDataRec:
PRIVATE
TYPE =
RECORD [
obj: Object, -- obj as returned by the layoutProc
cellType: CellType, -- source as passed by the user
mode: Sinix.Mode -- extractMode, at layout creation time
];
For information only
LayoutCellTypeInfo:
PROC [layoutCellType: CellType]
RETURNS [obj: Object, sourceCellType, extractedCellType: CellType, extractedToSource: HashTable.Table];
Returns all the information implicitly contained in a Layout CellType.
CorrespondingCellType:
PROC [obj: Object]
RETURNS [layoutCellType: CellType ←
NIL];
This function returns a cellType of class layoutClass such as Layout[layoutCellType.data.cellType]=obj, if any, NIL otherwise.
In particular, obj.class#indirect => layoutCellType=NIL.
This function is used for checking the isomorphism between the source Core and the extracted Core.
Exceptions
All the escapes from PWCore functions are described in this section.
Signal:
SIGNAL [cellType: CellType];
This SIGNAL is called when implementor should be called ...
Error:
ERROR [type:
ATOM, message:
ROPE, cellType: CellType];
This ERROR is called when attachment of layout is impossible. Current types are:
$NoLayoutAtom
$NoRegistration
$InternalBug
$CallerBug
PinsCorrespondingToSeveralPublics:
SIGNAL [cellType: CellType, obj: Object, publics: Wires, geometry: CoreGeometry.Instances];
This Signal is called during or after decoration of cellType, when some interface geometry corresponds to two several atomic wires of cellType. The variable publics holds the list of atomic publics corresponding; geometry holds all the geometry in error.
NoPinsOnAtomicPublic:
SIGNAL [cellType: CellType, obj: Object, public: Wire, message:
ROPE ←
NIL];
This Signal is called during or after decoration of cellType. The variable public holds the atomic public which has no geometry.