<> <> <> <<>> DIRECTORY BitOps, CD, CDBasics, CDInstances, CDOps, DABasics, ImagerSample, PW, Rope, SF; SoftHdw25D: CEDAR PROGRAM IMPORTS BitOps, CD, CDBasics, CDInstances, CDOps, ImagerSample, PW, SF EXPORTS = BEGIN TileType: TYPE = {MinorArray, BoardTraces, Corner, Clock0, Clock1, RAMEven, RAMOdd, ROMEven, ROMOdd, MuxRDLUToRDEven, MuxRDLUToRDOdd, MuxLURDToLUEven, MuxLURDToLUOdd, Program, Inverter, FlipFlop, OLUToI, OLUToRD, ORDToI, ORDToLU, ORDToL, RToI, LUToLU, LUToI, RDToRD, RDToI, OToP, RDToP, LUToP, LToP, PToI, PToRD, StartStopStateSlow, StartStopStateFast, BoxDecodeToDataPath, SampleMapCount, SampleMapExtension, SampleMapMux, SampleMapRam}; tileNames: ARRAY TileType OF Rope.ROPE _ ["MinorArray", "BoardTraces", "Corner", "Clock0", "Clock1", "RAMEven", "RAMOdd", "ROMEven", "ROMOdd", "MuxRDLUToRDEven", "MuxRDLUToRDOdd", "MuxLURDToLUEven", "MuxLURDToLUOdd", "Program", "Inverter", "FlipFlop", "OLUToI", "OLUToRD", "ORDToI", "ORDToLU", "ORDToL", "RToI", "LUToLU", "LUToI", "RDToRD", "RDToI", "OToP", "RDToP", "LUToP", "LToP", "PToI", "PToRD", "StartStopStateSlow", "StartStopStateFast", "BoxDecodeToDataPath", "SampleMapCount", "SampleMapExtension", "SampleMapMux", "SampleMapRam"]; tileObjects: ARRAY TileType OF CD.Object _ ALL[NIL]; InterconnectTileType: TYPE = TileType[OLUToI..RDToI]; PinTileType: TYPE = TileType[OToP..PToRD]; SoftHdwPgmTileType: TYPE = TileType[MinorArray..PToRD]; SoftHdw25DTileType: TYPE = TileType[StartStopStateSlow..SampleMapRam]; MachineSizes: TYPE = RECORD [sAddressBits, fAddressBits, pixelsPerChunk, bitsPerPixel: INT]; LoadTiles: PROC = { design: CD.Design _ PW.OpenDesign["SoftHdwPgm.dale"]; CDOps.SetMutability[design, readonly]; FOR index: TileType IN SoftHdwPgmTileType DO tileObjects[index] _ PW.Get[design, tileNames[index]]; ENDLOOP; design _ PW.OpenDesign["SoftHdw25D.dale"]; CDOps.SetMutability[design, readonly]; FOR index: TileType IN SoftHdw25DTileType DO tileObjects[index] _ PW.Get[design, tileNames[index]]; ENDLOOP; }; CreateChip: PROC [size: DABasics.Position] RETURNS [object: CD.Object] = { minorArray: CD.Object _ tileObjects[MinorArray]; boardTraces: CD.Object _ tileObjects[BoardTraces]; boardTracesSize: DABasics.Position _ CD.InterestSize[boardTraces]; corner: CD.Object _ tileObjects[Corner]; inner: CD.Object _ PW.Array[minorArray, size.x, size.y]; side: CD.Object _ PW.ArrayY[boardTraces, size.y]; middle: CD.Object _ PW.AbutX[side, inner, side]; topBottom: CD.Object _ PW.AbutX[corner, PW.ArrayX[PW.FlipX[PW.Rot90[boardTraces]], size.x], corner]; object _ PW.AbutY[topBottom, middle, topBottom]; }; lambda: INT = 8; minorSize: INT = 128*lambda; minorSpace: INT = 24*lambda; tileWidth: INT = 32*lambda; tileHeight: INT = 24*lambda; outputHeight: INT = 20*lambda; inputHeight: INT = 16*lambda; tile0: INT = tileWidth + 3*tileHeight; tile1: INT = tileWidth + 2*tileHeight; tile2: INT = tileWidth + tileHeight; tile3: INT = tileWidth; chunksPerRAM: INT = 8; bitsPerRAMROMPair: INT = 8; CreateSampleMap: PROC [sizes: MachineSizes, position: ImagerSample.Vec, map: ImagerSample.SampleMap] RETURNS [object: CD.Object] = { EmitRAM: PROC [y: INT] = { FOR index: INT IN [0..sizes.pixelsPerChunk/bitsPerRAMROMPair) DO x: INT _ decodeWidth-tileWidth+2*index*minorSize; il _ CONS[InstantiateTile[SampleMapRam, [x, y]], il]; ENDLOOP; }; box: SF.Box _ SF.Displace[ImagerSample.GetBox[map], position]; widthInChunks: INT _ ((box.max.f-1)/sizes.pixelsPerChunk) - (box.min.f/sizes.pixelsPerChunk) + 1; heightInChunks: INT _ box.max.s-box.min.s; chunkCount: INT _ widthInChunks*heightInChunks; decodeObject: CD.Object _ CreateBoxDecode[sizes, box]; decodeWidth: INT _ CD.InterestSize[decodeObject].x; il: CD.InstanceList _ NIL; IF ImagerSample.GetBitsPerSample[map]#1 THEN ERROR; -- not yet implemented IF sizes.bitsPerPixel#ImagerSample.GetBitsPerSample[map] THEN ERROR; IF (sizes.pixelsPerChunk MOD bitsPerRAMROMPair)#0 THEN ERROR; -- not yet implemented il _ CONS[CreateInstance[decodeObject, [0, 0]], il]; il _ CONS[InstantiateTile[SampleMapCount, [decodeWidth - tileWidth - 7*minorSize, -minorSize]], il]; FOR index: INT IN [0..sizes.pixelsPerChunk/bitsPerRAMROMPair) DO x: INT _ decodeWidth-tileWidth+2*index*minorSize; il _ CONS[InstantiateTile[SampleMapMux, [x, 0]], il]; ENDLOOP; EmitRAM[-minorSize]; FOR index: INT IN [1..(chunkCount/chunksPerRAM)-1] DO y: INT _ -(index+1)*minorSize; il _ CONS[InstantiateTile[SampleMapExtension, [decodeWidth - tileWidth - 4*minorSize, y]], il]; EmitRAM[y]; ENDLOOP; object _ PW.CreateCell[il, [0, -(chunkCount/chunksPerRAM)*minorSize, decodeWidth + ((sizes.pixelsPerChunk+3)/4)*minorSize, minorSize+tileWidth]]; <> }; CreateBox: PROC [sizes: MachineSizes, box: SF.Box] RETURNS [object: CD.Object] = { decodeObject: CD.Object _ CreateBoxDecode[sizes, box]; decodeWidth: INT _ CD.InterestSize[decodeObject].x; il: CD.InstanceList _ NIL; il _ CONS[CreateInstance[decodeObject, [0, 0]], il]; IF sizes.bitsPerPixel#1 THEN ERROR; -- not yet implemented FOR dataIndex: INT IN [0..sizes.pixelsPerChunk) DO x: INT _ decodeWidth + outputHeight + ((dataIndex/4)*minorSize) + ((dataIndex MOD 4)*minorSpace); il _ CONS[InstantiateProgramTile[[x, tile3 + inputHeight]], il]; IF dataIndex >= (box.min.f MOD sizes.pixelsPerChunk) THEN il _ CONS[InstantiateProgramTile[[x, tile0 + inputHeight]], il]; IF dataIndex < (box.max.f MOD sizes.pixelsPerChunk) THEN il _ CONS[InstantiateProgramTile[[x, tile1 + inputHeight]], il]; ENDLOOP; object _ PW.CreateCell[il, [0, 0, decodeWidth + ((sizes.pixelsPerChunk+3)/4)*minorSize, minorSize+tileWidth]]; }; CreateBoxDecode: PROC [sizes: MachineSizes, box: SF.Box] RETURNS [object: CD.Object] = { slowObject: CD.Object _ CreateStartStop[sizes.sAddressBits, box.min.s, box.max.s, StartStopStateSlow]; slowWidth: INT _ CD.InterestSize[slowObject].x; fastObject: CD.Object _ CreateStartStop[sizes.fAddressBits, box.min.f/sizes.pixelsPerChunk, box.max.f/sizes.pixelsPerChunk, StartStopStateFast]; fastWidth: INT _ CD.InterestSize[fastObject].x; il: CD.InstanceList _ NIL; il _ CONS[CreateInstance[slowObject, [0, 0]], il]; il _ CONS[CreateInstance[fastObject, [slowWidth-tileWidth, 0]], il]; il _ CONS[InstantiateTile[OLUToRD, [slowWidth-tileWidth, tile3]], il]; il _ CONS[CreateInstance[tileObjects[BoxDecodeToDataPath], [slowWidth + fastWidth - 2*tileWidth, 0]], il]; FOR minorIndex: INT IN [1..fastWidth/minorSize) DO il _ CONS[InstantiateTile[RDToRD, [slowWidth - tileWidth + minorIndex*minorSize, tile3]], il]; ENDLOOP; IF ((fastWidth/minorSize) MOD 2) = 0 THEN il _ CONS[InstantiateTile[Inverter, [slowWidth + fastWidth - 2*tileWidth, tile3]], il]; object _ PW.CreateCell[il, [0, 0, slowWidth + fastWidth + minorSize - tileWidth, minorSize+tileWidth]]; }; CreateStartStop: PROC [bits: INT, start, stop: INT, logicTile: TileType] RETURNS [object: CD.Object] = { startObject: CD.Object _ CreateDecoder[bits, start]; IF start=stop THEN { ERROR; -- single chunk height or width boxes not yet implemented } ELSE { stopObject: CD.Object _ CreateDecoder[bits, stop]; decoder: CD.Object _ PW.AbutY[stopObject, startObject]; il: CD.InstanceList _ NIL; il _ CONS[CreateInstance[decoder, [0, tileWidth + 2*tileHeight]], il]; il _ CONS[InstantiateTile[logicTile, [minorSize*((bits+1)/2), 0]], il]; object _ PW.CreateCell[il, [0, 0, minorSize*(((bits+1)/2)+1) + tileWidth, minorSize+tileWidth]]; }; }; CreateDecoder: PROC [bits: INT, constant: INT] RETURNS [object: CD.Object] = { il: CD.InstanceList _ NIL; FOR bitIndex: INT IN [0..bits) DO adjust: INT _ minorSize*(bitIndex/2) + tileWidth + inputHeight + 2*minorSpace*(bitIndex MOD 2) + (IF BitOps.EBFD[constant, bitIndex, bits] THEN minorSpace ELSE 0); il _ CONS[InstantiateProgramTile[[adjust, outputHeight]], il]; ENDLOOP; FOR minorIndex: INT IN [1..(bits+1)/2) DO x: INT _ minorIndex*minorSize; il _ CONS[InstantiateTile[OLUToI, [x, 0]], il]; il _ CONS[InstantiateTile[Inverter, [x, 0]], il]; il _ CONS[InstantiateProgramTile[[x+tileWidth, outputHeight]], il]; ENDLOOP; object _ PW.CreateCell[il, [0, 0, minorSize*((bits+1)/2) + tileWidth, tileHeight]]; }; InstantiateProgramTile: PROC [position: DABasics.Position] RETURNS [instance: CD.Instance] = { object: CD.Object _ tileObjects[Program]; size: DABasics.Position _ CD.InterestSize[object]; size.x _ size.x/2; size.y _ size.y/2; instance _ CreateInstance[object, CDBasics.SubPoints[position, size]]; }; InstantiateTile: PROC [tile: TileType, position: DABasics.Position, orientation: DABasics.Orientation _ original] RETURNS [instance: CD.Instance] = { object: CD.Object _ tileObjects[tile]; instance _ CreateInstance[object, position, orientation]; }; CreateInstance: PROC [object: CD.Object, offset: DABasics.Position, orientation: DABasics.Orientation _ original] RETURNS [instance: CD.Instance] = { base: DABasics.Position _ CD.InterestBase[object]; tbase: DABasics.Position _ CDBasics.MapPoint[base, [[0, 0], orientation]]; toff: DABasics.Position _ CDBasics.SubPoints[offset, tbase]; instance _ CDInstances.NewInst[object, [toff, orientation]]; }; Test: PROC = { sizes: MachineSizes _ [10, 8, 8, 1]; myBox: SF.Box _ [[1,1],[9,9]]; chip: CD.Object _ CreateChip[[16, 8]]; decoder: CD.Object _ CreateDecoder[sizes.sAddressBits, 5]; startStop: CD.Object _ CreateStartStop[sizes.sAddressBits, 5, 7, StartStopStateSlow]; boxDecode: CD.Object _ CreateBoxDecode[sizes, myBox]; box: CD.Object _ CreateBox[sizes, myBox]; map: ImagerSample.SampleMap _ ImagerSample.NewSampleMap[box: myBox, bitsPerSample: 1]; sampleMap: CD.Object _ CreateSampleMap[sizes, [1,1], map]; il: CD.InstanceList _ NIL; il _ CONS[CreateInstance[chip, [-32*lambda,-32*lambda]], il]; il _ CONS[CreateInstance[decoder, [0,tileWidth]], il]; il _ CONS[CreateInstance[startStop, [0,minorSize]], il]; il _ CONS[CreateInstance[boxDecode, [0,2*minorSize]], il]; il _ CONS[CreateInstance[box, [0,3*minorSize]], il]; il _ CONS[CreateInstance[sampleMap, [0,4*minorSize]], il]; [] _ PW.Draw[PW.CreateCell[il]]; }; LoadTiles[]; END. <<>>