DIRECTORY
CD, CDSimpleRules, Core, CoreFlat, CoreGeometry, CoreOps, CoreProperties, CoreRoute, Process, PWCore, Rope, Route, RTCoreUtil, SC, SCChanUtil, SCInitialPlace, SCInstUtil, SCPlaceUtil, SCPrivate, SCRowUtil, SCSmash, SCUtil, Sinix, Sisyph, TWOps;

SCImpl: CEDAR PROGRAM 
IMPORTS CD, CDSimpleRules, CoreFlat, CoreGeometry, CoreOps, CoreProperties, CoreRoute, Process, PWCore, Route, RTCoreUtil, SC, SCChanUtil, SCInitialPlace, SCInstUtil, SCPlaceUtil, SCPrivate, SCRowUtil, SCSmash, SCUtil, Sisyph, TWOps
EXPORTS SC
SHARES SC = {

debug: BOOLEAN _ FALSE;
Error: PUBLIC ERROR[errorType: SC.ErrorType _ callingError, explanation: Rope.ROPE _ NIL] = CODE;
Signal: PUBLIC SIGNAL[signalType: SC.ErrorType _ callingError, explanation: Rope.ROPE _ NIL] = CODE;
CreateDesignRules: PUBLIC PROC [technologyKey: ATOM, horizLayer, vertLayer: Rope.ROPE, rowDirection: SC.Direction] RETURNS [designRules: SC.DesignRules] =

BEGIN
hLayer: CD.Layer _ CDSimpleRules.GetLayer[technologyKey, horizLayer];
vLayer: CD.Layer _ CDSimpleRules.GetLayer[technologyKey, vertLayer];
technology: CD.Technology _ CD.FetchTechnology[technologyKey];
designRules _ NEW[SC.DesignRulesRec _ [horizLayer: horizLayer, vertLayer: vertLayer, rowParms: Route.DefaultDesignRulesParameters[technology, hLayer, vLayer, rowDirection], sideParms: Route.DefaultDesignRulesParameters[technology, hLayer, vLayer, rowDirection]]];
designRules.rowRules _ Route.DefaultDesignRules[designRules.rowParms];
designRules.sideRules _ Route.DefaultDesignRules[designRules.sideParms];
END;
CreateHandle: PUBLIC PROC [cellType: Core.CellType, flattenCellType: RTCoreUtil.FlattenCellTypeProc, libName: Rope.ROPE, designRules: SC.DesignRules, name: Rope.ROPE, decoration: CoreGeometry.Decoration] RETURNS [handle: SC.Handle] =

BEGIN
parms: SCPrivate.Parms _ NARROW[NEW[SCPrivate.ParmsRec], SCPrivate.Parms];

IF designRules = NIL THEN SC.Signal[callingError, "No design rules."];
IF cellType = NIL THEN SC.Signal[callingError, "No Core cell type."];
handle _ NEW[SC.HandleRec];
handle.name _ IF name # NIL THEN name ELSE CoreOps.GetCellTypeName[cellType];
handle.rules _ designRules;
handle.coreCellType _ cellType;

parms.libName _ libName; 
handle.parms _ parms;

IF ~SCPrivate.SetUpLayout[handle, cellType] THEN
SC.Signal[callingError, "Unable to construct layout data"];
IF ~SCPrivate.GetStructure[handle, cellType, flattenCellType, decoration] THEN
SC.Signal[callingError, "Unable to construct structure data"];
END;

InitialPlace: PUBLIC PROC [handle: SC.Handle, numRows: NAT _ 0] = {
layoutData: SCPrivate.LayoutData _ NARROW[handle.layoutData];
p: Process.Priority _ Process.GetPriority[];
Process.SetPriority[Process.priorityBackground];
SCSmash.RemoveSmash[handle];
SCPlaceUtil.ClrCurPlac[handle, TRUE];
SCInitialPlace.PrePlace[handle: handle, numRows: numRows, routingFactor: 2.5, initialized: TRUE];
SCInitialPlace.RowInit[handle];
SCInitialPlace.PosInit[handle];
[layoutData.lgRows.maxRowWidth, layoutData.lgRows.numMaxRows] _ SCRowUtil.FindMaxRow[handle];
SCChanUtil.InitChanWidths[handle];
SCInstUtil.AsgnChanPos[handle];
layoutData.initTotWidth _ layoutData.totWidth;
layoutData.initTotHeight _ layoutData.totHeight;

IF debug THEN SCPlaceUtil.WriteCurPlace[handle];
[] _ SCUtil.WriteResults["End initial placement\n initial size: ", handle, 0];
Process.SetPriority[p]}; 

PosImprove: PUBLIC PROC [handle: SC.Handle, maxCycles: INT] = {

p: Process.Priority _ Process.GetPriority[];
Process.SetPriority[Process.priorityBackground];
SCPrivate.PosImprove[handle, areaFom, maxCycles];
Process.SetPriority[p]};

PosImproveWL: PUBLIC PROC [handle: SC.Handle, maxCycles: INT] = {

p: Process.Priority _ Process.GetPriority[];
Process.SetPriority[Process.priorityBackground];
SCPrivate.PosImprove[handle, wlFom, maxCycles];
Process.SetPriority[p]};

OrientImprove: PUBLIC PROC [handle: SC.Handle, maxCycles: INT] = {

p: Process.Priority _ Process.GetPriority[];
Process.SetPriority[Process.priorityBackground];
SCPrivate.OrientImprove[handle, areaFom, maxCycles];
Process.SetPriority[p]};

OrientImproveWL: PUBLIC PROC [handle: SC.Handle, maxCycles: INT] = {

p: Process.Priority _ Process.GetPriority[];
Process.SetPriority[Process.priorityBackground];
SCPrivate.OrientImprove[handle, wlFom, maxCycles];
Process.SetPriority[p]};

FTImprove: PUBLIC PROC [handle: SC.Handle, maxCycles: INT] = {

p: Process.Priority _ Process.GetPriority[];
Process.SetPriority[Process.priorityBackground];
SCPrivate.FTImprove[handle, wlFom, maxCycles];
Process.SetPriority[p]};

SAInitialPlace: PUBLIC PROC [handle: SC.Handle, widthFactor: REAL, seed: INT] RETURNS [initialResult: SC.SAInitialResult] = {

p: Process.Priority _ Process.GetPriority[];
Process.SetPriority[Process.priorityBackground];
initialResult _ SCPrivate.SAInitialPlace[handle, widthFactor, seed];
Process.SetPriority[p]};

SAGetParms: PUBLIC PROC [handle: SC.Handle, initialResult: SC.SAInitialResult, cellType: Core.CellType] RETURNS [saParms: SC.SAParms] = {

p: Process.Priority _ Process.GetPriority[];
Process.SetPriority[Process.priorityBackground];
saParms _ SCPrivate.SAGetParms[handle, initialResult, cellType];
Process.SetPriority[p]};

SAPlaceImprove: PUBLIC PROC [handle: SC.Handle, saParms: SC.SAParms, widthFactor: REAL, seed: INT] = {

p: Process.Priority _ Process.GetPriority[];
Process.SetPriority[Process.priorityBackground];
SCPrivate.SAPlaceImprove[handle, saParms, widthFactor, seed];
Process.SetPriority[p]};

SAPlaceImproveM: PUBLIC PROC [handle: SC.Handle, saParms: SC.SAParms, widthFactor: REAL, seed: INT] = {

p: Process.Priority _ Process.GetPriority[];
Process.SetPriority[Process.priorityBackground];
SCPrivate.SAPlaceImproveM[handle, saParms, widthFactor, seed];
Process.SetPriority[p]};

PlaceImprove: PUBLIC PROC [handle: SC.Handle, maxCycles: INT] = {

p: Process.Priority _ Process.GetPriority[];
Process.SetPriority[Process.priorityBackground];
SCPrivate.PlaceImprove[handle, maxCycles];
Process.SetPriority[p]};

GlobalRoute: PUBLIC PROC [handle: SC.Handle] = {
p: Process.Priority _ Process.GetPriority[];
Process.SetPriority[Process.priorityBackground];
SCSmash.RemoveSmash[handle];
SCSmash.SmashAllNets[handle, FALSE];
Process.SetPriority[p]};

DetailRoute: PUBLIC PROC [handle: SC.Handle] RETURNS [result: SC.Result] = {
p: Process.Priority _ Process.GetPriority[];
Process.SetPriority[Process.priorityBackground];
result _ SCPrivate.DetailRoute[handle];
Process.SetPriority[p]};

CreateLayout: PUBLIC PROC [technologyKey: ATOM, horizLayer, vertLayer: Rope.ROPE, rowDirection: SC.Direction, numRows: NAT, cellType: Core.CellType, flattenCellType: RTCoreUtil.FlattenCellTypeProc, libName: Rope.ROPE _ NIL, name: Rope.ROPE _ NIL] RETURNS [object: CD.Object] = {
result: SC.Result;
widthFactor: REAL _ MAX[1.0, MIN[2.0, RTCoreUtil.GetCoreRealProp[cellType, SC.widthFactorProp, 1.1]]];

designRules: SC.DesignRules _ SC.CreateDesignRules[technologyKey, horizLayer, vertLayer, rowDirection];
handle: SC.Handle _ SC.CreateHandle[cellType, flattenCellType, libName, designRules, name, extractMode.decoration];
SC.InitialPlace[handle, RTCoreUtil.GetCoreIntProp[cellType, SC.numRows, 0]];
SC.SAPlaceImprove[handle, SC.SAGetParms[handle, SC.SAInitialPlace[handle, widthFactor], cellType], widthFactor];
SC.GlobalRoute[handle];
result _ SC.DetailRoute[handle];
RETURN [result.object]};

Destroy: PUBLIC PROC [handle: SC.Handle] ~ {
SCPrivate.DestroyLayout[handle];
SCPrivate.DestroyStructure[handle];
SCUtil.DestroyRules[handle];
SCUtil.DestroyParms[handle];
handle.name _ NIL;
handle.coreCellType _ NIL};
StandardCellRoute: PUBLIC PWCore.LayoutProc = {
result: SC.Result;
hMaterial: Rope.ROPE _ "metal";
vMaterial: Rope.ROPE _ "metal2";
widthFactor: REAL _ MAX[1.0, MIN[2.0, RTCoreUtil.GetCoreRealProp[cellType, SC.widthFactorProp, 1.1]]];

rules: SC.DesignRules _ SC.CreateDesignRules[technologyKey, hMaterial, vMaterial, horizontal];
handle: SC.Handle _ SC.CreateHandle[cellType: cellType, flattenCellType: RTCoreUtil.defaultFlatten, libName: libName, designRules: rules, decoration: extractMode.decoration];
CoreProperties.PutCellTypeProp[cellType, SC.handleAtom, handle];
SCUtil.ReadTWPlace[handle: handle];
SC.InitialPlace[handle, RTCoreUtil.GetCoreIntProp[cellType, SC.numRows, 0]];
SC.GlobalRoute[handle];
-- SC.FTImprove[handle, 10];
result _ SC.DetailRoute[handle];
RETURN[result.object]};

StandardCellPlace: PUBLIC PWCore.LayoutProc = {
hMaterial: Rope.ROPE _ "metal";
vMaterial: Rope.ROPE _ "metal2";

rules: SC.DesignRules _ SC.CreateDesignRules[technologyKey, hMaterial, vMaterial, horizontal];
handle: SC.Handle _ SC.CreateHandle[cellType: cellType, flattenCellType: RTCoreUtil.defaultFlatten, libName: libName, designRules: rules, decoration: extractMode.decoration];
CoreProperties.PutCellTypeProp[cellType, SC.handleAtom, handle];
SC.InitialPlace[handle, RTCoreUtil.GetCoreIntProp[cellType, SC.numRows, 0]];
SCUtil.WriteTWFiles[handle: handle];
RETURN[NIL]};

StandardCellLayout: PUBLIC PWCore.LayoutProc = {
result: SC.Result;
saParms: SC.SAParms;
initialResult: SC.SAInitialResult;
hMaterial: Rope.ROPE _ "metal";
vMaterial: Rope.ROPE _ "metal2";
widthFactor: REAL _ MAX[1.0, MIN[2.0, RTCoreUtil.GetCoreRealProp[cellType, SC.widthFactorProp, 1.1]]];

rules: SC.DesignRules _ SC.CreateDesignRules[technologyKey, hMaterial, vMaterial, horizontal];
handle: SC.Handle _ SC.CreateHandle[cellType: cellType, flattenCellType: RTCoreUtil.defaultFlatten, libName: libName, designRules: rules, decoration: extractMode.decoration];
CoreProperties.PutCellTypeProp[cellType, SC.handleAtom, handle];
SC.InitialPlace[handle, RTCoreUtil.GetCoreIntProp[cellType, SC.numRows, 0]];
initialResult _ SC.SAInitialPlace[handle, widthFactor];
saParms _ SC.SAGetParms[handle, initialResult, cellType];
SC.SAPlaceImprove[handle: handle, saParms: saParms, widthFactor: widthFactor];
SC.PlaceImprove[handle: handle, maxCycles: 1];
SC.GlobalRoute[handle];
SC.PlaceImprove[handle: handle, maxCycles: 1];
-- SCSmash.CheckFts[handle];
-- SCSmash.CheckExits[handle];
result _ SC.DetailRoute[handle];
RETURN[result.object]};

StandardCellLayoutTW: PUBLIC PWCore.LayoutProc = {
result: SC.Result;
hMaterial: Rope.ROPE _ "metal";
vMaterial: Rope.ROPE _ "metal2";
widthFactor: REAL _ MAX[1.0, MIN[2.0, RTCoreUtil.GetCoreRealProp[cellType, SC.widthFactorProp, 1.1]]];

rules: SC.DesignRules _ SC.CreateDesignRules[technologyKey, hMaterial, vMaterial, horizontal];
handle: SC.Handle _ SC.CreateHandle[cellType: cellType, flattenCellType: RTCoreUtil.defaultFlatten, libName: libName, designRules: rules, decoration: extractMode.decoration];
CoreProperties.PutCellTypeProp[cellType, SC.handleAtom, handle];
SC.InitialPlace[handle, RTCoreUtil.GetCoreIntProp[cellType, SC.numRows, 0]];
SCUtil.WriteTWFiles[handle: handle];
IF TWOps.TWIt[handle.name, TRUE]#NIL THEN ERROR;
SCUtil.ReadTWPlace[handle: handle];
SC.InitialPlace[handle, RTCoreUtil.GetCoreIntProp[cellType, SC.numRows, 0]];
-- initialResult _ SC.SAInitialPlace[handle, widthFactor];
-- saParms _ SC.SAGetParms[handle, initialResult, cellType];
-- SC.SAPlaceImprove[handle: handle, saParms: saParms, widthFactor: widthFactor];
-- SC.PlaceImprove[handle: handle, maxCycles: 1];
SC.GlobalRoute[handle];
-- SC.PlaceImprove[handle: handle, maxCycles: 1];
-- SCSmash.CheckFts[handle];
-- SCSmash.CheckExits[handle];
-- SC.FTImprove[handle, 10];
result _ SC.DetailRoute[handle];
RETURN[result.object]};

StandardCellDecorate: PUBLIC PWCore.DecorateProc = {

SmashPins: PROC [wire: Core.Wire] = {CoreGeometry.PutPins[extractMode.decoration, wire, NIL]};

WireToLabels: PROC [wire: Core.Wire] RETURNS [LIST OF Route.Label] ~ {
net: SCPrivate.Net _ SCUtil.FindNetByWire[handle, wire];
RETURN[IF net.numberOfRegions > 0 THEN LIST[net.name] ELSE net.brokenNets]};

ComparePos: PROC [pos1, pos2: CD.Position] RETURNS [BOOL]  ~ {
IF pos1.y = pos2.y THEN RETURN[pos1.x < pos2.x]
ELSE RETURN[pos1.y < pos2.y]};

CompareCT: CoreRoute.CompareFlatCTProc ~ {
flatName1: Rope.ROPE _ CoreFlat.CellTypePathRope[root, flatCT1];
instance1: SCPrivate.Instance _ SCUtil.FindInstance[handle, flatName1];
flatName2: Rope.ROPE _ CoreFlat.CellTypePathRope[root, flatCT2];
instance2: SCPrivate.Instance _ SCUtil.FindInstance[handle, flatName2];
IF instance1.curRow = instance2.curRow THEN RETURN[instance1.curPos < instance2.curPos]
ELSE RETURN[instance1.curRow < instance2.curRow]};

handle: SC.Handle _ NARROW[CoreProperties.GetCellTypeProp[cellType, SC.handleAtom]];
CoreOps.VisitRootAtomics[cellType.public, SmashPins];
IF handle # NIL THEN {
CoreRoute.DecorateRoutedArea[cellType: cellType, obj: obj, wireToLabels: WireToLabels, comparePos: ComparePos, compareCT: CompareCT];
SC.Destroy[handle]}};

