DIRECTORY
CD, CDCells, CDOps, CDProperties, Convert, Core, CoreGeometry, CoreOps, CoreRoute, DABasics, List, Rope, Route, RouteUtil, RTBasic, SC, SCChanUtil, SCExprGlobalRoute, SCInstUtil, SCNetUtil, SCPrivate, SCExprRoutePinsUtil, SCRowUtil, SCUtil, SCNewWidth, Sinix;

SCExprRouteImpl: CEDAR PROGRAM
IMPORTS CDCells, CDOps, CDProperties, Convert, CoreGeometry, CoreOps, CoreRoute, List, Rope, Route, RouteUtil, RTBasic, SC, SCChanUtil, SCInstUtil, SCNetUtil, SCExprRoutePinsUtil, SCRowUtil, SCUtil, SCNewWidth
 
EXPORTS SCExprGlobalRoute
SHARES SC = BEGIN
SegInChan: TYPE = REF SegInChanRec;
SegInChanRec: TYPE = RECORD [
segNum: INT _ 0,
net: SCPrivate.Net _ NIL,
leftExit, rightExit: BOOL _ FALSE,
pinsInSeg: PinsInSeg _ NIL];
PinsInSeg: TYPE = LIST OF Route.Pin;
DetailRoute: PUBLIC PROC [handle: SC.Handle] RETURNS [result: SC.Result] = {

lgRows: SCPrivate.LgRows _ NARROW[handle.layoutData, SCPrivate.LayoutData].lgRows;
SCNewWidth.ComputeAllChanDW[handle, areaFom];
SCInstUtil.AllOffsets[handle];
[lgRows.maxRowWidth, lgRows.numMaxRows] _ SCRowUtil.FindMaxRow[handle];
result _ NEW[SC.ResultRec _ [handle: handle, object: RouteChannels[handle]]];
SCInstUtil.AsgnChanPos[handle];
[] _ SCUtil.WriteResults["End detailed routing\n", handle, 0]};
ConstructRow: PROC [handle: SC.Handle, lgRow: SCPrivate.LgRow] RETURNS [row: CD.Object _ CDCells.CreateEmptyCell[]] ~ {

LeftEnumerateSegments: PROC [eachSegment: PROC [CoreRoute.Segment]] ~ {

EachWirePin: CoreGeometry.EachWirePinProc = {
IF side=left THEN eachSegment[[label: CoreOps.GetShortWireName[wire], min: min, max: max, layer: layer]]};

[] _ CoreGeometry.EnumerateWireSides[mode.decoration, lgRow.lgsOnRow[1].object.cellType, EachWirePin]};

RightEnumerateSegments: PROC [eachSegment: PROC [CoreRoute.Segment]] ~ {

EachWirePin: CoreGeometry.EachWirePinProc = {
IF side=right THEN eachSegment[[label: CoreOps.GetShortWireName[wire], min: min, max: max, layer: layer]]};
[] _ CoreGeometry.EnumerateWireSides[mode.decoration, lgRow.lgsOnRow[lgRow.nLgsOnRow].object.cellType, EachWirePin]};

ForEachInstance: SCRowUtil.EachInstProc = {

LabelProc: PROC [pinName: Rope.ROPE] RETURNS [label: Route.Label _ NIL] ~ {
EachPin: SCInstUtil.EachPinProc ~ {
IF Rope.Equal[netPin.pin.name, pinName] THEN {
label _ netPin.net.name; quit _ TRUE;
};
};

IF SCUtil.IsPowerName[handle, pinName] THEN label _ pinName
ELSE IF ~SCInstUtil.EnumeratePinsOnInst[instance: instance, eachPin: EachPin] THEN 
SC.Signal[callingError, "FeedThrough definition in library does not have all rectangles marked."]};

instOrientation: CD.Orientation _ SCInstUtil.CDOrien[instance];
object: CD.Object _ IF (instance.whichClass = ft) OR (instance.object = parms.vddObject) OR (instance.object = parms.gndObject) THEN CoreRoute.MakeRoutingCell[instance.object.cdOb, LabelProc]
ELSE instance.object.cdOb;
instPosition: CD.Position _ CDOps.FitObjectI[ob: object, location: [offset, 0], orientation: instOrientation].off;
cdInst: CD.Instance _ RouteUtil.Include[cell: row, ob: object, position: instPosition, orientation: instOrientation];
CDProperties.PutInstanceProp[cdInst, $InstanceName, instance.name];
offset _ offset + RTBasic.IRSize[object].x};

parms: SCPrivate.Parms = NARROW [handle.parms];
mode: Sinix.Mode = parms.mode;
layoutData: SCPrivate.LayoutData _ NARROW[handle.layoutData];
maxRowWidth: CD.Number _ layoutData.lgRows.maxRowWidth;
rowLength: SC.Number _ lgRow.size.p;
rowOffset: SC.Number _ lgRow.rowOrg.p - layoutData.lgRows.horzRowOrg;
offset: SC.Number _ 0;

IF rowOffset > 0 THEN {
leftObject: CD.Object _ CoreRoute.ExtendObject[enumerateSegments: LeftEnumerateSegments, size: [rowOffset, lgRow.size.q], side: left, extendProc: CoreRoute.ExtendSegment];
[] _ RouteUtil.Include[cell: row, ob: leftObject, position: [offset, 0]];
offset _ offset + RTBasic.IRSize[leftObject].x};

[] _ SCRowUtil.EnumerateAllInstsOnRow[handle, lgRow.rowNum, ForEachInstance];

IF rowOffset + rowLength < maxRowWidth THEN {
rightObject: CD.Object _ CoreRoute.ExtendObject[enumerateSegments: RightEnumerateSegments, size: [maxRowWidth - (rowOffset + rowLength), lgRow.size.q], side: right, extendProc: CoreRoute.ExtendSegment];
[] _ RouteUtil.Include[cell: row, ob: rightObject, position: [offset, 0]];
offset _ offset + RTBasic.IRSize[rightObject].x};

RTBasic.RepositionCell[row]};
RouteChannels: PROC [handle: SC.Handle] RETURNS [obj: CD.Object _ CDCells.CreateEmptyCell[]] ~ {

RouteChannel: PROC [enumerateNets: Route.EnumerateChannelNetsProc, rowChan: SCPrivate.RowChan] ~ {

BrokenNet: Route.BrokenNetProc ~ {
net: SCPrivate.Net _ NARROW[netData, SegInChan].net;
net.numberOfRegions _ net.numberOfRegions + 1;
newLabel _ CoreRoute.LabelBrokenNet[net.name, regionNumber];
net.brokenNets _ CONS[newLabel, net.brokenNets]};

channel: CD.Object _ Route.Channel[enumerateNets: enumerateNets, min: lgRows.horzRowOrg, max: lgRows.horzRowOrg + lgRows.maxRowWidth, rulesParameters: handle.rules.rowParms, name: Rope.Cat[handle.name, "Chan", Convert.RopeFromInt[rowChan.chanNum]], brokenNets: BrokenNet, channelData: handle].object;
[] _ RouteUtil.Include[cell: obj, ob: channel, position: [0, offset]];
offset _ offset + RTBasic.IRSize[channel].y;
rowChan.chanWidth _ RTBasic.IRSize[channel].y};

EachChannel: SCChanUtil.EachRowChanProc ~ {

LowerChannel: Route.EnumerateChannelNetsProc ~ {
LowerChannelNet: SCNetUtil.EachNetProc ~ {
numberOfSegments: INT _ List.Length[net.segsInChan];
FOR segList: LIST OF REF ANY _ net.segsInChan, segList.rest WHILE segList # NIL DO
segInChan: SegInChan _ NARROW[segList.first];
name: Rope.ROPE;
IF numberOfSegments <= 1 THEN name _ net.name
ELSE {
name _ CoreRoute.LabelBrokenNet[net.name, segInChan.segNum];
net.numberOfRegions _ net.numberOfRegions + 1;
net.brokenNets _ CONS[name, net.brokenNets]};
eachNet[name: name,
enumeratePins: LowerChannelPins,
exitLeftOrBottom: segInChan.leftExit,
exitRightOrTop: segInChan.rightExit,
trunkSize: net.trunkWidth,
netData: segInChan];
ENDLOOP};
[] _ SCNetUtil.EnumerateNets[handle, LowerChannelNet]};

LowerChannelPins: Route.EnumerateChannelPinsProc ~ {

segInChan: SegInChan _ NARROW[netData];
FOR pins: PinsInSeg _ segInChan.pinsInSeg, pins.rest UNTIL pins = NIL DO
pin: Route.Pin _ pins.first;
bottomOrLeftSide: BOOL _ pin.side = bottom;
xfer: BOOLEAN _ segInChan.net.externNet AND SCNetUtil.ExitOnSide[handle, segInChan.net, bottom] AND pin.side = top;
eachPin[bottomOrLeftSide: bottomOrLeftSide, min: pin.min, max: pin.max, depth: pin.depth, layer: pin.layer];
IF xfer THEN eachPin[bottomOrLeftSide: ~bottomOrLeftSide, min: pin.min, max: pin.max, depth: pin.depth, layer: pin.layer];
ENDLOOP};

InteriorChannel: Route.EnumerateChannelNetsProc ~ {
InteriorChannelNet: SCNetUtil.EachNetProc ~ {
numberOfSegments: INT _ List.Length[net.segsInChan];
FOR segList: LIST OF REF ANY _ net.segsInChan, segList.rest WHILE segList # NIL DO
segInChan: SegInChan _ NARROW[segList.first];
name: Rope.ROPE;
IF numberOfSegments <= 1 THEN name _ net.name
ELSE {
name _ CoreRoute.LabelBrokenNet[net.name, segInChan.segNum];
net.numberOfRegions _ net.numberOfRegions + 1;
net.brokenNets _ CONS[name, net.brokenNets]};
eachNet[name: name,
enumeratePins: InteriorChannelPins,
exitLeftOrBottom: segInChan.leftExit,
exitRightOrTop: segInChan.rightExit,
trunkSize: net.trunkWidth,
netData: segInChan];
ENDLOOP};
[] _ SCNetUtil.EnumerateNets[handle, InteriorChannelNet]};

InteriorChannelPins: Route.EnumerateChannelPinsProc ~ {

segInChan: SegInChan _ NARROW[netData];
FOR pins: PinsInSeg _ segInChan.pinsInSeg, pins.rest UNTIL pins = NIL DO
pin: Route.Pin _ pins.first;
bottomOrLeftSide: BOOL _ pin.side = bottom;
eachPin[bottomOrLeftSide: bottomOrLeftSide, min: pin.min, max: pin.max, depth: pin.depth, layer: pin.layer];
ENDLOOP};

GetGlobalRouteForChannel[handle: handle, rowChan: rowChan];

IF chan # 1 THEN { -- include the specified row in the object being constructed
[] _ RouteUtil.Include[cell: obj, ob: ConstructRow[handle, lgRows.rows[chan-1]], position: [0, offset]];
offset _ offset + lgRows.rows[chan-1].size.q};

IF chan = 1 AND rowChans.count = 2 THEN {
RouteChannel[LowerChannel, rowChan]};

IF chan # rowChans.count AND chan # 1 THEN {
RouteChannel[InteriorChannel, rowChan]}};

