DIRECTORY
CD, CDCells, CDOps, CDProperties, Convert, Core, CoreGeometry, CoreOps, CoreRoute, DABasics, Rope, Route, RouteUtil, RoutePrivate, RTBasic, SC, SCChanUtil, SCInstUtil, SCNetUtil, SCPrivate, SCNewRoutePinsUtil, SCRowUtil, SCUtil, Sinix, SinixOps;

SCNewRouteImpl: CEDAR PROGRAM
IMPORTS CDCells, CDOps, CDProperties, Convert, CoreGeometry, CoreOps, CoreRoute, Rope, Route, RouteUtil, RTBasic, SCChanUtil, SCInstUtil, SCNetUtil, SCNewRoutePinsUtil, SCRowUtil, SCUtil, SinixOps
 
EXPORTS SCPrivate
SHARES SC = BEGIN
DetailRoute: PUBLIC PROC [handle: SC.Handle] RETURNS [result: SC.Result] = {

lgRows: SCPrivate.LgRows _ NARROW[handle.layoutData, SCPrivate.LayoutData].lgRows;
SCInstUtil.AllOffsets[handle];
[lgRows.maxRowWidth, lgRows.numMaxRows] _ SCRowUtil.FindMaxRow[handle];
ConstructRows[handle];
result _ NEW[SC.ResultRec _ [handle: handle, object: RouteChannels[handle]]];
SCInstUtil.AsgnChanPos[handle];
[] _ SCUtil.WriteResults["End detailed routing\n", handle, 0]};
ConstructRows: PROC [handle: SC.Handle] = {

ForEachRow: SCRowUtil.EachRowProc = {

lgRow.cdOb _ ConstructRow[handle, lgRow]};

[] _ SCRowUtil.EnumerateRows[handle: handle, eachRow: ForEachRow]};

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 = {
object: CD.Object _ instance.object.cdOb;
instOrientation: CD.Orientation _ SCInstUtil.CDOrien[instance];
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};

mode: Sinix.Mode = SinixOps.GetExtractMode[handle.rules.rowParms.technology];
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];
IF net.externNet = internalNet THEN newLabel _ NIL
ELSE {
net.numberOfRegions _ net.numberOfRegions + 1;
newLabel _ CoreRoute.LabelBrokenNet[net.name, net.numberOfRegions];
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 ~ {
IF net.pinsOnChan # NIL THEN eachNet[name: net.name,
enumeratePins: LowerChannelPins,
exitLeftOrBottom: net.chanExits[left][rowChan.chanNum-1],
exitRightOrTop: net.chanExits[right][rowChan.chanNum-1],
trunkSize: net.trunkWidth,
netData: net]};
[] _ SCNetUtil.EnumerateNets[handle, LowerChannelNet]};

InteriorChannel: Route.EnumerateChannelNetsProc ~ {
InteriorChannelNet: SCNetUtil.EachNetProc ~ {
IF net.pinsOnChan # NIL THEN eachNet[name: net.name,
enumeratePins: InteriorChannelPins,
exitLeftOrBottom: net.chanExits[left][rowChan.chanNum-1],
exitRightOrTop: net.chanExits[right][rowChan.chanNum-1],
trunkSize: net.trunkWidth,
netData: net]};
[] _ SCNetUtil.EnumerateNets[handle, InteriorChannelNet]};

LowerChannelPins: Route.EnumerateChannelPinsProc ~ {

net: SCPrivate.Net _ NARROW[netData];
pinList: LIST OF RoutePrivate.Pin _ NARROW[net.pinsOnChan];
FOR pins: LIST OF RoutePrivate.Pin _ pinList, pins.rest UNTIL pins = NIL DO
pin: RoutePrivate.Pin _ pins.first;
bottomOrLeftSide: BOOL _ pin.side = bottom;
xfer: BOOLEAN _ net.externNet = externalNet AND SCNetUtil.ExitOnSide[handle, 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};

InteriorChannelPins: Route.EnumerateChannelPinsProc ~ {

net: SCPrivate.Net _ NARROW[netData];
pinList: LIST OF RoutePrivate.Pin _ NARROW[net.pinsOnChan];
FOR pins: LIST OF RoutePrivate.Pin _ pinList, pins.rest UNTIL pins = NIL DO
pin: RoutePrivate.Pin _ pins.first;
bottomOrLeftSide: BOOL _ pin.side = bottom;
eachPin[bottomOrLeftSide: bottomOrLeftSide, min: pin.min, max: pin.max, depth: pin.depth, layer: pin.layer];
ENDLOOP};

GlobalRouteChannel[handle, rowChan];

IF chan # 1 THEN { -- include the specified row in the object being constructed
[] _ RouteUtil.Include[cell: obj, ob: lgRows.rows[chan-1].cdOb, 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];
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]};