StandardCellAttibutes: PUBLIC PWCore.AttributesProc = {-- [cellType: Core.CellType]

FindSideForEachPin: CoreGeometry.EachWirePinProc = {

PushPropOnAtomic: PROC [wire: Core.Wire] ~ {
sideVal: REF ANY _ CoreProperties.GetWireProp[wire, SC.sideProp];
positionVal: REF ANY _ CoreProperties.GetWireProp[wire, SC.positionProp];
CoreProperties.PutWireProp[wire, SC.sideProp, IF sideVal=NIL THEN ref ELSE sideVal];
CoreProperties.PutWireProp[wire, SC.sideProp, IF positionVal=NIL THEN NEW[INT _ min] ELSE positionVal]};

ref: REF _ SELECT side FROM
bottom => SC.bottomSideValue,
top => SC.topSideValue,
right => SC.rightSideValue,
left => SC.leftSideValue,
ENDCASE => SC.noSideValue;
IF wire.size=0 THEN PushPropOnAtomic[wire] 
ELSE CoreOps.VisitRootAtomics[wire, PushPropOnAtomic]};

decoration: CoreGeometry.Decoration _ Sisyph.mode.decoration;
DO
IF CoreGeometry.HasObject[decoration, cellType] THEN {
[] _ CoreGeometry.EnumerateWireSides[decoration, cellType, FindSideForEachPin];
EXIT};
IF cellType.class.recast = NIL THEN EXIT;
cellType _ CoreOps.Recast[cellType]
ENDLOOP}; 