layoutData: SCPrivate.LayoutData _ NARROW[handle.layoutData];
structureData: SCPrivate.StructureData _ NARROW[handle.structureData];
rowChans: SCPrivate.RowChans _ layoutData.rowChans;
lgRows: SCPrivate.LgRows _ layoutData.lgRows;
offset: SC.Number _ 0;
[] _ SCChanUtil.EnumerateRowChans[handle, EachChannel];
RTBasic.SetCDCellName[obj, handle.name];
RTBasic.RepositionCell[obj]};

GetGlobalRouteForChannel: PROC [handle: SC.Handle, rowChan: SCPrivate.RowChan] ~ {

InitNet: SCNetUtil.EachNetProc = {net.segsInChan _ NIL};

MakeNetSeg: SCExprRoutePinsUtil.SegProc = {
seg: SegInChan _ NEW[SegInChanRec _ [segNum: segNum, net: net, leftExit: leftExit, rightExit: rightExit, pinsInSeg: pinList]];
net.segsInChan _ CONS[seg, net.segsInChan];
pinList _ NIL; leftExit _ rightExit  _ FALSE};

MakeNetPin: SCExprRoutePinsUtil.PinProc = {
pin: Route.Pin _ NEW[Route.PinRec _ [min: min, max: max, depth: depth, layer: layer, side: side]];
pinList _ CONS[pin, pinList]};

MakeNetExit: SCExprRoutePinsUtil.ExitProc = {
IF side = left THEN leftExit _ TRUE
ELSE IF side = right THEN rightExit _ TRUE
ELSE SC.Error[programmingError, "Not suppose to happen."]};

pinList: PinsInSeg _ NIL;
leftExit, rightExit: BOOL _ FALSE;
[] _ SCNetUtil.EnumerateNets[handle, InitNet];
SCExprRoutePinsUtil.GetAllNetSegInChan[handle, rowChan, MakeNetSeg, MakeNetPin, MakeNetExit]};