GlobalRouteChannel: PROC [handle: SC.Handle, rowChan: SCPrivate.RowChan] ~ {
InitNet: SCNetUtil.EachNetProc = {net.pinsOnChan _ NIL};

layoutData: SCPrivate.LayoutData _ NARROW[handle.layoutData];
rowChans: SCPrivate.RowChans _ layoutData.rowChans;
useThisChan: BOOLEAN _ (1 < rowChan.chanNum AND rowChan.chanNum < rowChans.count) OR (rowChan.chanNum = 1 AND rowChans.count = 2);

[] _ SCNetUtil.EnumerateNets[handle, InitNet];
SCNewRoutePinsUtil.InitGetChanPins[handle, rowChan];
IF useThisChan THEN CreateExitsForChannel[handle: handle, rowChan: rowChan];
CreatePinsForChannel[handle: handle, rowChan: rowChan];
SCNewRoutePinsUtil.CreateNetDat[handle, rowChan];
SCNewRoutePinsUtil.EnterAllNetSegInChan[handle, rowChan, MakeNetPin, NIL];
SCNewRoutePinsUtil.TermGetChanPins[handle, rowChan]};

CreatePinsForChannel: PROC [handle: SC.Handle, rowChan: SCPrivate.RowChan] = {

AllPins: SCInstUtil.EachPinProc = {
IF netPin.net #NIL THEN {  
IF side = SCInstUtil.PosOf[instance, netPin.pin].sideOn THEN {
alwaysUse: BOOLEAN _ (chan = 1 OR chan = rowChans.count) AND netPin.net.externNet = externalNet AND SCNetUtil.ExitOnSide[handle, netPin.net, side];
rowOffset: SC.Number _ lgRows.horzRowOrg + lgRow.rowOrg.p;
rect: CD.Rect _ SCInstUtil.RotateRect[instance, netPin.pin.rect];
min: SC.Number _ rowOffset + instance.offset + rect.x1;
[] _ SCNewRoutePinsUtil.EnterPin[rowChan: rowChan, min: min, max: min + rect.x2 - rect.x1, depth: 0, layer: netPin.pin.layer, net: netPin.net, side: RTBasic.OtherSide[side], alwaysUse: alwaysUse]}}};

ExternalPins: SCInstUtil.EachPinProc = {
IF netPin.net #NIL AND  netPin.net.externNet = externalNet THEN {  
IF side = SCInstUtil.PosOf[instance, netPin.pin].sideOn AND SCNetUtil.ExitOnSide[handle, netPin.net, side] THEN {
rowOffset: SC.Number _ lgRows.horzRowOrg + lgRow.rowOrg.p;
rect: CD.Rect _ SCInstUtil.RotateRect[instance, netPin.pin.rect];
min: SC.Number _ rowOffset + instance.offset + rect.x1;
[] _ SCNewRoutePinsUtil.EnterPin[rowChan: rowChan, min: min, max: min + rect.x2 - rect.x1, depth: 0, layer: netPin.pin.layer, net: netPin.net, side: RTBasic.OtherSide[side], alwaysUse: TRUE]}}};

InternalPinsInstance: SCRowUtil.EachInstProc = {
[] _ SCInstUtil.EnumeratePinsOnInst[instance, AllPins]};

ExternalPinsInstance: SCRowUtil.EachInstProc = {
[] _ SCInstUtil.EnumeratePinsOnInst[instance, ExternalPins]};

lgRows: SCPrivate.LgRows _ NARROW[handle.layoutData, SCPrivate.LayoutData].lgRows;
rowChans: SCPrivate.RowChans _ NARROW[handle.layoutData, SCPrivate.LayoutData].rowChans;
chan: SCPrivate.MaxChanSr _ rowChan.chanNum;
side: SC.Side;
lgRow: SCPrivate.LgRow;
SELECT TRUE FROM
chan = 1 AND lgRows.count = 1 => {
side _ bottom; lgRow _ lgRows.rows[1];
[] _ SCRowUtil.EnumerateAllInstsOnRow[handle, lgRow.rowNum, InternalPinsInstance]};
chan = 1 => {
side _ bottom; lgRow _ lgRows.rows[1];
[] _ SCRowUtil.EnumerateAllInstsOnRow[handle, lgRow.rowNum, ExternalPinsInstance]};
chan = lgRows.count + 1 => {
side _ top; lgRow _ lgRows.rows[lgRows.count];
[] _ SCRowUtil.EnumerateAllInstsOnRow[handle, lgRow.rowNum, ExternalPinsInstance]};
ENDCASE => {
side _ top; lgRow _ lgRows.rows[chan - 1];
[] _ SCRowUtil.EnumerateAllInstsOnRow[handle, lgRow.rowNum, InternalPinsInstance];
side _ bottom; lgRow _ lgRows.rows[chan];
[] _ SCRowUtil.EnumerateAllInstsOnRow[handle, lgRow.rowNum, InternalPinsInstance]}};