SCLayoutAtom: ATOM _ PWCore.RegisterLayoutAtom[$SC, StandardCellLayout, StandardCellDecorate, StandardCellAttibutes];
SCPlaceAtom: ATOM _ PWCore.RegisterLayoutAtom[$SCPlace, StandardCellPlace, StandardCellDecorate, StandardCellAttibutes];
SCRouteAtom: ATOM _ PWCore.RegisterLayoutAtom[$SCRoute, StandardCellRoute, StandardCellDecorate, StandardCellAttibutes];
SCTWAtom: ATOM _ PWCore.RegisterLayoutAtom[$SCRemote, StandardCellLayoutTW, StandardCellDecorate, StandardCellAttibutes];

technologyKey: ATOM _ $cmosB;		-- $cmosA or $cmosB
libName: Rope.ROPE _ "CMOSB";
extractMode: Sinix.Mode _ PWCore.extractMode;
handleAtom: PUBLIC ATOM _ CoreProperties.RegisterProperty[$SCHandle];
numRows: PUBLIC ATOM _ $numRows;
sideProp: PUBLIC ATOM _ $Side;
bottomSideValue: PUBLIC ATOM _ $bottom;
rightSideValue: PUBLIC ATOM _ $right;
topSideValue: PUBLIC ATOM _ $top;
leftSideValue: PUBLIC ATOM _ $left;
noSideValue: PUBLIC ATOM _ $none;
rowProp: PUBLIC ATOM _ $Row;
positionProp: PUBLIC ATOM _ $Position;
usePublicPositionsProp: PUBLIC ATOM _ $UsePublicPositions;
investmentProp: PUBLIC ATOM _ $Investment;
veryLongValue: PUBLIC ATOM _ $veryLong;
longValue: PUBLIC ATOM _ $long;
mediumValue: PUBLIC ATOM _ $medium;
shortValue: PUBLIC ATOM _ $short;
veryShortValue: PUBLIC ATOM _ $veryShort;
t0SA: PUBLIC ATOM _ $t0SA;
maxTStepSA: PUBLIC ATOM _ $maxTStepSA;
lambdaSA: PUBLIC ATOM _ $lambdaSA;
tableSizeSA: PUBLIC ATOM _ $tableSizeSA;
limitSA: PUBLIC ATOM _ $limitSA;
widthFactorProp: PUBLIC ATOM _ $widthFactor;
bottomMaxExits: PUBLIC ATOM _ $BottomMaxExits;
rightMaxExits: PUBLIC ATOM _ $RightMaxExits;
topMaxExits: PUBLIC ATOM _ $TopMaxExits;
leftMaxExits: PUBLIC ATOM _ $LeftMaxExits;
bottomExitSpacing: PUBLIC ATOM _ $BottomExitSpacing;
rightExitSpacing: PUBLIC ATOM _ $RightExitSpacing;
topExitSpacing: PUBLIC ATOM _ $TopExitSpacing;
leftExitSpacing: PUBLIC ATOM _ $LeftExitSpacing;
interestingProperties: PUBLIC RTCoreUtil.PropertyKeys _ NEW[RTCoreUtil.PropertyKeysRec[20]];
interestingProperties.p[0] _ SC.sideProp;
interestingProperties.p[1] _ SC.rowProp;
interestingProperties.p[2] _ SC.positionProp;
interestingProperties.p[3] _ SC.numRows;
interestingProperties.p[4] _ SC.bottomMaxExits;
interestingProperties.p[5] _ SC.rightMaxExits;
interestingProperties.p[6] _ SC.topMaxExits;
interestingProperties.p[7] _ SC.leftMaxExits;
interestingProperties.p[8] _ SC.bottomExitSpacing;
interestingProperties.p[9] _ SC.rightExitSpacing;
interestingProperties.p[10] _ SC.topExitSpacing;
interestingProperties.p[11] _ SC.leftExitSpacing;
interestingProperties.p[12] _ SC.investmentProp;
interestingProperties.p[13] _ SC.t0SA;
interestingProperties.p[14] _ SC.maxTStepSA;
interestingProperties.p[15] _ SC.lambdaSA;
interestingProperties.p[16] _ SC.tableSizeSA;
interestingProperties.p[17] _ SC.limitSA;
interestingProperties.p[18] _ SC.widthFactorProp;
interestingProperties.p[19] _ SC.usePublicPositionsProp;
}. 




