DIRECTORY
Convert, IO, Rope, Real, SC, SCChanUtil, SCInitialPlace, SCInstUtil, SCPlaceUtil, SCPrivate, SCRowUtil, TerminalIO;

SCPrePlaceImpl: CEDAR PROGRAM
IMPORTS Convert, IO, Real, Rope, SC, SCChanUtil, SCInstUtil, SCPlaceUtil, SCRowUtil, TerminalIO
EXPORTS SCInitialPlace
SHARES SC =

BEGIN
debug: BOOLEAN _ FALSE;

ChooseNonZero: PROCEDURE [num1, num2, num3: SC.Number _ 0]
RETURNS[ result: SC.Number] = {
IF num1 # 0 THEN result _ num1
ELSE IF num2 # 0 THEN result _ num2
ELSE result _ num3};

InitBpSide: PROCEDURE [handle: SC.Handle] = {
SideProc: SCRowUtil.EachSideProc = {
bpRow.maxBpsOnSide _ bpRow.initMaxBpsOnSide;
bpRow.size.p _ 0;
bpRow.size.q _ 0;
bpRow.dimInvalid _ FALSE;
bpRow.nBpsOnSide _ 0;
bpRow.fnlBpFxd _ FALSE;
bpRow.initBpFxd _ FALSE};

[] _ SCRowUtil.EnumerateSides[handle, SideProc]};

InitLgRow: PROCEDURE [handle: SC.Handle] = {
RowProc: SCRowUtil.EachRowProc = {
lgRow.size.p _ 0;
lgRow.size.q _ 0;
lgRow.dimInvalid _ FALSE;
lgRow.nLgsOnRow _ 0;
lgRow.nFtsOnRow _ 0;
lgRow.fnlLgFxd _ FALSE;
lgRow.initLgFxd _ FALSE};

[] _ SCRowUtil.EnumerateRows[handle, RowProc]};