CreateExitsForChannel: PROC [handle: SC.Handle, rowChan: SCPrivate.RowChan] = {

ExitPins: SCChanUtil.EachExitProc = {
pos: SC.Number _ IF lrSide = left THEN lgRows.horzRowOrg ELSE lgRows.horzRowOrg + lgRows.maxRowWidth;
[] _ SCNewRoutePinsUtil.EnterExit[rowChan, pos, exit.layer, exit.net, lrSide]};

EachSide: SCRowUtil.EachSideProc ~ {
IF side = left OR side = right THEN {
[] _ SCChanUtil.EnumerateExits[handle, rowChan, side, ExitPins]}};

layoutData: SCPrivate.LayoutData _ NARROW[handle.layoutData];
lgRows: SCPrivate.LgRows _ layoutData.lgRows;
[] _ SCRowUtil.EnumerateSides[handle, EachSide]};

MakeNetPin: SCNewRoutePinsUtil.PinProc = {
pin: RoutePrivate.Pin _ NEW[RoutePrivate.PinRec _ [min: min, max: max, depth: depth, layer: layer, side: side]];
net.pinsOnChan _ CONS[pin, net.pinsOnChan]};
END.




	0SCNewRouteImpl.mesa:  Implements of SC.DetailedRoute
Copyright c 1986, 1987 by Xerox Corporation.  All rights reserved.
Frank Bowers June 3, 1986 10:58:48 am PDT
Last Edited by: Bryan Preas August 12, 1987 4:08:01 pm PDT

Detail Route Operation
Construct The Rows
[row: SCPrivate.MaxRowSr, lgRow: SCPrivate.LgRow] RETURNS [quit: BOOL _ FALSE]
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]
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];
[chan: SCPrivate.MaxChanSr, rowChan: SCPrivate.RowChan] RETURNS [quit: BOOL _ FALSE]
route the channel specified by rowChan
PROC [channelData: REF, eachNet: EachChannelNetProc];
PROC [netIndex: NAT, net: SCPrivate.Net] RETURNS [quit: BOOL _ FALSE];
PROC [name: Label, enumeratePins: EnumerateChannelPinsProc, exitLeftOrBottom, exitRightOrTop: BOOL _ FALSE, mayExit: BOOL _ TRUE, trunkSize: CD.Number _ 0, channelData, netData: REF _ NIL];
PROC [netIndex: NAT, net: SCPrivate.Net] RETURNS [quit: BOOL _ FALSE];
PROC [channelData, netData: REF, eachPin: EachChannelPinProc];
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
[instance: SCPrivate.Instance, pin: NAT, netPin: SCPrivate.PinNet]

[instance: SCPrivate.Instance, pin: NAT, netPin: SCPrivate.PinNet]

only one row, must route one exterior channel. Choose the bottom one
bottom exterior channel, transfer the exterior pins
top exterior channel, transfer the exterior pins
the interior channels
PROC [exitNum: SCPrivate.MaxExitsSr, lrSide: SCPrivate.LRSide, rowChan: SCPrivate.RowChan, exit: SCPrivate.Exit] RETURNS [quit: BOOL _ FALSE]
[side: SC.Side, bpRow: SCPrivate.BpRow] RETURNS [quit: BOOL _ FALSE]
PROC [min, max, depth: SC.Number, side: SC.Side, layer: SC.Layer, net: SCPrivate.Net];

Κ
)˜
codešœ$Οkœ™4Kšœ
Οm
œ7™BKšœ&™)Kš
œ:™:K™—š
	˜	KšœŠ