END.




	"SCExprRouteImpl.mesa:  Implements of SCExprGlobalRoute.DetailedRoute
Copyright Σ 1986, 1987, 1988 by Xerox Corporation.  All rights reserved.
Frank Bowers June 3, 1986 10:58:48 am PDT
Last Edited by: Bryan Preas March 26, 1988 6:52:05 pm PST
Christian Le Cocq December 2, 1987 2:59:49 pm PST
Jean-Marc Frailong October 14, 1987 5:47:09 pm PDT

Local Types
Detail Route Operation
Construct The Rows
enumerate public wires for left side of row
PROC [wire: Wire, min, max: INT, side: Side, layer: CD.Layer] RETURNS [quit: BOOL _ FALSE];
enumerate public wires for right side of row
PROC [wire: Wire, min, max: INT, side: Side, layer: CD.Layer] RETURNS [quit: BOOL _ FALSE];
[pos: NAT, instance: SCPrivate.Instance] RETURNS [quit: BOOL _ FALSE]
find label for this pin
PROC [instance: SCPrivate.Instance, pin: NAT, netPin: SCPrivate.PinNet] RETURNS [quit: BOOL _ FALSE];
Route The Channels
route the channels and include rows and channels into the layout
route the specified channeland include in the object being constructed
PROC [channelData, netData: REF, sourceNet: Label, regionNumber, numberOfRegions: NAT] RETURNS [newLabel: Label];
HACK (BTP, 3/26/88) How to break private nets?
IF NOT net.externNet THEN newLabel _ NIL
ELSE {
net.numberOfRegions _ net.regionNumber + 1;
newLabel _ CoreRoute.LabelBrokenNet[net.name, net.numberOfRegions];
net.brokenNets _ CONS[newLabel, net.brokenNets]}};