PrePlaceComps: PROCEDURE [handle: SC.Handle, initialized: BOOLEAN] =  {

IntBounds: PROCEDURE[checkNum, lowLimit, upLimit, default: SC.Number, name: Rope.ROPE]
RETURNS[ result: SC.Number] = {

IF lowLimit <= checkNum AND checkNum <= upLimit THEN
result _ checkNum
ELSE {
result _ default;
TerminalIO.PutRope[Rope.Cat[Rope.Cat[" instance: ", name, " variable: ", Convert.RopeFromInt[checkNum], " limits = "], Rope.Cat[Convert.RopeFromInt[lowLimit], Convert.RopeFromInt[upLimit], "\n"]]]}};

SideBounds: PROCEDURE[checkNum, lowLimit, upLimit, default: SC.SideOrNone, name: Rope.ROPE]
RETURNS[ result: SC.SideOrNone] = {

IF lowLimit <= checkNum AND checkNum <= upLimit THEN
result _ checkNum
ELSE {
result _ default;
TerminalIO.PutRope[Rope.Cat[Rope.Cat[" instance: ", name, " variable: ", SCRowUtil.sideName[checkNum], " limits: "], Rope.Cat[SCRowUtil.sideName[lowLimit], " .. ", SCRowUtil.sideName[upLimit], "\n"]]]}};

PrePlacLg: PROCEDURE[handle: SC.Handle, instance: SCPrivate.Instance, initialized: BOOLEAN] = {

layoutData: SCPrivate.LayoutData _ NARROW[handle.layoutData];
lgRows: SCPrivate.LgRows _ layoutData.lgRows;
iRow, fRow: SCPrivate.ZMaxRowSr;

IF initialized THEN {
instance.curRow _ instance.initRow;
instance.curPos _ instance.initPos;
instance.curOrien _ instance.initOrien};
 
fRow _ IntBounds[instance.fnlRow, 0, SCPrivate.maxLgRows, 0, instance.name];
iRow _ IntBounds[instance.initRow, 0, SCPrivate.maxLgRows, 0, instance.name];
IF instance.preRow > 0 THEN {
instance.preRow _ IntBounds[instance.preRow, 1, SCPrivate.maxLgRows, 0, instance.name];
instance.prePos _ IntBounds[instance.prePos, 1, SCPrivate.maxPos, 0, instance.name];
instance.preOrien _ IntBounds[instance.preOrien, 1, SCPrivate.maxOrien, SCInstUtil.defltLgOrien, instance.name];
IF instance.preRow = 0 OR instance.prePos = 0 OR instance.preOrien = 0 THEN {
instance.preRow _ 0;
instance.prePos _ 0;
instance.preOrien _ 0}}
ELSE IF fRow > 0 THEN {
instance.preRow _ fRow;
instance.prePos _ IntBounds[ChooseNonZero[instance.fnlPos, instance.initPos], 0, SCPrivate.maxPos, 0, instance.name];
instance.preOrien _ IntBounds[ChooseNonZero[instance.fnlOrien, instance.initOrien, SCInstUtil.defltLgOrien], 1, SCPrivate.maxOrien, SCInstUtil.defltLgOrien, instance.name]}
ELSE IF iRow > 0 THEN {
instance.preRow _ iRow;
instance.prePos _ IntBounds[ChooseNonZero[instance.fnlPos, instance.initPos], 0, SCPrivate.maxPos, 0, instance.name];
instance.preOrien _ IntBounds[ChooseNonZero[instance.fnlOrien, instance.initOrien, SCInstUtil.defltLgOrien], 1, SCPrivate.maxOrien, SCInstUtil.defltLgOrien, instance.name]};

IF instance.preRow > 0 THEN SCPlaceUtil.PutLgRow[handle, instance, instance.preRow, instance.preOrien]
ELSE {instance.curRow _ 0; instance.curPos _ 0; instance.curOrien _ 0};
IF instance.preRow > 0 AND instance.prePos > 0 THEN {
IF fRow > 0 AND instance.fnlPos > 0 THEN lgRows.rows[fRow].fnlLgFxd _ TRUE;
IF iRow > 0 AND instance.initPos > 0 THEN lgRows.rows[iRow].initLgFxd _ TRUE}};

PrePlacBp: PROCEDURE[handle: SC.Handle, instance: SCPrivate.Instance, initialized:BOOLEAN] = {

layoutData: SCPrivate.LayoutData _ NARROW[handle.layoutData];
bpRows: SCPrivate.BpRows _ layoutData.bpRows;
iSide, fSide: SC.SideOrNone;

IF initialized THEN {
instance.curSide _ instance.initSide;
instance.curPos _ instance.initPos;
instance.curOrien _ instance.initOrien};
iSide _ SideBounds[instance.initSide, bottom, none, none, instance.name];
fSide _ SideBounds[instance.fnlSide, bottom, none, none, instance.name];

IF instance.preSide # none THEN {
instance.preSide _ SideBounds[instance.preSide, bottom, right, none, instance.name];
instance.prePos _ IntBounds[instance.prePos, 1, SCPrivate.maxPos, 0, instance.name];
instance.preOrien _ IntBounds[instance.preOrien, 1, SCPrivate.maxOrien, SCInstUtil.defltBpOrien[instance.preSide], instance.name];
IF instance.preSide = none OR instance.prePos = 0 OR instance.preOrien = 0 THEN {
instance.preSide _ none;
instance.prePos _ 0;
instance.preOrien _ 0}}
ELSE IF fSide # none THEN {
instance.preSide _ fSide;
instance.prePos _ IntBounds[ChooseNonZero[instance.fnlPos, instance.initPos], 0, SCPrivate.maxPos, 0, instance.name];
instance.preOrien _ IntBounds[ChooseNonZero[instance.fnlOrien, instance.initOrien, SCInstUtil.defltBpOrien[instance.preSide]], 1, SCPrivate.maxOrien, SCInstUtil.defltBpOrien[instance.preSide], instance.name]}
ELSE IF iSide # none THEN {
instance.preSide _ iSide;
instance.prePos _ IntBounds[ChooseNonZero[instance.fnlPos, instance.initPos], 0, SCPrivate.maxPos, 0, instance.name];
instance.preOrien _ IntBounds[ChooseNonZero[instance.fnlOrien, instance.initOrien, SCInstUtil.defltBpOrien[iSide]], 1, SCPrivate.maxOrien, SCInstUtil.defltBpOrien[iSide], instance.name]};