6SCImpl.mesa
Copyright Ó 1985, 1986, 1987 by Xerox Corporation.  All rights reserved.
Bryan Preas, August 14, 1986 5:07:05 pm PDT 
Last Edited by: Bryan Preas June 15, 1987 6:21:04 pm PDT
Christian Le Cocq June 24, 1987 10:46:09 am PDT
Errors
Design Rules
Define the standard cell design rules.  technologyKey values are predefinded for now. horizLayer, vertLayer should be "poly", "metal" or "metal2".
Standard Cell Handles and Results
Create a standard cell design.  The standard cell design definition includes the design rules (conductor and via widths and spacings) and the circuit definition.
set up the layout data

set up the structure data
Standard Cell Optimization and Construction
Determine an initial placement for the instances.

Improve the positions of instances whithin rows.
Improve the positions of instances whithin rows using wire lenght as figure of merit.
Improve the orientation of instances.
Improve the orientation of instances using wire lenght as figure of merit.
Improve the positions of instances whithin rows.
Initialize for simulated annealing improvement.
determine parameters for simulated placement.
Improve the placement for the instances (one at a time) by simulated annealing.
Improve the placement for the instances (one at a time) by simulated annealing.
Improve the placement for the instances by exhaustive search.
Determine strategic paths for the wiring that must cross cell rows.