[chan: SCPrivate.MaxChanSr, rowChan: SCPrivate.RowChan] RETURNS [quit: BOOL _ FALSE]
route the channel specified by rowChan
PROC [channelData: REF, eachNet: EachChannelNetProc];
PROC [net: SCPrivate.Net] RETURNS [quit: BOOL _ FALSE];
PROC [channelData, netData: REF, eachPin: EachChannelPinProc];
PROC [name: Label, enumeratePins: EnumerateChannelPinsProc, exitLeftOrBottom, exitRightOrTop: BOOL _ FALSE, mayExit: BOOL _ TRUE, trunkSize: CD.Number _ 0, channelData, netData: REF _ NIL];
PROC [net: SCPrivate.Net] RETURNS [quit: BOOL _ FALSE];
PROC [channelData, netData: REF, eachPin: EachChannelPinProc];
do the bottom channel if it is the only one
do the interior channels
collect the pins that are to be connected for this channel
PROC [segNum: SC.Number, net: SCPrivate.Net];
PROC [min, max, depth: SC.Number, side: SC.Side, layer: SC.Layer, net: SCPrivate.Net];

PROC [side: SCPrivate.LRSide, layer: SC.Layer, net: SCPrivate.Net];

Κ	˜
codeš
œD™DKš
œH™HKšœ&Οk™)Kš
œ9™9K™1K™2K™—š
	˜	Kšœ‚
