-- LupineTimeTestDriver.mesa. -- Copyright (C) 1985 by Xerox Corporation. All rights reserved. -- Last edited by BZM on 2-Mar-82 21:12:38. -- Last edited by Andrew Birrell on January 26, 1983 6:08 pm -- Bob Hagmann February 8, 1985 5:11:04 pm PST -- This program is derived from Liaison's Mesa6 ParamTestDriver. DIRECTORY Heap USING [systemZone], LupineTimeTest, --USING [ALL] String USING [AppendLongNumber, AppendString, InvalidNumber, StringToDecimal], Mopcodes USING [zMISC], Process USING [Detach, Yield], Runtime USING [CallDebugger], SpyClient USING [StartSpy, StopSpy], System USING [GetClockPulses, Microseconds, Pulses, PulsesToMicroseconds], Time USING [Append, Current, Unpack], TTY USING [ Create, Destroy, GetLine, Handle, LineOverflow, NumberFormat, PutChar, PutCR, PutDecimal, PutLine, PutLongDecimal, PutLongNumber, PutString, Rubout, ResetUserAbort, UserAbort ]; LupineTimeTestDriver: PROGRAM IMPORTS TimeTest: LupineTimeTest, Heap, Process, Runtime, SpyClient, ShortString: String, System, Time, TTY = BEGIN -- Compiletime parameters: StandardNumberOfTrials: INTEGER = 1; StandardIterationsPerTrial: INTEGER = 3000; -- Runtime parameters: TestParameters: TYPE = MACHINE DEPENDENT RECORD [ useDoradoClock (0): BOOLEAN _ FALSE, countOnlyEmulatorCycles (1): BOOLEAN _ FALSE, checkResults (2): BOOLEAN _ TRUE, trials (3): INTEGER _ StandardNumberOfTrials, iterationsPerTrial (4): INTEGER _ StandardIterationsPerTrial, spying (5:0..0): BOOLEAN _ FALSE, spyOnProcs (5:1..1): BOOLEAN _ FALSE, showSpyData (5:2..2): {afterEachTest, afterAllTests} _ afterAllTests, filler (5:3..15): BOOLEAN _ NULL ]; DefaultTestParameters: TestParameters = []; -- Runtime inconsistency found: ParamsDisagree: SIGNAL = CODE; -- An echo test failed. -- This top-level driver routine is run in a separate process. user: TTY.Handle; String: TYPE = STRING; TestProcess: PROCEDURE = BEGIN logFileString: STRING = [100]; logFile: String _ UniqueName[ root: "LupineTimeTest"L, suffix: ".log"L, nameString: logFileString ]; user _ TTY.Create[name: logFile]; TestRoutine[logFile: logFile ! ABORTED => CONTINUE ]; TTY.Destroy[user]; END; UniqueName: PROCEDURE [root, suffix, nameString: String] RETURNS [rootSuffix: String] = BEGIN rootSuffix _ nameString; rootSuffix.length _ 0; ShortString.AppendString[to: rootSuffix, from: root]; ShortString.AppendLongNumber [ s: rootSuffix, n: System.GetClockPulses[], radix: 10 ]; ShortString.AppendString[to: rootSuffix, from: suffix]; END; -- For periodically causing glitches (eg, NIL) that Lupine claims to handle. Periodically: PROC [testNumber: INTEGER] RETURNS [--yes:-- BOOLEAN] = --INLINE-- {RETURN[ (testNumber MOD 31) = 0 ]}; -- Main Timing Test. tp: TestParameters; -- Global values. TestRoutine: PROCEDURE[logFile: String] = BEGIN -- The entire test is in a loop. InitPrecisionTimings; DO ENABLE BEGIN AbortTest => CONTINUE; UNWIND => FinishPrecisionTimings; END; -- Get Test Parameters. tp _ DefaultTestParameters; TTY.PutCR[user]; TTY.PutLine[user, "Lupine RPC Timing Test of 24 February 1982."L]; TTY.PutString[user, "Results appear in file "L]; TTY.PutString[user, logFile]; TimeStamp[" of "L]; TTY.PutCR[user]; TTY.PutString[user, "Your options are: D Don't check results of remote calls for correctness. E Exclude nonemulator cycles in timings (Dorados only). G Go (type this last). H High precision timings (Dorados only). P Procedure-level spying (via Copilot). R Reset test parameters to default values. S Spy after all tests are over. T Spy at the conclusion of each test. Q Quit this program immediately. -- This line is a comment. 1-9 Perform # trials of each test. ^DEL To abort at any time."L ]; TTY.PutCR[user]; TTY.PutCR[user]; DO OPEN tp, TTY; BEGIN reply: STRING = [100]; PutString[user, "Type one of D,E,G,H,P,R,S,T,Q,--,1-9 [R1]: "L]; reply[0] _ 0C; CheckAbort; GetLine[user, reply ! Rubout, LineOverflow => GOTO TryAgain]; CheckAbort; SELECT reply[0] FROM 'd, 'D => {checkResults _ FALSE}; 'e, 'E => {useDoradoClock _ countOnlyEmulatorCycles _ TRUE}; 'g, 'G => {EXIT}; 'h, 'H => {useDoradoClock _ TRUE}; 'p, 'P => {spying _ spyOnProcs _ TRUE}; 'r, 'R => {tp _ DefaultTestParameters}; 's, 'S => {spying _ TRUE; showSpyData _ afterAllTests}; 't, 'T => {spying _ TRUE; showSpyData _ afterEachTest}; 'q, 'Q => {GOTO QuitTestProgram}; '- => {NULL}; IN ['1..'9] => {trials _ ShortString.StringToDecimal[ reply ! ShortString.InvalidNumber => GOTO TryAgain ]}; ENDCASE => GOTO TryAgain; EXITS TryAgain => PutLine[user, " ???"L]; END; ENDLOOP; -- Call debugger as needed for spying. IF tp.spying THEN CallSpy[ IF tp.spyOnProcs THEN startAndWatchDetails ELSE start ]; -- Eliminating timing transients before timings start. TimeTest.Null[]; TimeTest.Null[]; TimeTest.Null[]; -- Perform testing. NullTests; SimpleParameterTests; SignalTests; SmallArrayTests; --BigArrayTests; -- Call debugger as needed for spying. IF tp.spying THEN CallSpy[ (SELECT tp.showSpyData FROM afterEachTest => stop, afterAllTests => stopAndDisplayStats, ENDCASE => ERROR) ]; REPEAT QuitTestProgram => NULL; ENDLOOP; -- Test Loop. FinishPrecisionTimings; END; -- TestRoutine. NullTests: PROC = BEGIN -- Timing overhead. StartTest[testName: "per call timing overhead"L, skipSpy: TRUE]; THROUGH [0..tp.trials) DO StampTest; FOR test: INTEGER IN [0..tp.iterationsPerTrial) DO --DelayTest; StartPrecisionTiming; NULL; StopPrecisionTiming; ENDLOOP; ENDLOOP; StopTest[skipSpy: TRUE]; -- Null Procedure StartTest["the null procedure"L]; THROUGH [0..tp.trials) DO StampTest; FOR test: INTEGER IN [0..tp.iterationsPerTrial) DO DelayTest; StartPrecisionTiming; TimeTest.Null[]; StopPrecisionTiming; ENDLOOP; ENDLOOP; StopTest; END; -- NullTests. SimpleParameterTests: PROC = BEGIN a,b,c,d,e,f,g,h,i,j: INTEGER; StartTest["a 1 parameter procedure"L]; THROUGH [0..tp.trials) DO StampTest; FOR test: INTEGER IN [0..tp.iterationsPerTrial) DO DelayTest; StartPrecisionTiming; a _ TimeTest.One[test]; StopPrecisionTiming; IF tp.checkResults AND a#test THEN SIGNAL ParamsDisagree; ENDLOOP; ENDLOOP; StopTest; StartTest["a 2 parameter procedure"L]; THROUGH [0..tp.trials) DO StampTest; FOR test: INTEGER IN [0..tp.iterationsPerTrial) DO DelayTest; StartPrecisionTiming; [a,b] _ TimeTest.Two[test+0,test+1]; StopPrecisionTiming; IF tp.checkResults AND (a#test+0 OR b#test+1) THEN SIGNAL ParamsDisagree; ENDLOOP; ENDLOOP; StopTest; StartTest["a 4 parameter procedure"L]; THROUGH [0..tp.trials) DO StampTest; FOR test: INTEGER IN [0..tp.iterationsPerTrial) DO DelayTest; StartPrecisionTiming; [a,b,c,d] _ TimeTest.Four[test+0,test+1,test+2,test+3]; StopPrecisionTiming; IF tp.checkResults AND (a#test+0 OR b#test+1 OR c#test+2 OR d#test+3) THEN SIGNAL ParamsDisagree; ENDLOOP; ENDLOOP; StopTest; StartTest["a 10 parameter procedure"L]; THROUGH [0..tp.trials) DO StampTest; FOR test: INTEGER IN [0..tp.iterationsPerTrial) DO DelayTest; StartPrecisionTiming; [a,b,c,d,e,f,g,h,i,j] _ TimeTest.Ten[ test+0,test+1,test+2,test+3,test+4, test+5,test+6,test+7,test+8,test+9 ]; StopPrecisionTiming; IF tp.checkResults AND (a#test+0 OR b#test+1 OR c#test+2 OR d#test+3 OR e#test+4 OR f#test+5 OR g#test+6 OR h#test+7 OR i#test+8 OR j#test+9) THEN SIGNAL ParamsDisagree; ENDLOOP; ENDLOOP; StopTest; END; -- SimpleParameterTests. SignalTests: PROC = BEGIN out: INTEGER; StartTest["signal test (no signalling)"L]; THROUGH [0..tp.trials) DO StampTest; FOR test: INTEGER IN [0..tp.iterationsPerTrial) DO DelayTest; StartPrecisionTiming; out _ TimeTest.SignalTest[ in: test, action: neither ! TimeTest.Signal => {SIGNAL ParamsDisagree; CONTINUE} ]; StopPrecisionTiming; IF tp.checkResults AND out#test THEN SIGNAL ParamsDisagree; ENDLOOP; ENDLOOP; StopTest; StartTest["signal test (SIGNAL & RESUME)"L]; THROUGH [0..tp.trials) DO StampTest; FOR test: INTEGER IN [0..tp.iterationsPerTrial) DO DelayTest; StartPrecisionTiming; out _ TimeTest.SignalTest[ in: test, action: signal ! TimeTest.Signal => { IF tp.checkResults AND in#test THEN SIGNAL ParamsDisagree; RESUME[out: 2*in] } ]; StopPrecisionTiming; IF tp.checkResults AND out#2*test THEN SIGNAL ParamsDisagree; ENDLOOP; ENDLOOP; StopTest; StartTest["signal test (ERROR & UNWIND)"L]; THROUGH [0..tp.trials) DO StampTest; FOR test: INTEGER IN [0..tp.iterationsPerTrial) DO DelayTest; StartPrecisionTiming; out _ TimeTest.SignalTest[ in: test, action: error ! TimeTest.Signal => { IF tp.checkResults AND in#test THEN SIGNAL ParamsDisagree; CONTINUE } ]; StopPrecisionTiming; --Checking is never valid after an ERROR since out is undefined. ENDLOOP; ENDLOOP; StopTest; END; -- SignalTests. SmallArrayTests: PROC = BEGIN one: TimeTest.Array1 = ALL[1]; four: TimeTest.Array4 = ALL[4]; ten: TimeTest.Array10 = ALL[10]; forty: TimeTest.Array40 = ALL [40]; hundred: TimeTest.Array100 = ALL[100]; array1: TimeTest.Array1; array4: TimeTest.Array4; array10: TimeTest.Array10; array40: TimeTest.Array40; array100: TimeTest.Array100; StartTest["1 word array procedure"L]; THROUGH [0..tp.trials) DO StampTest; FOR test: INTEGER IN [0..tp.iterationsPerTrial) DO DelayTest; StartPrecisionTiming; array1 _ TimeTest.OneArray[one]; StopPrecisionTiming; IF tp.checkResults AND one#array1 THEN SIGNAL ParamsDisagree; ENDLOOP; ENDLOOP; StopTest; StartTest["4 word array procedure"L]; THROUGH [0..tp.trials) DO StampTest; FOR test: INTEGER IN [0..tp.iterationsPerTrial) DO DelayTest; StartPrecisionTiming; array4 _ TimeTest.FourArray[four]; StopPrecisionTiming; IF tp.checkResults AND four#array4 THEN SIGNAL ParamsDisagree; ENDLOOP; ENDLOOP; StopTest; StartTest["10 word array procedure"L]; THROUGH [0..tp.trials) DO StampTest; FOR test: INTEGER IN [0..tp.iterationsPerTrial) DO DelayTest; StartPrecisionTiming; array10 _ TimeTest.TenArray[ten]; StopPrecisionTiming; IF tp.checkResults AND ten#array10 THEN SIGNAL ParamsDisagree; ENDLOOP; ENDLOOP; StopTest; StartTest["40 word array procedure"L]; THROUGH [0..tp.trials) DO StampTest; FOR test: INTEGER IN [0..tp.iterationsPerTrial) DO DelayTest; StartPrecisionTiming; array40 _ TimeTest.FortyArray[forty]; StopPrecisionTiming; IF tp.checkResults AND forty#array40 THEN SIGNAL ParamsDisagree; ENDLOOP; ENDLOOP; StopTest; StartTest["100 word array procedure"L]; THROUGH [0..tp.trials) DO StampTest; FOR test: INTEGER IN [0..tp.iterationsPerTrial) DO DelayTest; StartPrecisionTiming; array100 _ TimeTest.HundredArray[hundred]; StopPrecisionTiming; IF tp.checkResults AND hundred#array100 THEN SIGNAL ParamsDisagree; ENDLOOP; ENDLOOP; StopTest; END; -- SmallArrayTests. -- Primary time logging routines that use Pilot's timer. StartTest: PROC [testName: String, skipSpy: BOOLEAN_FALSE] = BEGIN OPEN TTY; CheckAbort; PutCR[user]; PutCR[user]; PutString[user, "Timing "L]; PutDecimal[user, tp.trials]; PutString[user, " trials of "L]; PutString[user, testName]; TimeStamp[" at "L]; PreparePrecisionTimings; IF ~skipSpy AND tp.spying THEN CallSpy[startSpy]; StartTimer[reset:TRUE]; END; StampTest: PROC = INLINE {StopTimer; DoStampTest; StartTimer}; DoStampTest: PROC = BEGIN OPEN TTY; PutString[user, "Doing "L]; PutLongDecimal[user, tp.iterationsPerTrial]; TimeStamp[" calls at "L]; END; DelayTest: PROC = INLINE BEGIN StopTimer; CheckAbort; Delay[1000]; StartTimer; END; StopTest: PROC [skipSpy: BOOLEAN_FALSE] = BEGIN OPEN TTY; ms, tenths: LONG INTEGER; StopTimer[]; IF ~skipSpy AND tp.spying THEN CallSpy[stopSpy]; CheckAbort; [ms, tenths] _ ConvertTimer[ReadTimer[].elapsed/(tp.trials*LONG[tp.iterationsPerTrial])]; PutString[user, "The average call time (any checking included) was "L]; PutLongDecimal[user, ms]; PutChar[user, '.]; PutLongDecimal[user, tenths]; TimeStamp[" ms at "L]; PrintPrecisionTimings; IF ~skipSpy AND tp.spying AND tp.showSpyData=afterEachTest THEN CallSpy[displayStats]; END; TimeStamp: PROC [herald: String] = BEGIN OPEN TTY; timeString: STRING = [100]; CheckAbort; Time.Append[timeString, Time.Unpack[Time.Current[]]]; PutString[user, herald]; PutString[user, timeString]; PutLine[user, "."L]; END; AbortTest: PRIVATE ERROR = CODE; -- Raised by CheckAbort and caught in TestRoutine. CheckAbort: PROC = BEGIN OPEN TTY; IF ~UserAbort[] THEN RETURN; ResetUserAbort; PutCR[user]; PutLine[user, "Test aborted..."L]; ERROR AbortTest; END; -- Pilot Timing Routines. SystemTime: TYPE = LONG CARDINAL; -- Same as System.Pulses. Microseconds: TYPE = LONG CARDINAL; ReadPilotClock: PROC RETURNS [SystemTime] = INLINE {RETURN[ LOOPHOLE[System.GetClockPulses[]] ]}; PilotPrecisionRead: PROC RETURNS [--SystemTime-- PrecisionTime] = INLINE { RETURN[ ReadPilotClock[] ] }; PilotPrecisionConvert: PROC [pt: --SystemTime-- PrecisionTime] RETURNS [--microseconds:-- Microseconds] = ----INLINE---- {RETURN[ SystemTimeToUsec[pt] ]}; hrStartTime, hrEventTime, hrElapsedTime: SystemTime _ 0; StartTimer: PROC [reset: BOOLEAN_FALSE] = INLINE BEGIN IF reset THEN hrElapsedTime _ 0; hrStartTime _ ReadPilotClock[]; END; StopTimer: PROC = INLINE BEGIN hrEventTime _ ReadPilotClock[] - hrStartTime; hrElapsedTime _ hrElapsedTime + hrEventTime; END; ReadTimer: PROC RETURNS [event, elapsed: SystemTime] = ----INLINE---- BEGIN RETURN[hrEventTime, hrElapsedTime] END; ConvertTimer: PROC [time: SystemTime] RETURNS [ms,tenthsOfMs: LONG INTEGER] = BEGIN time _ (SystemTimeToUsec[time]+50)/100; ms _ time/10; tenthsOfMs _ time MOD 10; END; SystemTimeToUsec: PROC [time: SystemTime] RETURNS [Microseconds] = INLINE BEGIN RETURN[ System.PulsesToMicroseconds[System.Pulses[time]] ] END; lastDelayFinished: SystemTime _ 0; Delay: PROC [interval: --Microseconds-- LONG INTEGER] = -- Spin at least "interval" between executions. There is a startup glitch. BEGIN LastIntegerTime: SystemTime = LAST[LONG INTEGER]; DO grossWait: SystemTime = SystemTimeToUsec[ReadPilotClock[]-lastDelayFinished]; waitTime: LONG INTEGER = IF grossWait < LastIntegerTime THEN grossWait ELSE LastIntegerTime; SELECT interval-waitTime FROM < 0 => EXIT; < 50 => NULL; ENDCASE => Process.Yield; ENDLOOP; lastDelayFinished _ ReadPilotClock[]; END; -- Individual call high precision timing routines. PrecisionTime: TYPE = LONG CARDINAL; RingBufferIndex: TYPE = INTEGER[0..StandardIterationsPerTrial); SortBufferIndex: TYPE = INTEGER[0..LAST[RingBufferIndex]+2); RingBuffer: TYPE = ARRAY RingBufferIndex OF PrecisionTime; SortBuffer: TYPE = ARRAY SortBufferIndex OF PrecisionTime; ptRingIndex: RingBufferIndex _ LAST[RingBufferIndex]; ptRingBuffer: LONG DESCRIPTOR FOR RingBuffer _ DESCRIPTOR [NIL, 0]; ptSortBuffer: LONG DESCRIPTOR FOR SortBuffer _ DESCRIPTOR [NIL, 0]; ptStartTime: PrecisionTime; StartPrecisionTiming: PROC = INLINE BEGIN ptStartTime _ PrecisionRead[]; END; StopPrecisionTiming: PROC = INLINE BEGIN ptStopTime: PrecisionTime = PrecisionRead[]; ptRingBuffer[(ptRingIndex _ (ptRingIndex+1) MOD (LAST[RingBufferIndex]+1))] _ (ptStopTime - ptStartTime); END; PrecisionRead: PROC RETURNS [--pt:-- PrecisionTime] = INLINE BEGIN RETURN[IF tp.useDoradoClock THEN DoradoPrecisionRead[] ELSE PilotPrecisionRead[] ]; END; PrecisionConvert: PROC [pt: PrecisionTime] RETURNS [--microseconds:-- Microseconds] = ----INLINE---- BEGIN RETURN[IF tp.useDoradoClock THEN DoradoPrecisionConvert[pt] ELSE PilotPrecisionConvert[pt] ]; END; -- Precision timing routines. InitPrecisionTimings: PROC = BEGIN -- A compiler LENGTH computation bug makes this ugly: bufferPtr: LONG POINTER TO SortBuffer _ Heap.systemZone.NEW[SortBuffer]; ptSortBuffer _ DESCRIPTOR[bufferPtr, LENGTH[bufferPtr^]]; ptRingBuffer _ DESCRIPTOR [ @ptSortBuffer[FIRST[SortBufferIndex]+1], LENGTH[LOOPHOLE[NIL, POINTER TO RingBuffer]^] ]; END; FinishPrecisionTimings: PROC = BEGIN bufferPtr: LONG POINTER TO SortBuffer _ BASE[ptSortBuffer]; Heap.systemZone.FREE[@bufferPtr]; ptSortBuffer _ NIL; ptRingBuffer _ NIL; END; PreparePrecisionTimings: PROC = BEGIN IF BASE[ptRingBuffer] = NIL THEN ERROR; ptRingIndex _ LAST[RingBufferIndex]; FOR i: RingBufferIndex IN RingBufferIndex DO ptRingBuffer[i] _ 0 ENDLOOP; IF tp.useDoradoClock THEN StartDoradoCounters[EmuCycles]; END; PrintPrecisionTimings: PROC = BEGIN OPEN TTY; Range: INTEGER = 10; PrintRange: PROC [herald: String, startIndex: RingBufferIndex] = BEGIN PutString[user, herald]; FOR i: RingBufferIndex IN [startIndex..startIndex+Range) DO IF ptRingBuffer[i] > 99999 THEN PutString[user, " *****"L] ELSE PutLongNumber[ h: user, n: ptRingBuffer[i], format: [base: 10, zerofill: FALSE, unsigned: TRUE, columns: 6] ]; ENDLOOP; PutCR[user]; END; -- PrintRange. FOR i: RingBufferIndex IN RingBufferIndex DO ptRingBuffer[i] _ PrecisionConvert[ptRingBuffer[i]]; ENDLOOP; QuickSort[ptSortBuffer]; PutString[user, "Some instantaneous call times (microseconds) from a "L]; PutDecimal[user, LAST[RingBufferIndex]-FIRST[RingBufferIndex]+1]; PutLine[user, " element ring buffer:"L]; PrintRange[" Fastest times:"L, FIRST[RingBufferIndex]]; PrintRange[" Median times: "L, (LAST[RingBufferIndex]-FIRST[RingBufferIndex]-Range)/2]; PrintRange[" Slowest times:"L, LAST[RingBufferIndex]-Range]; END; -- Dorado 64ns precision counter routines. -- Modified from [Ivy]Measurements>Measure.mesa. doradoCounters: CounterVector _ ZeroCounterVector; DoradoPrecisionRead: PROC RETURNS [PrecisionTime] = INLINE BEGIN ReadDoradoCounters[@doradoCounters]; RETURN[IF tp.countOnlyEmulatorCycles THEN doradoCounters.A.low ELSE doradoCounters.B.low ]; END; DoradoPrecisionConvert: PROC [pt: PrecisionTime] RETURNS [--microseconds:-- Microseconds] = ----INLINE---- BEGIN -- Measured clock time was 2*32.2 ns => 644/10000 = 161/2500 usec/cycle -- Compute slowly to avoid overflow and do rounding. RETURN[ (LONG[161]*(pt/LONG[2500])) + ( LONG[161]*(pt MOD LONG[2500])+LONG[2500/2] )/LONG[2500] ]; END; StartDoradoCounters: PROCEDURE [CounterDescriptor] = MACHINE CODE BEGIN Mopcodes.zMISC, 240B END; ReadDoradoCounters: PROCEDURE [CounterVectorPtr] = MACHINE CODE BEGIN Mopcodes.zMISC, 241B END; StopDoradoCounters: PROCEDURE = MACHINE CODE BEGIN Mopcodes.zMISC, 242B END; CounterVector: TYPE = MACHINE DEPENDENT RECORD [ A(0): MACHINE DEPENDENT RECORD [low(0): LONG CARDINAL, high(2): CARDINAL], B(3): MACHINE DEPENDENT RECORD [low(0): LONG CARDINAL, high(2): CARDINAL] ]; ZeroCounterVector: CounterVector = [[0,0],[0,0]]; CounterVectorPtr: TYPE = LONG POINTER TO CounterVector; ASelection: TYPE = MACHINE DEPENDENT { true, hold, procRef, ifuJump, miss, bpa, bpc, bpe }; BSelection: TYPE = MACHINE DEPENDENT { true, hold, ifuRef, ifuNrdy, miss, bpb, bpc, bpd }; allA, allB, doA, doB: BOOLEAN = TRUE; emuOnlyA, emuOnlyB, notIS: BOOLEAN = FALSE; CounterDescriptor: TYPE = MACHINE DEPENDENT RECORD [ instrSet: BOOLEAN, ignoreBits123: [0..7], enableA, enableB: BOOLEAN, ignoreBits67: [0..3], aSelects: ASelection, allTasksA: BOOLEAN, bSelects: BSelection, allTasksB: BOOLEAN ]; EmuCycles: CounterDescriptor = [notIS,0,doA,doB,0,true,emuOnlyA,true,allB]; -- This Quicksort routine is from Sedgewick's thesis. -- It is a transliteration of [Maxc2]STSRT.SAI. QuickSort: PROC [table: LONG DESCRIPTOR FOR ARRAY OF PrecisionTime] = BEGIN first: INTEGER = 0; last: INTEGER = LENGTH[table]-1; M: INTEGER = 9; PP, L, R, I, J: INTEGER; V, TK: PrecisionTime; STACK: ARRAY [0..50) OF INTEGER; --Originally: STACK: ARRAY [0:2*(LOG(256/(M+2)) DIV 1)+1] OF INTEGER; table[first] _ FIRST[PrecisionTime]; table[last] _ LAST[PrecisionTime]; PP _ 0; L _ first+1; R _ last-1; WHILE PP >=0 DO I _ L; J _ R+1; V _ table[L]; WHILE I < J DO I_I+1; WHILE table[I]V DO J _ J-1 ENDLOOP; TK_table[J]; table[J]_table[I]; table[I]_TK; ENDLOOP; table[I]_table[J]; table[J]_table[L]; table[L]_TK; SELECT TRUE FROM R-J > J-L => SELECT TRUE FROM R-J <= M => NULL; J-L <= M => {L_J+1; LOOP}; ENDCASE => BEGIN PP_PP+2; STACK[PP]_J+1; STACK[PP+1]_R; R_J-1; LOOP; END; J-L <= M => NULL; R-J <= M => {R_J-1; LOOP}; ENDCASE => BEGIN PP _ PP+2; STACK[PP]_L; STACK[PP+1]_J-1; L_J+1; LOOP; END; L_STACK[PP]; R_STACK[PP+1]; PP_PP-2; REPEAT FINISHED => FOR I IN [2..last) DO V_table[I]; J_I-1; WHILE table[J]>V DO table[J+1]_table[J]; J_J-1 ENDLOOP; table[J+1]_V; ENDLOOP; ENDLOOP; END; -- General spy routine, in the hope that the real procedural interface improves. CallSpy: PROCEDURE[operation: { start, startAndWatchDetails, startSpy, stopSpy, displayStats, stop, stopAndDisplayStats } ] = BEGIN SELECT operation FROM start => Runtime.CallDebugger["Start Spy..."L]; startAndWatchDetails => Runtime.CallDebugger["Start Spy and finger specific procs..."L]; startSpy => SpyClient.StartSpy; stopSpy => SpyClient.StopSpy; displayStats => Runtime.CallDebugger["Examine Spy statistics..."L]; stop => Runtime.CallDebugger["Stop Spy..."L]; stopAndDisplayStats => Runtime.CallDebugger["Stop Spy and examine statistics..."L]; ENDCASE => ERROR; END; -- Module Initialization. Process.Detach[FORK TestProcess[]]; END. -- LupineTimeTestDriver. BigArrayTests: PROC = BEGIN fourHundred: TimeTest.Array400 = ALL[400]; thousand: TimeTest.Array1000 = ALL[1000]; array400: TimeTest.Array400; array1000: TimeTest.Array1000; StartTest["400 word array procedure"L]; THROUGH [0..tp.trials) DO StampTest; FOR test: INTEGER IN [0..tp.iterationsPerTrial) DO DelayTest; StartPrecisionTiming; array400 _ TimeTest.FourHundredArray[fourHundred]; StopPrecisionTiming; IF tp.checkResults AND fourHundred#array400 THEN SIGNAL ParamsDisagree; ENDLOOP; ENDLOOP; StopTest; StartTest["1000 word array procedure"L]; THROUGH [0..tp.trials) DO StampTest; FOR test: INTEGER IN [0..tp.iterationsPerTrial) DO DelayTest; StartPrecisionTiming; array1000 _ TimeTest.ThousandArray[thousand]; StopPrecisionTiming; IF tp.checkResults AND thousand#array1000 THEN SIGNAL ParamsDisagree; ENDLOOP; ENDLOOP; StopTest; END; -- BigArrayTests. -- String and array descriptor test. Alphabet: TYPE = PACKED ARRAY [0..26) OF CHARACTER; string1: String = "AbCdEfGhIjKlMnOpQrStUvWxYz"L; string2: String = "12345678901234567890123456"L; text: Alphabet; textDescriptor: TimeTest.RESULTTextDescriptor = DESCRIPTOR[text]; StartTest["26 character string to sequence procedure"L]; THROUGH [0..tp.trials) DO StampTest; FOR test: INTEGER IN [0..tp.iterationsPerTrial) DO string: String = IF test MOD 2 = 0 THEN string1 ELSE string2; DelayTest; StartPrecisionTiming; TimeTest.StringDescriptor[string, textDescriptor]; StopPrecisionTiming; IF tp.checkResults AND LOOPHOLE[@string.text, LONG POINTER TO Alphabet]^ # LOOPHOLE[BASE[textDescriptor], LONG POINTER TO Alphabet]^ THEN SIGNAL ParamsDisagree; ENDLOOP; ENDLOOP; StopTest; <> <> <<>>