Determine actual wiring paths.  

Create a standard cell object by performing the above operations

Remove circular references so garbage collection can work

PWCore Interface
-- The cellType to layout is a record cellType containing elements from MSI; the layout proc flattens the Core description and calls the standard cell router.  Placement is obtained from timberwolf.
initialResult _ SC.SAInitialPlace[handle, widthFactor];
saParms _ SC.SAGetParms[handle, initialResult, cellType];
SC.SAPlaceImprove[handle: handle, saParms: saParms, widthFactor: widthFactor];
SC.PlaceImprove[handle: handle, maxCycles: 1];
SC.PlaceImprove[handle: handle, maxCycles: 1];
SC.PosImproveWL[handle, 1];
SC.OrientImproveWL[handle, 1];
SC.PosImprove[handle, 1];
SC.OrientImprove[handle, 1];
SCSmash.CheckFts[handle];
SCSmash.CheckExits[handle];
-- The cellType to layout is a record cellType containing elements from MSI; the layout proc flattens the Core description and calls the standard cell placer.
-- The cellType to layout is a record cellType containing elements from MSI; the layout proc flattens the Core description and calls the standard cell placer and router.
SC.PosImproveWL[handle, 1];
SC.OrientImproveWL[handle, 1];
SC.PosImprove[handle, 1];
SC.OrientImprove[handle, 1];
-- The cellType to layout is a record cellType containing elements from MSI; the layout proc flattens the Core description and calls the standard cell placer and router.
SC.PosImproveWL[handle, 1];
SC.OrientImproveWL[handle, 1];
SC.PosImprove[handle, 1];
SC.OrientImprove[handle, 1];
PROC [cellType: CellType, obj: Object];
call back proc to map wires to labels
call back proc to order objects
call back proc to order cellTypes
PROC [root: Core.CellType, flatCT1, flatCT2: CoreFlat.FlatCellTypeRec] RETURNS [BOOL];
Puts on public wires their side as a property
[wire: Core.Wire, instance: CD.Instance, min: INT, max: INT, side: CoreGeometry.Side, layer: CD.Layer] RETURNS [quit: BOOL _ FALSE]
Properties
Used to specify the number of rows for a standard cell assembly.  Should be a property on Core cellType being laid out
Used to specify the side on which a public pin is to be placed.  sideProp with (mumble)Value should be a property/value on a public wire
Used to specify the row on which a logic cell is to be placed. rowProp and and integer row number should be a property/value on a logic cell instance
Used to specify the position of a logic within a row or of an public pin on a side.  May be used on public wire or a logic cell instance.
Used to specify the position of a public in the schematic is to be retained int the layout
Used to specify the investment to make in placement.
Used to specify simulated aneealing partameters to be used for placement
Used to specify the maximum number or publics on a side.
Used to specify the HINT for publics spacing on a side.
Cedar does not allow initialization of a sequence in the NEW!
Used to specify all the properties that are interesting to SC
�ʤ˜š
œ™Jš
œH™HJšœ(Ïkœ
™,Icodešœ�™8K™/—J˜š
�	˜	Jš�œ}�œs˜ô
—J˜šÐbnœ�œ
�œ
˜Kš�œ
�œq�œk˜è
Kš�œ
�˜
Kš�œ
�œ˜
K˜Kšœ�œ�œ
˜—
head™KšÏnœ�œ
�œ�œ-�œ�œ�œ
˜aKšŸœ�œ
�œ
�œ-�œ�œ�œ
˜d—™šŸœ�œ
�œ�œ�œ�œ�œ�œ˜š
Kš
œ’
™’
K˜Kš
�˜Kšœ�œ;˜EKšœ�œ:˜DKš
œ>˜>Kšœ�œ
�œó
˜‡Kš
œF˜FKš
œH˜HKš�œ
˜——™!šŸœ�œ
�œZ�œ�œ�œ'�œ
�œ
˜é
K™¡
K˜Kš
�˜Kšœ�œ
�œ'˜JK˜Kš�œ�œ
�œ
�œ*˜FKš�œ�œ
�œ
�œ,˜EKšœ	�œ
�œ˜Kš	œ�œ�œ
�œ�œ#˜MKš
œ˜Kš
œ˜K˜Kš
œ˜Kš
œ˜K˜Kš
œ™š�œ*�˜0Kš�œ9˜;—K™Kš
œ™š�œH�˜NKš�œ<˜>—Kš�œ
˜——™+J˜š
Ÿœ�œ
�œ
�œ�œ	˜CK™1K™Kšœ#�œ˜=Kš
œ,˜,Kš
œ0˜0Kš
œ˜Kšœ�œ˜%Kšœ[�œ˜aKš
œ˜Kš
œ˜Kš
œ]˜]Kš
œ"˜"Kš
œ˜Kš
œ.˜.Kš
œ0˜0K˜Kš�œ�œ#˜0Kš
œN˜NKš
œ˜—K˜š
Ÿ
œ�œ
�œ
�œ�œ˜?K™0K˜Kš
œ,˜,Kš
œ0˜0Kš
œ1˜1š
œ˜K˜——š
Ÿœ�œ
�œ
�œ�œ˜AK™UK˜Kš
œ,˜,Kš
œ0˜0Kš
œ/˜/š
œ˜K˜——š
Ÿ
œ�œ
�œ
�œ�œ˜BK™%K˜Kš
œ,˜,Kš
œ0˜0Kš
œ4˜4š
œ˜K˜——š
Ÿœ�œ
�œ
�œ�œ˜DK™JK˜Kš
œ,˜,Kš
œ0˜0Kš
œ2˜2š
œ˜K˜——š
Ÿ	œ�œ
�œ
�œ�œ˜>K™0K˜Kš
œ,˜,Kš
œ0˜0Kš
œ.˜.š
œ˜K˜——šŸœ�œ
�œ
�œ�œ�œ�œ�œ˜}K™/K˜Kš
œ,˜,Kš
œ0˜0Kš
œD˜Dš
œ˜K˜——šŸ
œ�œ
�œ
�œ�œ+�œ�œ
˜‰
K™-K˜Kš
œ,˜,Kš
œ0˜0Kš
œ@˜@Kš
œ˜K˜—šŸœ�œ
�œ
�œ�œ�œ�œ˜fK™OK˜Kš
œ,˜,Kš
œ0˜0Kš
œ=˜=š
œ˜K˜——šŸœ�œ
�œ
�œ�œ�œ�œ˜gK™OK˜Kš
œ,˜,Kš
œ0˜0Kš
œ>˜>š
œ˜K˜——š
Ÿœ�œ
�œ
�œ�œ˜AK™=K˜Kš
œ,˜,Kš
œ0˜0Kš
œ*˜*š
œ˜K˜——šŸœ�œ
�œ
�œ˜0K™CK™Kš
œ,˜,Kš
œ0˜0Kš
œ˜Kšœ�œ˜$Kš
œ˜—K˜šŸœ�œ
�œ
�œ	�œ
�œ˜LKš
œ ™ K™Kš
œ,˜,Kš
œ0˜0Kš
œ'˜'Kš
œ˜K˜—šŸœ�œ
�œ�œ�œ�œ�œZ�œ�œ
�œ�œ�œ
�œ˜–Kš
œ@™@K™Kšœ�œ˜Kš	œ
�œ�œ�œ+�œ˜fK˜Kšœ
�œ�œG˜gKšœ�œ
�œ]˜sKš�œ:�œ˜LKš�œ�œ�œ>˜pKš�œ˜Kšœ	�œ˜ Kš�œ˜—K˜šŸœ�œ
�œ
�œ˜,Kš
œ9™9K™Kš
œ ˜ Kš
œ#˜#Kš
œ˜Kš
œ˜Kšœ�œ
˜Kšœ�œ˜——™Kš
ÏcÆ
™Æ
šŸœ�œ˜/Kšœ�œ˜Kšœ�œ˜Kšœ�œ˜ Kš	œ
�œ�œ�œ+�œ˜fK˜Kšœ�œ�œD˜^Kšœ�œ
�œ˜
˜®
Kšœ)�œ˜@Kš
œ#˜#Kš�œ:�œ˜LKš
œ7™7Kš
œ9™9Kš
œN™NKš
œ.™.Kš�œ˜Kš
œ.™.Kš�œ™Kš�œ™Kš�œ™Kš�œ™Kš
œ™Kš
œ™Kš�œ˜Kšœ	�œ˜ Kš�œ˜K˜—Kš
 ž