œ}˜ƒK˜—šΠlnœœ
˜šœΚ
˜Ρ
Kš
œ
˜
—Kšœ˜Kšœ
œ˜—
head™Kšœœ˜#šœœœ˜Kšœœ˜Kšœœ
˜Kšœœœ
˜"Kšœœ˜—Kšœœ˜$—šΟnœ™šŸœœ
œ
œ	œ
œ˜LK˜Kšœœ1˜RKš
œ-˜-Kš
œ˜Kš
œG˜GKšœ	œ
œ>˜MKš
œ˜Kš
œ?˜?——™š
Ÿœœ
œ!œœ(˜wK˜šŸœœœ˜GKš
œ+™+K˜šŸœ"˜-Kš
œ[™[KšœœY˜jK˜—Kš
œg˜gK˜—šŸœœœ˜HKš
œ,™,K˜šŸœ"˜-Kš
œ[™[KšœœY˜k—Kš
œu˜uK˜—šŸœ˜+Kš	œœ œœœ
™EK˜š
Ÿ	œœœœœ˜KKš
œ™šŸœ˜#Kš
œ%œœœœ™ešœ&œ˜.Kšœ œ
˜%Kš
œ˜—Kš
œ˜K˜—Kšœ%œ˜;šœ
œGœ
˜SKšœa˜c—K˜—Kšœœ,˜?šœœ
œœ#œ#œ;˜Ώ
Kšœ˜—Kšœœb˜rKšœœk˜uKš
œC˜CKš
œ,˜,K˜—Kšœœ˜/Kš
œ˜Kšœ#œ˜=Kšœ
œ(˜7Kšœœ˜$Kšœœ8˜EKšœœ˜K˜šœœ˜Kšœœ
˜«
Kš
œI˜IKš
œ0˜0K˜—š
œM˜MK˜—šœ%œ˜-Kšœ
œ»
˜Κ
Kš
œJ˜JKš
œ1˜1K˜—Kš
œ˜——™š
Ÿ
œœ
œ	œœ(˜`Kš
œ@™@K˜šŸœœP˜bš
œF™FK˜—šŸ	œ˜"Kšœœ3œœ™qKšœœ˜4Kš
œ.˜.Kš
œ<˜<Kšœœ˜1K˜K™.Kšœ
œœ™(šœ™Kš
œ+™+Kš
œC™CKšœœ™2K™——Kšœ	œ‘˜¬Kš
œF˜FKš
œ,˜,Kš
œ/˜/K˜—šŸœ ˜+Kšœ8œœœ
™TKš
œ&™&K˜šŸœ$˜0Kšœœ™5šŸœ˜*Kšœœœœ™7Kšœœ˜4šœ
œ
œ
œ
œ œœ
˜RKšœœ˜-Kšœœ
˜Kšœœ˜-šœ˜Kš
œ<˜<K˜.Kšœœ˜-—š
œ˜Kš
œ ˜ Kš
œ%˜%Kš
œ$˜$Kš
œ˜Kš
œ˜—Kšœ˜	——Kš
œ7˜7K˜—šŸœ$˜4Kšœœ™>K˜Kšœœ
˜'šœ2œœ
˜HKš
œ˜Kšœœ˜+Kšœœœ5œ˜sKš
œl˜lKšœœn˜zKšœ˜	—K˜—šŸœ$˜3KšœZœœœœ
œ#œœ™½
šŸœ˜-Kšœœœœ™7Kšœœ˜4šœ
œ
œ(œœ
˜RKšœœ˜-Kšœœ
˜Kšœœ˜-šœ˜Kš
œ<˜<K˜.Kšœœ˜-—š
œ˜Kš
œ#˜#Kš
œ%˜%Kš
œ$˜$Kš
œ˜Kš
œ˜—Kšœ˜	——Kš
œ:˜:K˜—šŸœ$˜7Kšœœ™>K˜Kšœœ
˜'šœ2œœ
˜HKš
œ˜Kšœœ˜+Kš
œl˜lKšœ˜	—K˜—Kš
œ;˜;K˜šœ
œΟc<˜OKš
œh˜hKš
œ.˜.—K˜šœ
œœ˜)Kš
œ+™+Kš
œ%˜%K˜—šœœ
œ˜,Kš
œ™Kš
œ)˜)—K˜—Kšœ#œ˜=Kšœ)œ˜FKš
œ3˜3Kš
œ-˜-Kšœœ˜Kš
œ7˜7Kš
œ(˜(Kš
œ˜K˜—šŸœœ
œ(˜RKš
œ:™:K˜KšŸœ,œ˜8K˜šŸ
œ!˜+Kšœ
œ™-Kšœœj˜~Kšœœ˜+Kšœ
œœ˜.K˜—šŸ
œ!˜+Kšœœœœ™VK™KšœœN˜bKšœ
œ˜K˜—šŸœ"˜-Kšœ!œ™CK™Kšœ
œ˜#Kšœ
œœ
˜*Kšœ
œ4˜;K˜—Kšœœ
˜Kšœœœ
˜"Kš
œ.˜.Kš
œ^˜^K˜——šœ
˜K˜K˜K˜—K˜—…—%J7ϋ