<> <> <> <<>> <> <<>> DIRECTORY Basics, Convert, Core, CoreClasses, CoreFlat, CoreOps, CoreProperties, FS, IO, List, PlotGraph, Ports, Real, RedBlackTree, RefTab, RefText, Rope, Rosemary, RosemaryUser; RosemaryUserBackingImpl: CEDAR MONITOR IMPORTS Basics, Convert, CoreFlat, CoreOps, CoreProperties, FS, IO, List, PlotGraph, Ports, Real, RedBlackTree, RefTab, RefText, Rope, Rosemary, RosemaryUser EXPORTS RosemaryUser ~ BEGIN OPEN RosemaryUser; <> <> <> <<- samples are kept in memory only if needed (i.e. if they are plotted). Samples are time-stamped with the MosSim step number. Relationship between `Eval time' and steps is achieved through an array in the handle that keeps track of the endpoints of each Eval. This permits to support time-logging or step-logging, as well as time-plotting or step-plotting.>> <> <<- two samples are always kept in memory per wire in order to allow collapsing identical values (c.f. LogData). The information is attached as data field to RoseWires and RoseInstances.>> <<- samples on disk are chained backwards through disk pointers to accelerate recovery. Only deltas in file position and time are kept on disk, using a variable length encoding, to reduce storage. The exact format per sample is < where>> <<>> <<>> <> <> <<>> <> <<- It would be real fine to save the drive with which a wire has been driven, in order to distinguish X from Z (driven to garbage from tri-stated). Two problems for that: RoseWires that have LS attached do not carry the drive around (Rick says that can be twiddled around), and PlotGraph does not provide the capacity to display that information. The nice thing is that the cost in storage/disk is very small...>> <> Sample: TYPE = REF SampleRec; SampleRec: TYPE = RECORD [ next: Sample _ NIL, step: INT _ LAST[INT], -- MosSim step number at which this event occured value: PACKED SEQUENCE size: CARDINAL OF Ports.Level ]; <> <<>> SampleList: TYPE = REF SampleListRec; SampleListRec: TYPE ~ RECORD [ head: Sample, -- the head of the list. The tail is always LogData.current beforeHeadPos: INT, -- the file position of the predecessor of head, <0 => no predecessor inTable: BOOL _ FALSE -- used internally to RBT management, don't modify ... ]; <> LogData: TYPE = REF LogDataRec; LogDataRec: TYPE = RECORD [ lastFilePos: INT _ -1, -- the file position of the last sample written list: SampleList _ NIL, -- if non-nil, the samples for this object are currently kept in memory previous: Sample _ NIL, -- the previous sample currentTime: INT _ -1, -- time of current sample current: Sample _ NIL -- the sample currently taken, not guaranteed if time=lastUpdateTime ]; <> <<- current.next = NIL>> <<- current.step = value of MosSimStep at last call to Update>> <<- current will never be modified once step of Update call > current.step>> <<- previous is the sample that was valid just before current. It is necessary to allow collapsing curent with a previous value. previous has not yet been written to disk!>> <<- if previous#NIL, then previous.next=current>> <<- if list#NIL, then samples are kept in memory. Then, either list.head=previous=NIL, or previous may be reached by following next links from list.head (possibly 0 times!).>> <> LockBackingStore: ENTRY PROC [h: RoseDisplay] = { UNTIL NOT h.psLock DO WAIT h.psWait ENDLOOP; h.psLock _ TRUE; }; UnlockBackingStore: ENTRY PROC [h: RoseDisplay] = { h.psLock _ FALSE; BROADCAST h.psWait; }; WillWrite: PROC [handle: RoseDisplay, nBytes: NAT] ~ { <> to: REF TEXT = handle.wBuff; IF to.maxLength-nBytes < to.length THEN FlushWBuff[handle, nBytes]; }; FlushWBuff: PROC [handle: RoseDisplay, nBytes: NAT] ~ { <> IO.PutBlock[handle.ps, handle.wBuff]; IF handle.wBuff.maxLength> <> <<0XXXXXXX => delta IN [0..128)>> <<10XXXXXX XXXXXXXX => delta IN [0..16384)>> <<110XXXXX XXXXXXXX XXXXXXXX => delta IN [0..2097152)>> <<111XXXXX XXXXXXXX XXXXXXXX XXXXXXXX => delta IN [0..536870912)>> byte: CARD32 = 256; limit1: CARD32 = 080H; limit2: CARD32 = 040H*byte; limit3: CARD32 = 020H*byte*byte; limit4: CARD32 = 020H*byte*byte*byte; v: Basics.LongNumber; v.li _ delta; SELECT v.lc FROM { -- write single byte <> PutByte[handle, v.ll]; handle.filePos _ handle.filePos+1; }; { -- write 2 bytes <> v.lo _ Basics.BITOR[v.lo, 08000H]; <> PutByte[handle, v.lh]; PutByte[handle, v.ll]; handle.filePos _ handle.filePos+2; }; { -- write 3 bytes <> v.hi _ Basics.BITOR[v.hi, 000C0H]; <> PutByte[handle, v.hl]; PutByte[handle, v.lh]; PutByte[handle, v.ll]; handle.filePos _ handle.filePos+3; }; { -- write 4 bytes <> v.hi _ Basics.BITOR[v.hi, 0E000H]; <> PutByte[handle, v.hh]; PutByte[handle, v.hl]; PutByte[handle, v.lh]; PutByte[handle, v.ll]; handle.filePos _ handle.filePos+4; }; ENDCASE => ERROR; -- too large }; Read29Bits: PROC [s: IO.STREAM] RETURNS [delta: INT32] ~ { <> v: Basics.LongNumber; v.lc _ 0; v.ll _ IO.GetByte[s]; SELECT TRUE FROM Basics.BITAND[v.lo, 00080H]=0 => { -- single byte <=limit1 THEN ERROR;>> }; Basics.BITAND[v.lo, 00040H]=0 => { -- 2 bytes v.lo _ Basics.BITAND[Basics.BITSHIFT[v.lo, 8], 03F00H]; v.ll _ IO.GetByte[s]; <=limit2 THEN ERROR;>> }; Basics.BITAND[v.lo, 00020H]=0 => { -- 3 bytes v.hi _ Basics.BITAND[v.lo, 0001FH]; v.lh _ IO.GetByte[s]; v.ll _ IO.GetByte[s]; <=limit3 THEN ERROR;>> }; ENDCASE => { -- 4 bytes v.hi _ Basics.BITAND[Basics.BITSHIFT[v.lo, 8], 01F00H]; v.hl _ IO.GetByte[s]; v.lh _ IO.GetByte[s]; v.ll _ IO.GetByte[s]; <=limit4 THEN ERROR;>> }; RETURN [delta: v.li]; }; WriteSample: PROC [handle: RoseDisplay, sample: Sample, prvPos: INT, nextStep: INT] RETURNS [pos: INT] ~ { <> <> deltaPos: INT; WillWrite[handle, 8+sample.size]; -- max number of bytes that will be written pos _ handle.filePos; IF prvPos<0 THEN deltaPos _ 0 ELSE { deltaPos _ pos-prvPos; IF deltaPos<=0 THEN ERROR; -- something is very wrong... }; Write29Bits[handle, deltaPos]; Write29Bits[handle, nextStep - sample.step]; -- must be >=0 !!! FOR i: NAT IN [0..sample.size) DO PutByte[handle, ORD[sample.value[i]]]; ENDLOOP; handle.filePos _ handle.filePos+sample.size; }; ReadSample: PROC [s: IO.STREAM, pos: INT, into: Sample, nextStep: INT] RETURNS [prvPos: INT] ~ { <> <> deltaPos: INT; IO.SetIndex[s, pos]; deltaPos _ Read29Bits[s]; IF deltaPos=0 THEN prvPos _ -1 ELSE { prvPos _ pos - deltaPos; IF prvPos<0 THEN ERROR; -- inconsistency in file management }; into.step _ nextStep - Read29Bits[s]; FOR i: NAT IN [0..into.size) DO into.value[i] _ VAL[IO.GetByte[s]]; ENDLOOP; }; <> RBTGetKey: RedBlackTree.GetKey ~ { <> RETURN [data]; -- keys are same as data... }; RBTCompare: RedBlackTree.Compare ~ { <> list1: SampleList = NARROW [k]; list2: SampleList = NARROW [data]; RETURN [Basics.CompareInt[list1.beforeHeadPos, list2.beforeHeadPos]]; }; EnterSourceInRBT: PROC [table: RedBlackTree.Table, source: REF ANY, min: INT _ 0] RETURNS [newTable: RedBlackTree.Table] ~ { <> <> <> EnterLogDataInRBT: PROC [data: LogData] ~ { IF data#NIL THEN { -- nothing ever logged for this guy... list: SampleList _ data.list; IF list=NIL THEN { -- must create list head list _ NEW [SampleListRec _ [ head: IF data.previous#NIL THEN data.previous ELSE data.current, beforeHeadPos: data.lastFilePos, inTable: FALSE]]; data.list _ list; }; IF list.beforeHeadPos<0 OR list.head.step<=min THEN RETURN; -- nothing to fetch IF newTable=NIL THEN newTable _ RedBlackTree.Create[RBTGetKey, RBTCompare]; IF NOT list.inTable THEN { -- may not insert twice in a RedBlackTree RedBlackTree.Insert[newTable, list, list]; list.inTable _ TRUE; }; }; }; newTable _ table; WITH source SELECT FROM rvl: Rosemary.RoseValues => UNTIL rvl=NIL DO -- this is for a CoreFlat wire EnterLogDataInRBT[NARROW [rvl.first.roseWire.data]]; rvl _ rvl.rest; -- advance list pointer ENDLOOP; roseInstance: Rosemary.RoseCellInstance => EnterLogDataInRBT[NARROW [roseInstance.data]]; ENDCASE => ERROR; }; ReadSamplesUsingRBT: PROC [handle: RoseDisplay, table: RedBlackTree.Table, min: INT] ~ { <> <> <> stream: IO.STREAM = handle.ps; FlushWBuff[handle, 0]; -- ensure we are really at end of file and the buffer is empty IF table#NIL THEN WHILE RedBlackTree.Size[table]#0 DO list: SampleList _ NARROW [RedBlackTree.LookupLargest[table]]; node: RedBlackTree.Node _ RedBlackTree.Delete[table, list]; sample: Sample _ NEW [SampleRec[list.head.size]]; list.beforeHeadPos _ ReadSample[stream, list.beforeHeadPos, sample, list.head.step]; sample.next _ list.head; list.head _ sample; -- insert as head of list IF sample.step>min AND list.beforeHeadPos>=0 THEN RedBlackTree.InsertNode[table, node, list] -- this one must still go on... ELSE list.inTable _ FALSE; -- it's no more there... ENDLOOP; IO.SetIndex[stream, handle.filePos]; -- go back to end of file }; <> <> <> <> <> <<>> LogTime: PROC [handle: RoseDisplay, time: INT] ~ { <> index: NAT _ time/timeBlock; offset: NAT _ time MOD timeBlock; block: TimeSteps _ handle.timeSteps[index]; handle.lastValidTime _ time; IF block=NIL THEN { IF offset#0 THEN ERROR; -- we missed a time value !!! block _ NEW [TimeStepsRep _ ALL[-1]]; handle.timeSteps[index] _ block; }; block[offset] _ handle.simulation.mosSimTime; }; LastStep: PROC [handle: RoseDisplay, time: INT] RETURNS [lastStep: INT] ~ { <> SELECT TRUE FROM time<0 => lastStep _ 0; time>handle.lastValidTime => lastStep _ handle.simulation.mosSimTime; ENDCASE => { -- normal case index: NAT _ time/timeBlock; offset: NAT _ time MOD timeBlock; lastStep _ handle.timeSteps[index][offset]; }; }; FirstStep: PROC [handle: RoseDisplay, time: INT] RETURNS [firstStep: INT] ~ { <> time _ time-1; SELECT TRUE FROM time<0 => firstStep _ 0; time>handle.lastValidTime => firstStep _ LAST[INT]; -- get lost ... ENDCASE => { -- normal case index: NAT _ time/timeBlock; offset: NAT _ time MOD timeBlock; firstStep _ handle.timeSteps[index][offset]+1; }; }; <> LSToSample: PROC [ls: Ports.LevelSequence, sample: Sample] ~ { <> IF ls.size#sample.size THEN ERROR; -- Client programming error or Rosemary bug FOR i: NAT IN [0.. ls.size) DO sample.value[i] _ ls[i] ENDLOOP; }; NewLogData: PROC [nbits: NAT] RETURNS [data: LogData] ~ { <> data _ NEW [LogDataRec]; data.lastFilePos _ -1; data.list _ NIL; -- not kept in memory (yet...) data.previous _ NIL; -- no previous sample data.currentTime _ -1; data.current _ NEW[SampleRec[nbits]]; data.current.next _ NIL; data.current.step _ 0; }; InitializeDeltas: PUBLIC PROC [handle: RoseDisplay] = { EraseWireData: RefTab.EachPairAction = { <> wire: Rosemary.RoseWire _ NARROW[val]; atomic: BOOL = wire.currentValue=NIL; data: LogData _ NewLogData[IF atomic THEN 1 ELSE wire.currentValue.size]; IF atomic THEN data.current.value[0] _ wire.wireLevel ELSE LSToSample[wire.currentValue, data.current]; wire.data _ data; }; EraseInstanceData: RefTab.EachPairAction ~ { <> roseInstance: Rosemary.RoseCellInstance _ NARROW [val]; ls: Ports.LevelSequence = NARROW [roseInstance.data]; IF ls#NIL THEN { -- make into a LogData data: LogData _ NewLogData[ls.size]; LSToSample[ls, data.current]; roseInstance.data _ data; }; }; LockBackingStore[handle]; -- Don't forget it here... LogTime[handle, 0]; IF handle.wBuff=NIL THEN handle.wBuff _ RefText.New[4096]; handle.wBuff.length _ 0; -- erase the buffer as it may contain garbage IF handle.ps=NIL THEN handle.ps _ FS.StreamOpen["///Temp/RoseBackingStore.bin", $create] ELSE IO.SetLength[handle.ps, 0]; -- completely erase the file if already there... handle.filePos _ 0; [] _ RefTab.Pairs[x: handle.simulation.coreToRoseWires, action: EraseWireData]; [] _ RefTab.Pairs[x: handle.simulation.coreToRoseInstances, action: EraseInstanceData]; UnlockBackingStore[handle]; -- we don't want to hold onto it during plotting ! IF handle.plot#NIL AND handle.plot.data#NIL THEN PlotGraph.RefreshPlot[plot: handle.plot, eraseFirst: TRUE]; }; CollapseSample: PROC [handle: RoseDisplay, data: LogData] ~ { <> <> nbits: NAT = data.current.size; DifferSample: PROC [s1, s2: Sample] RETURNS [BOOL] ~ { <> FOR i: CARDINAL IN [0..s1.size) DO IF s1.value[i]#s2.value[i] THEN RETURN [TRUE] ENDLOOP; RETURN [FALSE]; }; SELECT TRUE FROM data.previous=NIL => { -- this the 1st sample, make it previous & allocate new current data.previous _ data.current; data.current _ NEW[SampleRec[nbits]]; data.previous.next _ data.current; data.current.next _ NIL; -- just to make sure... }; DifferSample[data.previous, data.current] => { -- commit current sample data.lastFilePos _ WriteSample[handle, data.previous, data.lastFilePos, data.current.step]; data.current.next _ IF data.list=NIL THEN data.previous ELSE NEW[SampleRec[nbits]]; data.previous _ data.current; data.current _ data.previous.next; -- update data data.current.next _ NIL; -- necessary if data.previous was reused }; ENDCASE => NULL; -- collapse current with previous }; RecordDelta: PUBLIC PROC [handle: RoseDisplay, wire: Rosemary.RoseWire, time: INT] ~ { <> IF handle.recordDeltas THEN { -- otherwise, nop... data: LogData = NARROW [wire.data]; nbits: NAT = data.current.size; mosSimTime: INT = handle.simulation.mosSimTime; mustCollapse: BOOL = IF handle.recordSteps THEN mosSimTime#data.current.step ELSE time#data.currentTime; LockBackingStore[handle]; -- let's be paranoid... <> IF mustCollapse THEN { -- this is a different Eval CollapseSample[handle, data]; data.currentTime _ time; -- this is the new time for the curent sample data.current.step _ mosSimTime; -- this is the new step for the curent sample }; IF wire.currentValue=NIL THEN data.current.value[0] _ wire.wireLevel ELSE LSToSample[wire.currentValue, data.current]; UnlockBackingStore[handle]; }; IF handle.traceChanges THEN { -- debug output wireKey: CoreFlat.FlatWire _ NEW[CoreFlat.FlatWireRec _ wire.wire]; UpdateDisplay[handle]; IO.PutF[handle.tsout, "%g_%g ", IO.rope[CoreFlat.WirePathRope[handle.cellType, wireKey^]], IO.rope[Ports.LevelSequenceToRope[Rosemary.WireValue[ handle.simulation, wireKey]]]]; }; }; RecordStateSample: PUBLIC PROC [handle: RoseDisplay, roseInstance: Rosemary.RoseCellInstance, value: Ports.LevelSequence, time: INT] ~ { <> IF value#NIL AND handle.recordDeltas THEN { data: LogData = NARROW [roseInstance.data]; mosSimTime: INT = handle.simulation.mosSimTime; mustCollapse: BOOL = IF handle.recordSteps THEN mosSimTime#data.current.step ELSE time#data.currentTime; IF data=NIL THEN ERROR; -- InitProc should be returning an LS first !!! LockBackingStore[handle]; -- let's be paranoid... <> IF mustCollapse THEN { -- this is a different Eval CollapseSample[handle, data]; data.currentTime _ time; -- this is the new time for the curent sample data.current.step _ mosSimTime; -- this is the new step for the curent sample }; LSToSample[value, data.current]; UnlockBackingStore[handle]; }; IF handle.traceChanges THEN { -- cell has changed state UpdateDisplay[handle]; IO.PutF[handle.tsout, "<%g> ", IO.rope[CoreFlat.CellTypePathRope[handle.cellType, roseInstance.instance]]]; }; }; <> <> <> <<- PlotGraph almost always calls the GraphEnumerateProc with bounds=infinite (on fact, due to a PlotGraph bug, empty). As a result, when a new wire is displayed, it is always read back to the origin of times. It is not possible from the client code to infer the correct bounds (gathering them from the viewer will hamper IP generation). This should be fixed in PlotGraph (anyway, there are other things to be fixed there...).>> <<- It would be more efficient to add multiple wires to the plot at once than one at a time because refreshing requires reading the disk. Either have AddWiresToPlot instead of AddWireToPlot, or (better) leave the responsability of refreshing to the client.>> <<- It would be faster is InitPlotGraphData could avoid rewinding back to the beginning of times. This could be achieved by adding a "currentTime" field to the pgd, but this raises serious questions when the simulation is re-initialized because we then must invalidate all pgd's.>> <<>> PlotGraphData: TYPE ~ REF PlotGraphDataRec; PlotGraphDataRec: TYPE ~ RECORD [ source: REF ANY _ NIL, -- either RoseValues or RoseCellInstance bits: Ports.LevelSequence _ NIL, -- computed values will go in there clientData: REF ANY _ NIL, -- only for RoseCellInstances ropeProc: StateToRopeProc, -- only if display style is hexaV parts: SEQUENCE size: CARDINAL OF Sample -- basic information for reconstitution ]; <> <<>> roseGraphClass: PlotGraph.GraphClass _ NEW[PlotGraph.GraphClassRec _ [ enumerate: RoseGraphEnumerate]]; <> NewPlotGraphData: PROC [source: REF ANY, clientData: REF ANY, ropeProc: StateToRopeProc] RETURNS [pgd: PlotGraphData] ~ { <> partCount: NAT _ 0; bits: Ports.LevelSequence _ NIL; WITH source SELECT FROM rvl: Rosemary.RoseValues => { -- this plot is for a CoreFlat wire bitCount: NAT _ 0; UNTIL rvl=NIL DO val: Rosemary.RoseValue = rvl.first; bitCount _ bitCount+val.fieldWidth; partCount _ partCount + 1; rvl _ rvl.rest; ENDLOOP; bits _ NEW[Ports.LevelSequenceRec[bitCount]]; }; roseInstance: Rosemary.RoseCellInstance => { -- this plot is for an unexpanded cell <> <> partCount _ 1; }; ENDCASE => ERROR; -- internal bug, invalid argument pgd _ NEW[PlotGraphDataRec[partCount]]; pgd.source _ source; pgd.clientData _ clientData; pgd.ropeProc _ ropeProc; pgd.bits _ bits; }; InitPlotGraphData: PROC [handle: RoseDisplay, pgd: PlotGraphData, minStep: INT] RETURNS [effectiveStep: INT _ 0] ~ { <> <> <minStep, LAST[INT] means no value may be established).>> <> WITH pgd.source SELECT FROM rvl: Rosemary.RoseValues => { -- this is a wire plot FOR part: NAT IN [0..pgd.size) DO -- go up the sample chain up to minStep data: LogData = NARROW[rvl.first.roseWire.data]; sample: Sample; IF data=NIL OR data.list=NIL THEN RETURN [LAST[INT]]; -- not initialized ! sample _ data.list.head; -- cannot be NIL ! IF sample.step<=minStep THEN { -- try going forwards UNTIL sample.next=NIL OR sample.next.step>minStep DO sample _ sample.next; ENDLOOP; }; effectiveStep _ MAX[effectiveStep, sample.step]; pgd.parts[part] _ sample; rvl _ rvl.rest; ENDLOOP; }; roseInstance: Rosemary.RoseCellInstance => { -- this is a cell state plot <> data: LogData = NARROW[roseInstance.data]; sample: Sample; IF data=NIL OR data.list=NIL THEN RETURN [LAST[INT]]; -- no info available sample _ data.list.head; -- cannot be NIL ! IF pgd.bits=NIL THEN pgd.bits _ NEW[Ports.LevelSequenceRec[sample.size]]; IF sample.step<=minStep THEN { -- try going forwards UNTIL sample.next=NIL OR sample.next.step>minStep DO sample _ sample.next; ENDLOOP; }; effectiveStep _ sample.step; pgd.parts[0] _ sample; -- there is exactly 1 part in a cell state pgd }; ENDCASE => ERROR; }; AssemblePlotGraphDataBits: PROC [pgd: PlotGraphData] RETURNS [nextStep: INT] ~ { <> <> firstFreeBit: NAT _ 0; bits: Ports.LevelSequence _ pgd.bits; nextStep _ LAST[INT]; FOR i: NAT IN [0..pgd.size) DO -- build up the bits sample: Sample = pgd.parts[i]; FOR bit: NAT IN [0..sample.size) DO bits[firstFreeBit+bit] _ sample.value[bit] ENDLOOP; firstFreeBit _ firstFreeBit+sample.size; IF sample.next#NIL THEN nextStep _ MIN[sample.next.step, nextStep]; ENDLOOP; IF nextStep=LAST[INT] THEN RETURN; -- nothing more to do... FOR i: NAT IN [0..pgd.size) DO -- advance samples for nextTime sample: Sample = pgd.parts[i]; IF sample.next#NIL AND sample.next.step=nextStep THEN pgd.parts[i] _ sample.next; ENDLOOP; }; GetValueAt: PROC [handle: RoseDisplay, pgd: PlotGraphData, time: INT] RETURNS [ls: Ports.LevelSequence _ NIL] ~ { <> atStep: INT _ LastStep[handle, time]; -- convert to step specification possibleStep: INT; LockBackingStore[handle]; -- critical here... possibleStep _ InitPlotGraphData[handle, pgd, atStep]; IF possibleStep>atStep THEN { -- try from disk... table: RedBlackTree.Table _ EnterSourceInRBT[NIL, pgd.source, atStep]; IF table#NIL THEN ReadSamplesUsingRBT[handle, table, atStep]; possibleStep _ InitPlotGraphData[handle, pgd, atStep]; IF possibleStep>atStep THEN RETURN [NIL]; -- we lost the battle... }; IF possibleStep<=atStep THEN { [] _ AssemblePlotGraphDataBits[pgd]; ls _ NEW [Ports.LevelSequenceRec[pgd.bits.size]]; Ports.CopyLS[from: pgd.bits, to: ls]; }; UnlockBackingStore[handle]; -- may now safely release }; WireTimeValue: PUBLIC PROC [handle: RoseDisplay, flatWire: CoreFlat.FlatWire, time: INT] RETURNS [value: Ports.LevelSequence] = { <> roseValues: Rosemary.RoseValues _ Rosemary.GetValues[handle.simulation, flatWire]; value _ GetValueAt[handle, NewPlotGraphData[roseValues, NIL, NIL], time]; }; StateTimeValue: PUBLIC PROC [handle: RoseDisplay, flatCell: CoreFlat.FlatCellType, time: INT] RETURNS [value: Ports.LevelSequence] = { <> roseInstance: Rosemary.RoseCellInstance = NARROW [ RefTab.Fetch[handle.simulation.coreToRoseInstances, flatCell].val]; IF roseInstance=NIL THEN ERROR Rosemary.NotInstantiated[]; value _ GetValueAt[handle, NewPlotGraphData[roseInstance, NIL, NIL], time]; }; <> DisplayPortLeafWires: PUBLIC PROC [root: Core.CellType, flatCell: CoreFlat.FlatCellTypeRec _ CoreFlat.rootCellType] RETURNS [displayWires: CoreFlat.FlatWires] = { CompareFlatWires: List.CompareProc = { flat1: CoreFlat.FlatWire _ NARROW[ref1]; flat2: CoreFlat.FlatWire _ NARROW[ref2]; IF flat1.flatCell.path.length>flat2.flatCell.path.length THEN RETURN [greater]; IF flat1.flatCell.path.length RETURN [greater]; (NOT one) AND other => RETURN [less]; ENDCASE; ENDLOOP; IF flat1.flatCell.recastCount>flat2.flatCell.recastCount THEN RETURN [greater]; IF flat1.flatCell.recastCount> <> size: NAT = value.size; scratch: REF TEXT _ RefText.New[(size+3)/4]; bitsInDigit: NAT; digitBitCount: NAT _ 0; someX: BOOL _ FALSE; digitVal: CARDINAL _ 0; <> bitsInDigit _ ((size+3) MOD 4) + 1; FOR bit: NAT IN [0..size) DO SELECT value[bit] FROM H => digitVal _ 2*digitVal + 1; L => digitVal _ 2*digitVal; ENDCASE => someX _ TRUE; -- don't care about digitVal now... digitBitCount _ digitBitCount + 1; IF digitBitCount=bitsInDigit THEN { IF someX THEN scratch _ RefText.InlineAppendChar[scratch, 'X] ELSE scratch _ Convert.AppendCard[to: scratch, from: digitVal, base: 16, showRadix: FALSE]; bitsInDigit _ 4; digitBitCount _ 0; someX _ FALSE; digitVal _ 0; }; ENDLOOP; rope _ Rope.FromRefText[scratch]; }; AddGraph: PROC [handle: RoseDisplay, pgd: PlotGraphData, name: ROPE, style: PlotGraph.DrawingStyle, maxChars: NAT _ 8] ~ { <> plot: PlotGraph.Plot _ handle.plot; graph: PlotGraph.Graph _ NEW[PlotGraph.GraphRec _ [ class: roseGraphClass, data: pgd]]; axis: PlotGraph.Axis _ NEW[PlotGraph.AxisRec _ [ graphs: LIST [graph], bounds: [0.0, 0.0, 10.0, 6.0], name: name, style: style, maxChars: maxChars, axisData: [X: [ticks: 1.0, visible: TRUE], Y: [ticks: 1.0, visible: TRUE]] ]]; IF plot=NIL OR plot.data=NIL THEN { -- don't forget the plot might have been destroyed plot _ handle.plot _ PlotGraph.CreatePlot[handle.name]; PlotGraph.LockPlot[plot]; plot.lowerBounds _ [0.0, 0.0]; plot.upperBounds _ [Real.Float[handle.lastValidTime], 5.0]; plot.data _ handle; } ELSE PlotGraph.LockPlot[plot]; IF plot.axis#NIL THEN axis.bounds _ plot.axis.first.bounds; plot.axis _ CONS[axis, plot.axis]; PlotGraph.UnlockPlot[plot]; PlotGraph.RefreshPlot[plot: plot, eraseFirst: TRUE]; }; AddWireToPlot: PUBLIC PROC [handle: RoseDisplay, wire: CoreFlat.FlatWire] RETURNS [msg: ROPE _ NIL] = { <> roseValues: Rosemary.RoseValues _ Rosemary.GetValues[handle.simulation, wire ! Rosemary.NotInstantiated => GOTO NoSuchWire]; pgd: PlotGraphData _ NewPlotGraphData[roseValues, NIL, LSToRope]; name: ROPE _ CoreFlat.WirePathRope[handle.cellType, wire^]; IF Rope.Equal[Rope.Substr[name, 0, 7], "public."] THEN name _ Rope.Substr[name, 7]; IF pgd.bits.size=1 THEN AddGraph[handle, pgd, name, analog] ELSE AddGraph[handle, pgd, name, hexaV, (pgd.bits.size+3)/4]; EXITS NoSuchWire => msg _ "Not stored as a Rosemary wire"; }; stateToMaxCharsProcProp: PUBLIC ATOM _ $RoseStateToMaxCharsProc; stateToRopeProcProp: PUBLIC ATOM _ $RoseStateToRopeProc; AddStateToPlot: PUBLIC PROC [handle: RoseDisplay, flatCell: CoreFlat.FlatCellType, data: REF ANY _ NIL] RETURNS [msg: ROPE _ NIL] = { <> flat: CoreFlat.FlatCellType _ NEW[CoreFlat.FlatCellTypeRec _ flatCell^]; cellType: Core.CellType _ NIL; cellInstance: CoreClasses.CellInstance _ NIL; roseInstance: Rosemary.RoseCellInstance _ NIL; IF CoreFlat.BelowCutSet[handle.cellType, flatCell^, handle.cutSet] THEN RETURN [msg: "Below simulation cutset"]; [,cellInstance, cellType] _ CoreFlat.ResolveFlatCellType[handle.cellType, flat^]; UNTIL CoreFlat.CutSetMemberResolved[flat^, cellInstance, cellType, handle.cutSet] DO cellType _ CoreOps.Recast[cellType]; flat.recastCount _ flat.recastCount + 1; ENDLOOP; roseInstance _ NARROW [ RefTab.Fetch[handle.simulation.coreToRoseInstances, flat].val]; IF roseInstance#NIL THEN { charsProc: REF StateToMaxCharsProc _ NARROW [CoreProperties.InheritCellTypeProp[cellType, stateToMaxCharsProcProp]]; ropeProc: REF StateToRopeProc _ NARROW [CoreProperties.InheritCellTypeProp[cellType, stateToRopeProcProp]]; name: ROPE _ CoreFlat.CellTypePathRope[handle.cellType, flat^]; pgd: PlotGraphData _ NewPlotGraphData[roseInstance, data, IF ropeProc=NIL THEN LSToRope ELSE ropeProc^]; AddGraph[handle, pgd, name, hexaV, IF charsProc=NIL THEN (pgd.bits.size+3)/4 ELSE charsProc^[roseInstance.state, data]]; } ELSE msg _ "Not stored as a Rosemary cell instance"; }; RemoveFromPlot: PROC [handle: RoseDisplay, source: REF ANY, clientData: REF ANY] RETURNS [found: BOOL _ FALSE] ~ { plot: PlotGraph.Plot _ handle.plot; trail: PlotGraph.AxisList _ NIL; IF plot=NIL OR plot.data=NIL THEN RETURN; PlotGraph.LockPlot[plot]; FOR axis: PlotGraph.AxisList _ plot.axis, axis.rest UNTIL axis=NIL DO pgd: PlotGraphData _ NARROW[axis.first.graphs.first.data]; IF pgd.source=source AND pgd.clientData=clientData THEN { IF trail=NIL THEN plot.axis _ axis.rest ELSE trail.rest _ axis.rest; -- excise guilty axis found _ TRUE; EXIT; }; trail _ axis; ENDLOOP; PlotGraph.UnlockPlot[plot]; IF found THEN PlotGraph.RefreshPlot[plot: plot, eraseFirst: TRUE]; }; RemoveWireFromPlot: PUBLIC PROC [handle: RoseDisplay, wire: CoreFlat.FlatWire] RETURNS [found: BOOL _ FALSE] = { roseValues: Rosemary.RoseValues _ Rosemary.GetValues[handle.simulation, wire ! Rosemary.NotInstantiated => GOTO NoSuchWire]; found _ RemoveFromPlot[handle, roseValues, NIL]; EXITS NoSuchWire => NULL; }; RemoveStateFromPlot: PUBLIC PROC [handle: RoseDisplay, flatCell: CoreFlat.FlatCellType, data: REF ANY _ NIL] RETURNS [found: BOOL _ FALSE] = { roseInstance: Rosemary.RoseCellInstance = NARROW [ RefTab.Fetch[handle.simulation.coreToRoseInstances, flatCell].val]; IF roseInstance#NIL THEN found _ RemoveFromPlot[handle, roseInstance, data]; }; <> DeltaFinished: PUBLIC PROC [handle: RoseDisplay, time: INT] = { plot: PlotGraph.Plot _ handle.plot; LogTime[handle, time]; IF plot#NIL AND plot.data#NIL THEN { -- the plot viewer might have been destroyed ! oldUpper: REAL = plot.upperBounds.x-1.0; newUpper: REAL = Real.Float[time]; plot.upperBounds.x _ newUpper; PlotGraph.RefreshPlot[plot: plot, within: [oldUpper, 0.0, newUpper-oldUpper, 6.0]]; }; }; PGDStepProc: TYPE ~ PROC [pgd: PlotGraphData, rTime: REAL, notLast: BOOL]; EnumeratePGD: PROC [handle: RoseDisplay, pgd: PlotGraphData, from: REAL, to: REAL, eachStep: PGDStepProc, showSteps: BOOL] ~ { <> <> < everything is shown in full detail, may be unreadable, fractional time>> < show steps only if showSteps is TRUE (waveforms), fractional time>> < never show steps, force all display point on integer time boundaries>> <> firstCur, lastCur, step: INT; -- steps for current time: firstCur<=step<=lastCur, in fromTime firstLogged: INT; -- first time time at which we succeed to get a sample fromTime: INT _ Real.Floor[MAX[from, 0.0]]; -- we should start roughly from here fractional: BOOL; -- TRUE means time is fractional, FALSE time is forced to INT firstCur _ FirstStep[handle, fromTime]; -- first step in fromTime lastCur _ LastStep[handle, fromTime]; -- last step in fromTime step _ firstCur; firstLogged _ InitPlotGraphData[handle, pgd, firstCur]; IF firstLogged>firstCur THEN { -- read more data from disk table: RedBlackTree.Table _ NIL; plot: PlotGraph.Plot = handle.plot; FOR al: PlotGraph.AxisList _ plot.axis, al.rest UNTIL al=NIL DO -- pass over all axis FOR gl: PlotGraph.GraphList _ al.first.graphs, gl.rest UNTIL gl=NIL DO -- and all graphs thisPGD: PlotGraphData = NARROW [gl.first.data]; table _ EnterSourceInRBT[table, thisPGD.source, firstCur]; -- collect source values ENDLOOP; ENDLOOP; IF table#NIL THEN ReadSamplesUsingRBT[handle, table, firstCur]; firstLogged _ InitPlotGraphData[handle, pgd, firstCur]; }; <<-- At this point, firstLogged contains the 1st really available point of data.>> SELECT handle.plotStyle FROM allSteps => {showSteps _ TRUE; fractional _ TRUE}; waveSteps => {fractional _ TRUE}; noSteps => {showSteps _ FALSE; fractional _ FALSE}; ENDCASE => ERROR; IF step<=handle.simulation.mosSimTime THEN DO nextStep: INT = AssemblePlotGraphDataBits[pgd]; rTime: REAL; UNTIL step<=lastCur DO -- advance `fromTime' till it reaches step fromTime _ fromTime+1; firstCur _ lastCur+1; lastCur _ LastStep[handle, fromTime]; ENDLOOP; IF showSteps OR nextStep>lastCur THEN { -- show step, or last of time slot rTime _ Real.Float[fromTime]; IF fractional THEN rTime _ rTime - (lastCur-step)/Real.Float[lastCur-firstCur+1]; IF rTimehandle.simulation.mosSimTime THEN GO TO EndOfWindow; REPEAT EndOfWindow => eachStep[pgd, to, FALSE]; ENDLOOP; }; RoseGraphEnumerate: PlotGraph.GraphEnumerateProc = { <<[plot: Plot, graph: Graph, bounds: Rectangle, eachPoint: PointProc, data: REF ANY]>> ENABLE ABORTED => GOTO Aborted; -- in order to help debug... handle: RoseDisplay _ NARROW [plot.data]; pgd: PlotGraphData _ NARROW [graph.data]; low: REAL = MAX [bounds.x, 0]; high: REAL = handle.lastValidTime+1; -- bounds.w is incorrect in PlotGraph LockBackingStore[handle]; -- critical here... WITH pgd.source SELECT FROM rvl: Rosemary.RoseValues => { -- this plot is for a CoreFlat wire value: REAL; notFirst: BOOL _ FALSE; EachAnalogStep: PGDStepProc ~ { IF notFirst THEN [] _ eachPoint[x: rTime, y: value] ELSE notFirst _ TRUE; IF notLast THEN { value _ SELECT pgd.bits[0] FROM L => 0.0, X => 2.5, H => 5.0, ENDCASE => ERROR; [] _ eachPoint[x: rTime, y: value] }; }; EachWireStep: PGDStepProc ~ { value: ROPE = pgd.ropeProc[NIL, pgd.bits, pgd.clientData]; [] _ eachPoint[x: rTime, y: 0.0, rope: value] }; IF pgd.bits.size=1 THEN EnumeratePGD[handle, pgd, low, high, EachAnalogStep, TRUE] ELSE EnumeratePGD[handle, pgd, low, high, EachWireStep, FALSE]; }; roseInstance: Rosemary.RoseCellInstance => { -- this plot is for an unexpanded cell EachStateStep: PGDStepProc ~ { value: ROPE = pgd.ropeProc[roseInstance.state, pgd.bits, pgd.clientData]; [] _ eachPoint[x: rTime, y: 0.0, rope: value] }; EnumeratePGD[handle, pgd, low, high, EachStateStep, FALSE]; }; ENDCASE => ERROR; UnlockBackingStore[handle]; -- may now safely release EXITS Aborted => UnlockBackingStore[NARROW [plot.data]]; }; <> <> Entry: TYPE ~ REF EntryRep; LevelSeen: TYPE ~ RECORD [wasH, wasL: BOOL]; EntryRep: TYPE ~ RECORD [ pos: INT _ -1, roseWire: Rosemary.RoseWire, -- to print the wire name in case of error sample: Sample, -- to read the sample seen: PACKED SEQUENCE size: CARDINAL OF LevelSeen ]; <> MergeSample: PROC [entry: Entry, sample: Sample] RETURNS [allSeen: BOOL _ TRUE] ~ { <> FOR i: CARDINAL IN [0..entry.size) DO SELECT sample.value[i] FROM H => { entry.seen[i].wasH _ TRUE; allSeen _ allSeen AND entry.seen[i].wasL; }; L => { entry.seen[i].wasL _ TRUE; allSeen _ allSeen AND entry.seen[i].wasH; }; ENDCASE => allSeen _ allSeen AND entry.seen[i].wasH AND entry.seen[i].wasL; ENDLOOP; }; GetEntryKey: RedBlackTree.GetKey ~ { <> RETURN [data]; -- keys are same as data... }; CompareEntries: RedBlackTree.Compare ~ { <> e1: Entry = NARROW [k]; e2: Entry = NARROW [data]; RETURN [Basics.CompareInt[e1.pos, e2.pos]]; }; CheckCoverage: PUBLIC PROC [handle: RoseDisplay] RETURNS [ok: BOOL] ~ { <> <> <<- build an RBT containing all of the simulations roseWires>> <<- perform an algorithm similar to ReadSamplesUsingRBT:>> <<- when a wire has been both H and L, remove it from RBT>> <<- when a wire reaches the starting point and it has not been through both values, log a message & remove it from RBT>> InsertInRBT: RefTab.EachPairAction ~ { wire: Rosemary.RoseWire = NARROW[val]; data: LogData = NARROW [wire.data]; nBits: CARDINAL = data.current.size; entry: Entry _ NEW [EntryRep[nBits]]; entry.pos _ data.lastFilePos; entry.roseWire _ wire; entry.sample _ NEW [SampleRec[nBits]]; FOR i: CARDINAL IN [0..nBits) DO entry.seen[i] _ [FALSE, FALSE] ENDLOOP; IF MergeSample[entry, data.current] THEN RETURN; -- all bits have seen H and L IF data.previous#NIL AND MergeSample[entry, data.previous] THEN RETURN; -- H,L seen SELECT TRUE FROM entry.pos<0 => ReportEntry[entry]; -- we've seen all about it, and it fails RedBlackTree.LookupNode[table, entry]=NIL => RedBlackTree.Insert[table, entry, entry]; ENDCASE => NULL; -- discard the entry, it's already in the RBT somehow ... }; ReportEntry: PROC [entry: Entry] ~ { <> <> ReportAtomic: PROC [wire: Core.Wire] ~ { msg: ROPE; h, l: BOOL; [wasH: h, wasL: l] _ entry.seen[bit]; bit _ bit+1; SELECT TRUE FROM h AND l => RETURN; -- good bit h => msg _ "L"; l => msg _ "H"; ENDCASE => msg _ "H nor L"; flatWire.wire _ wire; handle.tsout.PutF["Wire %g does not go through %g\n", IO.rope[CoreFlat.WirePathRope[handle.cellType, flatWire]], IO.rope[msg]]; ok _ FALSE; -- at least one bit in error }; flatWire: CoreFlat.FlatWireRec _ entry.roseWire.wire; wireSize: NAT = CoreOps.WireBits[flatWire.wire]; bit: NAT _ 0; IF entry.roseWire.currentValue=NIL AND entry.roseWire.wireDrive=infinite THEN RETURN; IF wireSize#entry.size THEN ERROR; -- we're in BIG trouble IF wireSize>1 THEN CoreOps.VisitRootAtomics[flatWire.wire, ReportAtomic] ELSE ReportAtomic[flatWire.wire]; }; table: RedBlackTree.Table _ RedBlackTree.Create[GetEntryKey, CompareEntries]; LockBackingStore[handle]; -- the whole procedure assumes the backing store does not change FlushWBuff[handle, 0]; -- ensure we are really at end of file and the buffer is empty ok _ TRUE; -- until proven false ... [] _ RefTab.Pairs[x: handle.simulation.coreToRoseWires, action: InsertInRBT]; -- build RBT WHILE RedBlackTree.Size[table]#0 DO -- Read the backing file backwards entry: Entry _ NARROW [RedBlackTree.LookupLargest[table]]; node: RedBlackTree.Node _ RedBlackTree.Delete[table, entry]; entry.pos _ ReadSample[handle.ps, entry.pos, entry.sample, 0]; -- step is ignored IF MergeSample[entry, entry.sample] THEN LOOP; -- entry has seen H and L, discard IF entry.pos>=0 THEN RedBlackTree.InsertNode[table, node, entry] -- keep entry active ELSE ReportEntry[entry]; -- no more samples, but disagreement ENDLOOP; IO.SetIndex[handle.ps, handle.filePos]; -- go back to end of file UnlockBackingStore[handle]; }; <> BackingFileStats: PROC [handle: RoseDisplay] RETURNS [nSamples: INT, avgPosLen: REAL, avgStepLen: REAL, avgLSLen: REAL, compression: REAL] ~ { <> <> <<- build an RBT containing all of the simulations roseWires>> <<- Read all samples backwards & compute stats on the fly.>> <> InsertInRBT: RefTab.EachPairAction ~ { wire: Rosemary.RoseWire = NARROW[val]; data: LogData = NARROW [wire.data]; nBits: CARDINAL = data.current.size; sampleList: SampleList _ NEW [SampleListRec _ [head: NEW [SampleRec[nBits]], beforeHeadPos: data.lastFilePos, inTable: FALSE]]; SELECT TRUE FROM data.lastFilePos<0 => NULL; -- nothing stored on file for this entry RedBlackTree.LookupNode[table, sampleList]=NIL => RedBlackTree.Insert[table, sampleList, sampleList]; ENDCASE => NULL; -- discard the entry, it's already in the RBT somehow ... }; Length29: PROC [s: IO.STREAM] RETURNS [size: INT] ~ { b: BYTE _ IO.GetByte[s]; SELECT TRUE FROM Basics.BITAND[b, 00080H]=0 => { -- single byte size _ 1; }; Basics.BITAND[b, 00040H]=0 => { -- 2 bytes size _ 2; [] _ IO.GetByte[s]; }; Basics.BITAND[b, 00020H]=0 => { -- 3 bytes size _ 3; [] _ IO.GetByte[s]; [] _ IO.GetByte[s]; }; ENDCASE => { -- 4 bytes size _ 4; [] _ IO.GetByte[s]; [] _ IO.GetByte[s]; [] _ IO.GetByte[s]; }; }; table: RedBlackTree.Table _ RedBlackTree.Create[RBTGetKey, RBTCompare]; nLSBytes: INT _ 0; nPosBytes: INT _ 0; nStepBytes: INT _ 0; totalBytes: INT; nSamples _ 0; LockBackingStore[handle]; -- the whole procedure assumes the backing store does not change FlushWBuff[handle, 0]; -- ensure we are really at end of file and the buffer is empty totalBytes _ handle.filePos; [] _ RefTab.Pairs[x: handle.simulation.coreToRoseWires, action: InsertInRBT]; -- build RBT WHILE RedBlackTree.Size[table]#0 DO -- Read the backing file backwards sampleList: SampleList _ NARROW [RedBlackTree.LookupLargest[table]]; node: RedBlackTree.Node _ RedBlackTree.Delete[table, sampleList]; IO.SetIndex[handle.ps, sampleList.beforeHeadPos]; nSamples _ nSamples+1; nLSBytes _ nLSBytes+sampleList.head.size; nPosBytes _ nPosBytes+Length29[handle.ps]; nStepBytes _ nStepBytes+Length29[handle.ps]; sampleList.beforeHeadPos _ ReadSample[handle.ps, sampleList.beforeHeadPos, sampleList.head, 0]; -- step is ignored IF sampleList.beforeHeadPos>=0 THEN RedBlackTree.InsertNode[table, node, sampleList]; ENDLOOP; IO.SetIndex[handle.ps, handle.filePos]; -- go back to end of file UnlockBackingStore[handle]; avgPosLen _ Real.Float[nPosBytes]/Real.Float[nSamples]; avgStepLen _ Real.Float[nStepBytes]/Real.Float[nSamples]; avgLSLen _ Real.Float[nLSBytes]/Real.Float[nSamples]; compression _ Real.Float[8*nSamples+nLSBytes]/Real.Float[nPosBytes+nStepBytes+nLSBytes]; IF nPosBytes+nStepBytes+nLSBytes#totalBytes THEN ERROR; -- real strange... }; END.