<> <> <> <> <> <> <<>> DIRECTORY CD, CDCells, CDOps, CDProperties, Convert, Core, CoreGeometry, CoreOps, CoreRoute, DABasics, Rope, Route, RouteUtil, RTBasic, SC, SCChanUtil, SCInstUtil, SCNetUtil, SCPrivate, SCNewRoutePinsUtil, SCRowUtil, SCUtil, Sinix; SCNewRouteImpl: CEDAR PROGRAM IMPORTS CDCells, CDOps, CDProperties, Convert, CoreGeometry, CoreOps, CoreRoute, Rope, Route, RouteUtil, RTBasic, SC, SCChanUtil, SCInstUtil, SCNetUtil, SCNewRoutePinsUtil, SCRowUtil, SCUtil 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]; 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 = { <<[pos: NAT, instance: SCPrivate.Instance] RETURNS [quit: BOOL _ FALSE]>> 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]; IF NOT net.externNet 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 ~ { <<[chan: SCPrivate.MaxChanSr, rowChan: SCPrivate.RowChan] RETURNS [quit: BOOL _ FALSE]>> <> LowerChannel: Route.EnumerateChannelNetsProc ~ { <> LowerChannelNet: SCNetUtil.EachNetProc ~ { <> leftExit: BOOL _ net.chanExits[left][rowChan.chanNum-1]; rightExit: BOOL _ net.chanExits[right][rowChan.chanNum-1]; IF net.pinsOnChan # NIL OR leftExit OR rightExit THEN eachNet[name: net.name, enumeratePins: LowerChannelPins, exitLeftOrBottom: leftExit, exitRightOrTop: rightExit, trunkSize: net.trunkWidth, netData: net]}; [] _ SCNetUtil.EnumerateNets[handle, LowerChannelNet]}; InteriorChannel: Route.EnumerateChannelNetsProc ~ { <> InteriorChannelNet: SCNetUtil.EachNetProc ~ { <> leftExit: BOOL _ net.chanExits[left][rowChan.chanNum-1]; rightExit: BOOL _ net.chanExits[right][rowChan.chanNum-1]; IF net.pinsOnChan # NIL OR leftExit OR rightExit THEN eachNet[name: net.name, enumeratePins: InteriorChannelPins, exitLeftOrBottom: leftExit, exitRightOrTop: rightExit, trunkSize: net.trunkWidth, netData: net]}; [] _ SCNetUtil.EnumerateNets[handle, InteriorChannelNet]}; LowerChannelPins: Route.EnumerateChannelPinsProc ~ { <> net: SCPrivate.Net _ NARROW[netData]; pinList: LIST OF Route.Pin _ NARROW[net.pinsOnChan]; FOR pins: LIST OF Route.Pin _ pinList, pins.rest UNTIL pins = NIL DO pin: Route.Pin _ pins.first; bottomOrLeftSide: BOOL _ pin.side = bottom; xfer: BOOLEAN _ net.externNet 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 Route.Pin _ NARROW[net.pinsOnChan]; FOR pins: LIST OF Route.Pin _ pinList, 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}; GlobalRouteChannel[handle, 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]; 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.GetAllNetSegInChan[handle, rowChan, NIL, MakeNetPin, NIL]; SCNewRoutePinsUtil.TermGetChanPins[handle, rowChan]}; CreatePinsForChannel: PROC [handle: SC.Handle, rowChan: SCPrivate.RowChan] = { AllPins: SCInstUtil.EachPinProc = { <<[instance: SCPrivate.Instance, pin: NAT, netPin: SCPrivate.PinNet]>> <<>> 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 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 = { <<[instance: SCPrivate.Instance, pin: NAT, netPin: SCPrivate.PinNet]>> <<>> IF netPin.net #NIL AND netPin.net.externNet 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 ~ { <<[side: SC.Side, bpRow: SCPrivate.BpRow] RETURNS [quit: BOOL _ FALSE]>> 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: Route.Pin _ NEW[Route.PinRec _ [min: min, max: max, depth: depth, layer: layer, side: side]]; net.pinsOnChan _ CONS[pin, net.pinsOnChan]}; END.