IF instance.preSide # none THEN SCPlaceUtil.PutBpSide[handle, instance, instance.preSide]
ELSE {instance.curSide _ none; instance.curPos _ 0; instance.curOrien _ 0};
IF instance.preSide # none AND instance.prePos > 0 THEN {
IF fSide # none AND instance.fnlPos > 0 THEN bpRows[fSide].fnlBpFxd _ TRUE;
IF iSide # none AND instance.initPos >0 THEN bpRows[iSide].initBpFxd _ TRUE}};

EachInstance: SCInstUtil.EachInstanceProc = {
SELECT instance.whichClass FROM
logic, ft => PrePlacLg[handle, instance, initialized];
io => PrePlacBp[handle, instance, initialized];
ENDCASE};

[] _ SCInstUtil.EnumerateAllInstances[handle, EachInstance]}; 

DetermineRows: PROCEDURE [handle: SC.Handle, numRows: NAT, routingFactor: REAL] = {

EachInstance: SCInstUtil.EachInstanceProc = {
IF instance.whichClass = logic THEN {
maxRowSpec _ MAX[instance.initRow, MAX[maxRowSpec, instance.fnlRow]];
totLinComps _ totLinComps + SCInstUtil.InstWidth[instance];
avgHeight _ avgHeight + SCInstUtil.InstHeight[instance]}};

layoutData: SCPrivate.LayoutData _ NARROW[handle.layoutData];
lgRows: SCPrivate.LgRows _ layoutData.lgRows;
structureData: SCPrivate.StructureData _ NARROW[handle.structureData];
instances: SCPrivate.Instances _ structureData.instances;
routFact: REAL = 2.5;

detRow: NAT;
maxRowSpec, avgHeight, totLinComps: SC.Number _ 0;

[] _ SCInstUtil.EnumerateAllInstances[handle, EachInstance];

avgHeight _ avgHeight /MAX[1, instances.numLogics];
IF avgHeight > 0 THEN
detRow _ MAX[1, Real.RoundI[Real.SqRt[totLinComps * avgHeight* routingFactor] / (avgHeight * routingFactor)]]
ELSE detRow _ 0;

IF numRows > 0 THEN
lgRows.count _ MIN[SC.Number[SCPrivate.maxLgRows], MAX[maxRowSpec, numRows]]
ELSE IF maxRowSpec > 0 THEN
lgRows.count _ MIN[SC.Number[SCPrivate.maxLgRows], MAX[maxRowSpec, detRow]]
ELSE
lgRows.count _ MIN[SCPrivate.maxLgRows, detRow];
lgRows.count _ MAX[1, lgRows.count];

layoutData.rowChans.count _ lgRows.count +1;
TerminalIO.PutRope["  number of rows calculation:\n"];
TerminalIO.PutF1["    maximum row specified: %g\n", IO.int[maxRowSpec]];
TerminalIO.PutF1["    computed number of rows: %g\n", IO.int[detRow]];
TerminalIO.PutF1["    number of rows specified: %g\n", IO.int[numRows]];
TerminalIO.PutF1["    number of rows used: %g\n", IO.int[lgRows.count]]}; 