™ž
šŸœ�œ˜/Kšœ�œ˜Kšœ�œ˜ K˜Kšœ�œ�œD˜^Kšœ�œ
�œ˜
˜®
Kšœ)�œ˜@Kš�œ:�œ˜LKš
œ$˜$Kš�œ˜
K˜—Kš
 ©
™©
šŸœ�œ˜0Kšœ�œ˜Kšœ	�œ	˜Kšœ�œ˜"Kšœ�œ˜Kšœ�œ˜ Kš	œ
�œ�œ�œ+�œ˜fK˜Kšœ�œ�œD˜^Kšœ�œ
�œ˜
˜®
Kšœ)�œ˜@Kš�œ:�œ˜LKšœ�œ%˜7Kšœ
�œ-˜9Kš�œL˜NKš�œ,˜.Kš�œ˜Kš�œ,˜.Kš
œ™Kš
œ™Kš�œ™Kš�œ™Kš
œ˜Kš
œ˜Kšœ	�œ˜ Kš�œ˜K˜—Kš
 ©
™©
šŸœ�œ˜2Kšœ�œ˜Kšœ�œ˜Kšœ�œ˜ Kš	œ
�œ�œ�œ+�œ˜fK˜Kšœ�œ�œD˜^Kšœ�œ
�œ˜
˜®
Kšœ)�œ˜@Kš�œ:�œ˜LKš
œ$˜$Jš
�œ�œ�œ
�œ
�œ
˜0Kš
œ#˜#Kš�œ:�œ˜LKšœ�œ%˜:Kšœ
�œ-˜<Kš�œL˜QKš�œ,˜1Kš�œ˜Kš�œ,˜1Kš
œ™Kš
œ™Kš�œ™Kš�œ™Kš
œ˜Kš
œ˜Kš�œ˜Kšœ	�œ˜ Kš�œ˜K˜—šŸœ�œ˜4Kš
œ'™'K˜šŸ	œ�œI�œ˜^K˜—Kš
œ%™%š
Ÿœ�œ�œ�œ
�œ˜FKš
œ8˜8Kš
�œ
�œ�œ
�œ�œ˜LK˜—Kš
œ™š
Ÿ
œ�œ�œ�œ�œ˜>Kš�œ�œ
�œ˜/Kš�œ
�œ˜K˜—Kš
œ!™!šŸ	œ!˜*Kš�œC�œ�œ™VKšœ�œ,˜@Kš
œG˜GKšœ�œ,˜@Kš
œG˜GKš�œ%�œ
�œ%˜WKš�œ
�œ'˜2—K˜Kšœ�œ
�œ*�œ˜TKš
œ5˜5š�œ
�œ
�œ˜Kš
œ…
˜…
Kš�œ˜——K˜K•StartOfExpansion6 -- [cellType: Core.CellType] RETURNS [obj: CD.Object]š
œ-™-šŸœ�œ ˜SK˜šŸœ"˜4Kšœ�œ�œ�œ"�œ�œ�œ�œ
™ƒ
K–‡
 -- [wire: Core.Wire, instance: CD.Instance, min: INT, max: INT, side: CoreGeometry.Side, layer: CD.Layer] RETURNS [quit: BOOL _ FALSE]˜šŸœ�œ˜,Kšœ	�œ