œg˜υ
K˜—šΟnœœ
˜šœ½
˜Δ
Kš
œ
˜
—Kšœ
˜Kšœ
œ˜—
headšŸœ™šŸœœ
œ
œ	œ
œ˜LK˜Kšœœ1˜RKš
œ˜Kš
œG˜GKš
œ˜Kšœ	œ
œ>˜MKš
œ˜Kš
œ?˜?——™šŸ
œœ
œ˜+K˜šŸ
œ˜%Kšœ2œœœ
™NK˜Kš
œ*˜*K˜—Kš
œC˜CK˜—š
Ÿœœ
œ!œœ(˜wK˜šŸœœœ˜GKš
œ+™+K˜šŸœ"˜-Kš
œ[™[KšœœY˜jK˜—Kš
œg˜gK˜—šŸœœœ˜HKš
œ,™,K˜šŸœ"˜-Kš
œ[™[KšœœY˜k—Kš
œu˜uK˜—šŸœ˜+Kš	œœ œœœ
™EKšœœ˜)Kšœœ,˜?Kšœœb˜rKšœœk˜uKš
œC˜CKš
œ,˜,K˜—Kš
œM˜MKšœ#œ˜=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šœœ
˜%Kšœœ˜2šœ˜K˜.Kš
œC˜CKšœœ˜2K˜——Kšœ	œ‘˜¬Kš
œF˜FKš
œ,˜,Kš
œ/˜/K˜—šŸœ ˜+Kšœ8œœœ
™TKš
œ&™&K˜šŸœ$˜0Kšœœ™5šŸœ˜*Kš
œœœœœ™Fšœœ
œ˜4Kš
œ ˜ Kš
œ9˜9Kš
œ8˜8Kš
œ˜Kš
œ˜——Kš
œ7˜7K˜—šŸœ$˜3KšœZœœœœ
œ#œœ™½
šŸœ˜-Kš
œœœœœ™Fšœœ
œ˜4Kš
œ#˜#Kš
œ9˜9Kš
œ8˜8Kš
œ˜Kš
œ˜——Kš
œ:˜:K˜—šŸœ$˜4Kšœœ™>K˜Kš
œ%˜%Kšœ	œ
œ+˜;šœœ
œ'œœ
˜KKš
œ#˜#Kš
œ+˜+Kšœœœ+œ˜mKš
œl˜lKšœœn˜zKšœ˜	—K˜—šŸœ$˜7Kšœœ™>K˜Kš
œ%˜%Kšœ	œ
œ+˜;šœœ
œ'œœ
˜KKš
œ#˜#Kš
œ+˜+Kš
œl˜lKšœ˜	—K˜—Kš
œ$˜$K˜šœ
œ?˜OKš
œW˜WKš
œ.˜.—K˜šœ
œœ˜)Kš
œ+™+Kš
œ%˜%K˜—šœœ
œ˜,Kš
œ™Kš
œ)˜)—K˜—Kšœ#œ˜=Kš
œ3˜3Kš
œ-˜-Kšœœ˜Kš
œ7˜7Kš
œ(˜(Kš
œ˜K˜—šŸœœ
œ(˜LKš
œ:™:KšŸœ,œ˜8K˜Kšœ#œ˜=Kš
œ3˜3Kš	œ
œœ#œœ˜‚
K˜Kš
œ.˜.Kš
œ4˜4Kšœ
œ9˜LKš
œ7˜7Kš
œ1˜1KšœEœ˜JKš
œ5˜5K˜—šŸœœ
œ(˜NK˜šŸœ˜#šΟi$Πik ™BK™—šœ
œ
œ˜šœ6œ˜>Kš	œœ
œœ$œ0˜“
Kšœœ-˜:Kšœœ9˜AKšœœ0˜7Kš
œΗ
˜Η
——K˜—šŸœ˜(Kš $‘ ™BK™šœ
œ
œ%œ˜Cšœ6œ0œ˜qKšœœ-˜:Kšœœ9˜AKšœœ0˜7KšœΉ
œ˜Β
——K˜—šŸœ˜0Kš
œ8˜8K˜—šŸœ˜0Kš
œ=˜=K˜—Kšœœ1˜RKšœœ3˜XKš
œ,˜,Kšœœ˜Kš
œ˜šœ
œ
˜šœ	œ˜"Kš
œD™DKš
œ&˜&Kš
œS˜S—š
œ
˜
Kš
œ3™3Kš
œ&˜&Kš
œS˜S—š
œ˜Kš
œ0™0Kš
œ.˜.Kš
œS˜S—šœ˜Kš
œ™Kš
œ*˜*Kš
œR˜RKš
œ)˜)Kš
œT˜T——K˜—šŸœœ
œ(˜OK˜šŸœ˜%Kšœmœœœ
™
Kš	œœ
œœœ(˜eKš
œO˜OK˜—šŸœ˜$Kš	œœœœœ
™Dšœ
œœ˜%Kš
œB˜B—K˜—Kšœ#œ˜=K˜-Kš
œ1˜1K˜—šŸ
œ ˜*Kšœœœœ™VK™KšœœU˜pKšœœ˜,——šœ
˜K˜K˜K˜—K˜—…—,ˆ?α