DetermineSides: PROCEDURE [handle: SC.Handle] = {

SideSlots: SCRowUtil.EachSideProc = {
bpRow.maxBpsOnSide _ MAX[bpRow.initMaxBpsOnSide, bpRow.nBpsOnSide];
IF bpRow.maxBpsOnSide > 0 THEN {
totBpSlots _ totBpSlots + bpRow.maxBpsOnSide;
nSidesAvail _ nSidesAvail -1}};

SetSlots: SCRowUtil.EachSideProc = {
-- 2X is a HACK
IF bpRow.maxBpsOnSide <= 0 THEN bpRow.maxBpsOnSide _ nBps*2};

structureData: SCPrivate.StructureData _ NARROW[handle.structureData];
instances: SCPrivate.Instances _ structureData.instances;
nSidesAvail: NAT[0..4] _ 4;
totBpSlots: NAT _ 0;	
nBps: NAT;

[] _ SCRowUtil.EnumerateSides[handle, SideSlots];
IF nSidesAvail > 0 THEN
nBps _ MAX[0, (instances.numIOs - totBpSlots +3) /nSidesAvail]
ELSE {
nBps _ 0;
IF instances.numIOs > totBpSlots THEN SC.Error[callingError, "Too many IO's"]};

[] _ SCRowUtil.EnumerateSides[handle, SetSlots]}; 

PrePlace: PUBLIC PROCEDURE[handle: SC.Handle, numRows: NAT _ 0, routingFactor: REAL _ 2.5, initialized: BOOLEAN _ TRUE] = {

TerminalIO.PutRope["Pre placement\n"];
InitBpSide[handle];
InitLgRow[handle];
SCChanUtil.ClearRouteDat[handle];
PrePlaceComps[handle, initialized];
DetermineRows[handle, numRows, routingFactor];
DetermineSides[handle];
TerminalIO.PutRope["End pre placement\n"];
IF debug THEN SCPlaceUtil.WriteCurPlace[handle]}; 
END.


ΪSCPrePlaceImpl.mesa
Copyright c 1986 by Xerox Corporation.  All rights reserved.
last edited by Bryan Preas, January 18, 1987 1:56:51 pm PST
 
Choose non zero num in priority order
 
make the bonding pad rows empty
 
make the interior rows empty
pre place the components 
preplace the logic component instance 
check if this instance has a currently defined position 


check if the final position is specified 

check for initial position specified 

check if this instance restricts a row by specifying a position on a row 
preplace the bonding pad component instance 

check if this instance has a currently defined position 

check if the final position is specified 

check for initial position specified 