�œ$�œ˜AKšœ
�œ
�œ$�œ˜IKšœ!�œ�œ	�œ
�œ�œ
˜TKšœ!�œ�œ
�œ
�œ
�œ
�œ�œ˜h—K˜šœ�œ�œ�˜Kšœ
�œ˜Kšœ�œ˜Kšœ	�œ˜Kšœ�œ˜Kš�œ�œ
˜—Kš�œ
�œ˜+Kš�œ3˜7—K˜Kš
œ=˜=š
�˜š�œ.�œ˜6Kš
œO˜OKš�œ˜—Kš�œ�œ
�œ
�œ
˜)K˜#Kš�œ˜
—K˜—KšŸœ�œc˜uKšŸœ�œg˜xKšŸœ�œg˜xKšŸœ�œk˜yK˜Kšœ�œ ˜2Kšœ�œ˜Kš
œ-˜-—™
Kšœ�œ
�œ.˜Ešœ	�œ
�œ˜ Kš
œv™v—šœ
�œ
�œ	˜Kšœ�œ
�œ˜'Kšœ�œ
�œ
˜%Kšœ�œ
�œ˜!Kšœ�œ
�œ	˜#šœ
�œ
�œ	˜!Kš
œˆ
™ˆ
——šœ	�œ
�œ˜Kš
ϥ
™•
—šœ�œ
�œ
˜&Kš
œ‰
™‰
—šœ�œ
�œ˜:Kš
œZ™Z—šœ�œ
�œ˜*Kšœ�œ
�œ
˜'Kšœ�œ
�œ	˜Kšœ
�œ
�œ˜#Kšœ�œ
�œ
˜!šœ�œ
�œ˜)Kš
œ4™4—Kšœ�œ
�œ	˜Kšœ�œ
�œ˜&Kšœ
�œ
�œ
˜"Kšœ
�œ
�œ˜(šœ	�œ
�œ˜ Kš
œH™H——Kšœ�œ
�œ˜,Kšœ�œ
�œ˜.Kšœ�œ
�œ˜,Kšœ
�œ
�œ˜(šœ�œ
�œ˜*Kš
œ8™8—Kšœ�œ
�œ˜4Kšœ�œ
�œ˜2Kšœ�œ
�œ˜.šœ�œ
�œ˜0Kšœ�œ™7—šœ�œ�œ!˜\Kšœ9�œ
™=Kšœ�œ
˜)Kšœ�œ	˜(Kšœ�œ˜-Kšœ�œ	˜(Kšœ�œ˜/Kšœ�œ˜.Kšœ�œ
˜,Kšœ�œ˜-Kšœ�œ˜2Kšœ�œ˜1Kšœ�œ˜0Kšœ�œ˜1Kšœ�œ˜0Kšœ�œ˜&Kšœ�œ˜,Kšœ�œ
˜*Kšœ�œ
˜-Kšœ�œ	˜)Kšœ�œ˜1šœ�œ˜8Kšœ;�™=——Jš
œ˜—J˜J˜J˜J˜—…—@üdÖ