check to see if this bp restricts this side by having a position assigned 
determine the number of rows to use 
must use direct data access, no placement exists yet
determine the number of Bps on sides to use 
compute number of slots to put on currently empty sides 
Κπ˜š
œ™Icodešœ
Οm
œ1™<K™;—J˜š
Οk	˜	JšœžœX˜sJ˜—šΟnœžœ
ž˜Jšžœžœ<˜_Jšžœ˜Jšžœ
žœ˜J˜Jš
ž˜Jšœžœžœ
˜J˜šŸ
œž	œžœ˜:Jšžœ
žœ˜Jš
œ
™
Jš
œ%™%Jšžœ
žœ˜Jšžœ
žœ
žœ˜#Jšžœ˜—J˜šŸ
œž	œ
žœ˜-Jš
œ
™
Jš
œ™šŸœ˜$Jš
œ,˜,Jš
œ˜Jš
œ˜Jšœžœ
˜Jš
œ˜Jšœžœ
˜Jšœžœ˜J˜—Jš
œ1˜1—J˜šŸ	œž	œ
žœ˜,Jš
œ
™
Jš
œ™šŸœ˜"Jš
œ˜Jš
œ˜Jšœžœ
˜Jš
œ˜Jš
œ˜Jšœžœ
˜Jšœžœ˜J˜—Jš
œ/˜/J˜—šŸ
œž	œ
žœžœ˜GJš
œ™J˜šŸ	œž	œ'žœžœ
˜VJšžœ
žœ˜—˜šžœžœž˜4Jš
œ˜—šžœ˜Jš
œ˜Jš
œΗ
˜Η
——J˜šŸ
œž	œ'žœžœ
˜[Jšžœ
žœ˜#—˜šžœžœž˜4Jš
œ˜—šžœ˜Jš
œ˜Jš
œΛ
˜Λ
——J˜šŸ	œž	œ	žœ4žœ˜_Jš
œ&™&J˜Jšœ#žœ˜=J˜-Jš
œ ˜ J˜šžœ
žœ˜Jš
œ#˜#Jš
œ#˜#Jš
œ(˜(—J˜
Jš
œ8™8Jš
œL˜LJš
œM˜MJ™šžœžœ˜Jš
œW˜WJš
œT˜TJš
œp˜pšžœžœžœžœ˜MJš
œ˜Jš
œ˜Jš
œ˜——J™Jš
œ)™)šžœ
žœ
žœ˜Jš
œ˜Jš
œu˜uJš
œ¬
˜¬
—J™Jš
œ%™%šžœ
žœ
žœ˜Jš
œ˜Jš
œu˜uJš
œ­
˜­
—J˜JšžœžœK˜fJšžœC˜GJ™Jš
œI™Išžœžœžœ˜5Jšžœ
žœžœžœ
˜KJšžœ
žœžœžœ˜O——J˜šŸ	œž	œ	žœ3žœ˜^Jš
œ,™,J˜Jšœ#žœ˜=J˜-Jšœžœ˜J˜šžœ
žœ˜J˜%J˜#Jš
œ(˜(J™—Jš
œ8™8Jš
œI˜IJš
œH˜HJ˜šžœžœ˜!Jš
œT˜TJš
œT˜TJš
œ‚
˜‚
šžœžœžœžœ˜QJš
œ˜Jš
œ˜Jš
œ˜——J™Jš
œ)™)šžœ
žœžœ˜Jš
œ˜Jš
œu˜uJš
œΠ
˜Π
J™—Jš
œ%™%šžœ
žœžœ˜Jš
œ˜Jš
œu˜uJš
œ»
˜»
—J˜Jšžœžœ:˜YJšžœG˜KJ™Jš
œJ™Jšžœžœžœ˜9Jšžœžœžœžœ
˜KJšžœžœžœžœ˜N——J˜šŸœ!˜-šžœž˜Jš
œ6˜6Jš
œ/˜/Jšžœ˜	J˜——Jš
œ>˜>—J˜š
Ÿ
œž	œ
žœžœžœ˜SJš
œ$™$J˜šŸœ!˜-šžœžœ˜%Jšœ
žœžœ˜EJš
œ4™4Jš
œ;˜;Jš
œ:˜:—J˜—Jšœ#žœ˜=Jš
œ-˜-Jšœ)žœ˜FJš
œ9˜9Jšœ
žœ˜J˜Jšœžœ
˜Jšœ$žœ˜2J˜Jš
œ<˜<J˜Jšœžœ˜3šžœž˜Jšœ	žœa˜m—Jšžœ˜J˜šžœ
ž˜Jšœžœ
žœžœ˜L—šžœ
žœž˜Jšœžœ
žœžœ˜K—š
ž˜Jšœžœ˜0—Jšœžœ˜$J˜Jš
œ,˜,Jš
œ6˜6Jš
œH˜HJš
œF˜FJš
œH˜HJš
œJ˜JJ˜—šŸœž	œ
žœ˜1J˜Jš
œ,™,šŸ	œ˜%Jšœžœ+˜Cšžœžœ˜ Jš
œ-˜-Jš
œ˜——J˜šŸœ˜$Jš
œ˜Jšžœžœ˜=—J˜Jšœ)žœ˜FJš
œ9˜9Jšœ
žœ˜Jšœžœ˜Jšœžœ
˜
J˜Jš
œ8™8Jš
œ1˜1šžœž˜Jšœžœ4˜>—šžœ˜Jš
œ	˜	šžœžœ'˜OJ˜——Jš
œ2˜2J˜—šŸœžœ
ž	œ	žœžœžœžœžœ˜{J˜Jš
œ&˜&Jš
œ˜Jš
œ˜Jš
œ!˜!Jš
œ#˜#Jš
œ.˜.Jš
œ˜Jš
œ*˜*Jšžœžœ%˜2—šžœ
˜J˜J˜———…—$Ό1†