DIRECTORY
AllocatorOps USING [BlockSize, REFToHP],
Basics USING [BITAND],
BasicTime USING [GetClockPulses, Pulses],
DebuggerSwap USING [CallDebugger],
FastBreak USING [FastBreakProc],
IntervalTimer USING [Wait],
IntervalTimerFace USING [exists],
PrincOps,
PrincOpsUtils USING [DisableInterrupts, EnableInterrupts, LongNotify, LongReEnter, LongWait, PsbIndexToHandle, PsbHandleToIndex, ReadPSB, ReadPTC],
Process USING [Detach, GetCurrent, GetPriority, InitializeCondition, Priority, priorityFaultHandlers, priorityRealTime, priorityNormal, SecondsToTicks, SetPriority, TicksToMsec],
Rope USING [ROPE],
SafeStorage USING [NWordsAllocated, NWordsReclaimed],
Loader USING [MakeProcedureResident, MakeGlobalFrameResident],
SpyClient USING [DataType, StackType],
SpyLog USING [active, Here, InvisibleProcesses, OpenForWrite, WriteData],
SpyOps USING [Count, DataType, Frame, SetAllocationBreak, SpyState, Stack, stackHeader, stackLength, StackType],
SystemVersion USING [machineType],
VM USING [AddressFault, PageNumberForAddress],
VMStatistics USING [pageFaults];
SpyKernelImpl: MONITOR
IMPORTS AllocatorOps, Basics, BasicTime, DebuggerSwap, IntervalTimer, IntervalTimerFace, Loader, PrincOpsUtils, Process, SafeStorage, SpyLog, SpyOps, SystemVersion, VM, VMStatistics
EXPORTS SpyClient, SpyOps
= { OPEN PrincOps, Rope;

PsbIndex: TYPE = PrincOps.PsbIndex;
Ticks: TYPE = PrincOps.Ticks;
spyState: PUBLIC SpyOps.SpyState _ off;
watching: PUBLIC SpyOps.DataType _ CPU;
justMe: PUBLIC PsbIndex _ 0;
freqDivisor: PUBLIC NAT _ 0;
runningTime: PUBLIC BasicTime.Pulses; -- total time running
pageFaults: PUBLIC CARD;
active, starts, stops: PUBLIC INTEGER _ 0;
wordsAllocated: PUBLIC CARD;
wordsReclaimed: PUBLIC CARD;

code: PUBLIC SpyOps.Count _ 0; -- page faults on code
data: PUBLIC SpyOps.Count _ 0; -- page faults on data
InitializeSpy: PUBLIC ENTRY PROC [dataType: SpyClient.DataType _ CPU, process: PsbIndex _ PrincOps.PsbNull, spyOnSpyLog: BOOL _ FALSE, frequencyDivisor: NAT _ 1]
RETURNS [errorMsg: ROPE] = {
DisableSpy[];
IF dataType IN [allocations..wordsAllocated] THEN errorMsg _ SpyOps.SetAllocationBreak[];
IF errorMsg # NIL THEN RETURN [errorMsg];
IF frequencyDivisor < 1 THEN RETURN ["0 is a stupid frequency divisor"];
InitializeTables[];
watching _ dataType;
justMe _ IF dataType = process THEN process ELSE 0;
freqDivisor _ frequencyDivisor;
allocWait _ allocDivisorMinusOne _ freqDivisor - 1;
SpyLog.OpenForWrite[spyOnSpyLog];
EnableSpy[];
};

InitializeTables: PROC = {
runningTime _ 0;
code _ data _ 0;
wordsAllocated _ wordsReclaimed _ 0;
};

Initialize: PROC = {
Loader.MakeProcedureResident[Spy];
Loader.MakeProcedureResident[Record];
Loader.MakeProcedureResident[UserBreak];
Loader.MakeProcedureResident[PageFaultRecorder];
Loader.MakeGlobalFrameResident[Initialize];
Process.InitializeCondition[@processDead, 10000];
SetTimeouts[];
};

SetTimeouts: PROC = {
ticks: Ticks;
cutoff: Ticks;
found: BOOL;
frame: PrincOps.FrameHandle;
IF IntervalTimerFace.exists THEN RETURN;
IF index = maxIndex THEN RETURN;
cutoff _ Process.SecondsToTicks[10];
ticks _ PrincOpsUtils.ReadPTC[];
FOR psbi: PsbIndex IN [PrincOps.StartPsb..PrincOps.StartPsb+PrincOps.PDA.count) DO
sample: CARDINAL _ PrincOps.PDA.block[psbi].mds;
IF sample = 0 THEN LOOP;
IF sample > cutoff + ticks THEN LOOP; -- not significant
IF PrincOps.PDA.block[psbi].link.vector
THEN frame _ PDA[PrincOps.PDA.block[psbi].context.state].frame
ELSE frame _ PrincOps.PDA.block[psbi].context.frame;
found _ FALSE;
FOR i: CARDINAL IN [0..index) DO
IF timeout[i] = [frame.accesslink, frame.pc] THEN {found _ TRUE; EXIT};
ENDLOOP;
IF found THEN LOOP;
timeout[index] _ [frame.accesslink, frame.pc];
index _ index + 1;
IF index = maxIndex THEN EXIT;
ENDLOOP;
};


processDead: CONDITION;
spyProcess: PROCESS _ NIL;
oldSpyState: SpyOps.SpyState _ off;

startTime: BasicTime.Pulses;
startPageFaults: CARD;
startWordsAllocated: CARD;
startWordsReclaimed: CARD;

StartCounting: PUBLIC ENTRY FastBreak.FastBreakProc = {
priority: Process.Priority;
starts _ starts + 1;
WHILE active = 0 AND spyProcess # NIL DO WAIT processDead; ENDLOOP; 
IF (active _ active + 1) > 1 THEN RETURN [useOldBreak: FALSE]; -- a psuedo start
startPageFaults _ VMStatistics.pageFaults;
startWordsAllocated _ SafeStorage.NWordsAllocated[];
startWordsReclaimed _ SafeStorage.NWordsReclaimed[];
startTime _ BasicTime.GetClockPulses[];
IF watching = breakProcess THEN justMe _ LOOPHOLE[Process.GetCurrent[]];
IF justMe # 0 THEN justMePrincOps _ @PrincOps.PDA[PrincOpsUtils.PsbIndexToHandle[justMe]];
SetTimeouts[]; -- do it a second time in case the first time missed some
priority _ Process.GetPriority[];
Process.SetPriority[Process.priorityRealTime];
SELECT watching FROM
CPU, process, breakProcess => Process.Detach[spyProcess _ FORK Spy[]]; 
pagefaults => Process.Detach[spyProcess _ FORK PageFaultRecorder[]];
allocations, wordsAllocated => spyState _ on;
ENDCASE => spyState _ on;
Process.SetPriority[priority];
RETURN [useOldBreak: FALSE];
};

StopCounting: PUBLIC ENTRY FastBreak.FastBreakProc = {
IF active = 0 THEN RETURN [useOldBreak: FALSE]; -- already stopped
stops _ stops + 1;
IF (active _  active - 1) > 0 THEN RETURN; -- a psuedo stop
spyState _ off;
runningTime _ runningTime + BasicTime.GetClockPulses[] - startTime;
pageFaults _ pageFaults + VMStatistics.pageFaults - startPageFaults;
wordsAllocated _ wordsAllocated + SafeStorage.NWordsAllocated[] - startWordsAllocated;
wordsReclaimed _ wordsReclaimed + SafeStorage.NWordsReclaimed[] - startWordsReclaimed;
RETURN [useOldBreak: FALSE];
};

DisableSpy: PROC = {
IF spyState = disabled THEN RETURN;
oldSpyState _ spyState; 
spyState _ disabled;
};

EnableSpy: PROC = {spyState _ oldSpyState};

justMePrincOps: LONG POINTER TO ProcessStateBlock _ NIL;
baseWait: REAL _ SELECT SystemVersion.machineType FROM
dorado => Process.TicksToMsec[1]*1.3e-4,
ENDCASE => (Process.TicksToMsec[1]-1)*2.0e-3;
priorityLimit: Process.Priority _ Process.priorityFaultHandlers;
monitor: BOOL _ FALSE; -- measure performance of spy
maxStackDepth: CARDINAL = 200;
timeout: ARRAY [0..maxIndex) OF RECORD [gfh: PrincOps.GlobalFrameHandle, pc: CARDINAL];
maxIndex: CARDINAL = 25;
index: CARDINAL _ 0;
sampleInterval: INT _ 10*1000; -- measured in microseconds
searchReadyList: BOOL _ TRUE;

Spy: PROC = {
top: PsbIndex;
frame: FrameHandle;
myPrincOps: PsbHandle = PrincOpsUtils.ReadPSB[];
handleMask: PsbLink = [
failed: FALSE, priority: 0, next: LAST[PsbIndex], reserved: 0, vector: FALSE];
waitSeconds: REAL = freqDivisor * baseWait;
NextHandle: PROC [link: CARDINAL] RETURNS [PsbHandle] = INLINE {
RETURN [LOOPHOLE[Basics.BITAND[link, LOOPHOLE[handleMask]]]];
};
spyState _ on;
DO
IntervalTimer.Wait[waitSeconds];
IF active <= 0 THEN EXIT;
IF spyState = disabled THEN LOOP;
IF monitor THEN SpyLog.Here[];
IF justMe = 0 OR searchReadyList THEN {
top _ PrincOps.PsbNull;
PrincOpsUtils.DisableInterrupts[];
{
once: BOOL _ FALSE;
tailOfReadyList: PsbHandle _ NextHandle[LOOPHOLE[PDA.ready]];
headOfReadyList: PsbHandle _ NextHandle[LOOPHOLE[PDA[tailOfReadyList].link]];
FOR current: PsbHandle _ headOfReadyList,
NextHandle[LOOPHOLE[PDA[current].link]] DO
psb: LONG POINTER TO ProcessStateBlock = @PDA[current];
link: PsbLink = psb.link;
level: Process.Priority = link.priority;
IF current = headOfReadyList THEN IF once THEN EXIT ELSE once _ TRUE;
IF level = 0 OR level > priorityLimit THEN LOOP;
IF current = myPrincOps THEN LOOP;
IF ~link.vector AND PDA.state[level] = NullStateVectorHandle THEN LOOP;
frame _ IF link.vector THEN PDA[psb.context.state].frame ELSE psb.context.frame;
{
FOR i: CARDINAL IN [0..maxIndex) DO
IF timeout[i] = [NIL, 0] THEN EXIT;
IF timeout[i] = [frame.accesslink, frame.pc] THEN GO TO skip;
ENDLOOP;
top _ PrincOpsUtils.PsbHandleToIndex[current];
EXIT;
EXITS skip => {};
};
ENDLOOP;
};
PrincOpsUtils.EnableInterrupts[];
};
SELECT TRUE FROM
justMe = 0 => Record[top, frame, ready];
justMePrincOps.link.failed => Record[justMe, NIL, waitingML]; -- waiting ML
justMePrincOps.flags.waiting => Record[justMe, NIL, waitingCV]; -- waiting CV
OnQueue[justMe, @PDA.fault[PrincOps.qPageFault].queue] => 
Record[justMe, NIL, pageFault]; -- waiting pagefault
OnQueue[justMe, @PDA.fault[PrincOps.qPageFault+4].queue] => 
Record[justMe, NIL, pageFault]; -- waiting pagefault
OnQueue[justMe, @PrincOps.PDA.ready] => 
SELECT TRUE FROM
PDA.state[justMePrincOps.link.priority] = NullStateVectorHandle
AND ~justMePrincOps.link.vector =>
Record[justMe, NIL, waitingSV];
searchReadyList AND justMe # top =>
Record[justMe, NIL, preempted];
ENDCASE =>
Record[justMe, NIL, ready]; -- ready
ENDCASE => Record[justMe, NIL, unknown]; -- in some unknown state
IF monitor THEN SpyLog.Here[];
ENDLOOP;
spyProcess _ NIL;
spyState _ off;
NotifyProcessDead[];
Process.SetPriority[Process.priorityNormal];    
};

OnQueue: PROC [psbi: PsbIndex, queueHandle: PrincOps.QueueHandle]
RETURNS [BOOL] = INLINE {
tail, prev: PsbIndex;
IF queueHandle^ = PrincOps.QueueEmpty THEN RETURN [FALSE];
prev _ tail _ queueHandle.tail;
THROUGH [FIRST[PsbIndex]..LAST[PsbIndex]+1] DO
next: PsbIndex = PrincOps.PDA.block[prev].link.next;
IF next = psbi THEN RETURN [TRUE];
prev _ next;
IF prev = tail THEN RETURN [FALSE];
ENDLOOP;
RETURN [FALSE] -- actually, the queue is thoroughly mangled! --
};
recordPageFaulted: BOOL _ FALSE;
Data: TYPE = RECORD[process: CARDINAL, page: INTEGER];
CodeBase: TYPE = LONG POINTER TO PACKED ARRAY [0..0) OF PrincOps.op;

PageFaultRecorder: PROC = {
fault: Data;
type: SpyClient.StackType;
codePage: INTEGER;
handle: PrincOps.PsbHandle;
frame: PrincOps.FrameHandle;
pda: PrincOps.PDABase = PrincOps.PDA;
qPageFault: PrincOps.FaultIndex = PrincOps.qPageFault;
pPageFaultCondition: LONG POINTER TO PrincOps.Condition = 
@pda.fault[qPageFault].condition;
pPageFaultCONDITION: LONG POINTER TO CONDITION =
LOOPHOLE[pPageFaultCondition];
recorderLock: MONITORLOCK;
shouldNotifyKernel: BOOL _ FALSE;
spyState _ on;
DO  
PrincOpsUtils.LongWait[@recorderLock, pPageFaultCONDITION, 1];
UNTIL PrincOpsUtils.LongReEnter[@recorderLock, pPageFaultCONDITION] DO ENDLOOP;
IF pda.fault[qPageFault].queue.tail = PrincOps.PsbNull THEN {
IF shouldNotifyKernel
AND pda.fault[qPageFault].condition.tail ~= PrincOps.PsbNull THEN {
LongNakedNotify[pPageFaultCONDITION];
shouldNotifyKernel _ FALSE;
};
IF active <= 0 THEN EXIT;
LOOP;  -- go back and wait again.
};
fault.process _ pda.block[pda.fault[qPageFault].queue.tail].link.next;
handle _ PrincOpsUtils.PsbIndexToHandle[fault.process];
fault.page _ VM.PageNumberForAddress[pda[pda[handle].context.state].memPointer];
frame _ IF pda[handle].link.vector 
THEN pda[pda[handle].context.state].frame 
ELSE pda[handle].context.frame;
codePage _ VM.PageNumberForAddress[frame.accesslink.code.longbase+frame.pc/2];
SELECT TRUE FROM
ABS[codePage - fault.page] <= 1 => {
code _ code + 1;
type _ pageFaultCode;
};
Xfer[frame.accesslink.code.longbase, frame.pc] => {
code _ code + 1;
type _ pageFaultXfer;
}; 
ENDCASE => {
data _ data + 1;
type _ pageFaultData;
};
PrincOpsUtils.DisableInterrupts[];
IF pPageFaultCondition^.tail = PrincOps.PsbNull 
THEN shouldNotifyKernel _ TRUE  -- not ready for this fault yet...
ELSE LongNakedNotify[pPageFaultCONDITION];
PrincOpsUtils.EnableInterrupts[];
IF active <= 0 THEN EXIT;
IF recordPageFaulted THEN SpyLog.WriteData[@fault, SIZE[Data], CODE[Data]];
Record[fault.process, NIL, type];
ENDLOOP;
spyProcess _ NIL;
spyState _ off;
NotifyProcessDead[];
Process.SetPriority[Process.priorityNormal];    
};

Xfer: PROC [base: CodeBase, pc: PrincOps.BytePC] RETURNS [BOOL] = INLINE {
IF base[pc] IN [PrincOps.zEFC0..PrincOps.zKFCB] THEN RETURN [TRUE];
RETURN [FALSE];
};

LongNakedNotify: PROC [pCondition: LONG POINTER TO CONDITION] = INLINE {
pCond: LONG POINTER TO PrincOps.Condition = LOOPHOLE[pCondition];
PrincOpsUtils.DisableInterrupts[];
IF pCond^.tail=PrincOps.PsbNull 
THEN {pCond^.wakeup _ TRUE; PrincOpsUtils.EnableInterrupts[]}
ELSE {PrincOpsUtils.EnableInterrupts[]; PrincOpsUtils.LongNotify[pCondition]};
};

NotifyProcessDead: ENTRY PROC = INLINE {NOTIFY processDead}; 
stack: SpyOps.Stack;
break: BOOL _ FALSE;
breakAtom: ATOM _ NIL;
allocDivisorMinusOne: CARDINAL _ 0;
allocWait: CARDINAL _ 0;

AllocationBreak: PUBLIC FastBreak.FastBreakProc = {
words: CARDINAL _ 1;
type: SpyOps.StackType _ allocSafe;
GetWordsFromStack: PROC = INLINE {
blockSize: INT = AllocatorOps.BlockSize[AllocatorOps.REFToHP[LOOPHOLE[@sv.stk[0], POINTER TO REF ANY]^]];
words _ MAX[MIN[blockSize, CARDINAL.LAST], 0];
};
IF active = 0 THEN RETURN;
IF watching NOT IN [allocations..wordsAllocated] THEN RETURN;
IF allocWait > 0 THEN {allocWait _ allocWait - 1; RETURN};
allocWait _ allocDivisorMinusOne;
SELECT data FROM
NIL => IF watching = wordsAllocated THEN GetWordsFromStack[];
LOOPHOLE[$Permanent, LONG POINTER] => {
type _ allocPerm;
IF watching = wordsAllocated THEN GetWordsFromStack[];
};
LOOPHOLE[$Unsafe, LONG POINTER] => {
type _ allocUnsafe;
IF watching = wordsAllocated THEN GetWordsFromStack[];
};
ENDCASE => NULL;
IF break AND data = LOOPHOLE[breakAtom, LONG POINTER] THEN
DebuggerSwap.CallDebugger["Allocation break"L];
Record[psbi: LOOPHOLE[Process.GetCurrent[]], type: type, frame: frame, count: words];
};

UserBreak: PUBLIC FastBreak.FastBreakProc = TRUSTED {
count: CARDINAL _ 1;
type: SpyOps.StackType _ userBreak;
IF spyState # on THEN RETURN [useOldBreak: FALSE];
IF watching # userDefined THEN RETURN [useOldBreak: FALSE];
IF data # NIL THEN type _ LOOPHOLE[data, LONG POINTER TO SpyOps.StackType]^;
Record[LOOPHOLE[Process.GetCurrent[]], frame, type, count];
RETURN [useOldBreak: FALSE];
};

Record: PUBLIC PROC
[psbi: PsbIndex, frame: FrameHandle, type: SpyOps.StackType, count: CARDINAL _ 1] = {
recordInner: ENTRY PROC = {
level: Process.Priority;
psb: LONG POINTER TO ProcessStateBlock;
IF spyState = disabled OR active <= 0 THEN RETURN;
IF psbi = PrincOps.PsbNull THEN {
IF PDA.fault[qPageFault].queue.tail = PrincOps.PsbNull
AND PDA.fault[qPageFault+4].queue.tail = PrincOps.PsbNull
THEN LogStack[psbi, 0, NIL, count, ready]
ELSE LogStack[psbi, 0, NIL, count, pageFault]; -- waiting for a page fault
RETURN;
};
psb _ @PDA[PrincOpsUtils.PsbIndexToHandle[psbi]];
level _ psb.link.priority;
IF frame = NIL THEN 
frame _ IF psb.link.vector THEN PDA[psb.context.state].frame ELSE psb.context.frame;
LogStack[psbi, level, frame, count, type];
};
writeProcess: PROCESS;
extendProcess: PROCESS;
[writeProcess, extendProcess] _ SpyLog.InvisibleProcesses[];
IF (writeProcess # NIL AND LOOPHOLE[writeProcess, PsbIndex] = psbi)
OR (extendProcess # NIL AND LOOPHOLE[extendProcess, PsbIndex] = psbi) THEN RETURN;
recordInner[];
};

LogStack: INTERNAL PROC [process: PsbIndex, level: Process.Priority, frame: FrameHandle, count: CARDINAL, type: SpyClient.StackType] = {
sdLength: CARDINAL = PrincOps.SD[PrincOps.sGFTLength];
gf: GlobalFrameHandle _ NIL;
length: CARDINAL _ 0;
ValidFrame: PROC [f: ControlLink] RETURNS [FrameHandle] = {
OPEN PrincOps;
IF f.proc OR f.indirect OR f.frame = NIL OR (gf _ f.frame.accesslink) = NIL OR
(LOOPHOLE[gf, CARDINAL] MOD 4) # 0 THEN RETURN [NIL];
RETURN [f.frame]
};
IF ~SpyLog.active THEN RETURN;
stack.type _ type;
stack.count _ count;
stack.level _ level;
stack.process _ process;
frame _ ValidFrame[LOOPHOLE[frame] ! VM.AddressFault => {frame _ NIL; CONTINUE}];
THROUGH [0..maxStackDepth) UNTIL frame = NIL DO
IF length >= SpyOps.stackLength THEN {stack.level _ 7; length _ 0; EXIT};
stack.frame[length] _ [gf, frame.pc];
IF length > 0 AND stack.frame[length] = stack.frame[length-1] 
THEN length _ length - 1; -- skip recursive frames
length _ length + 1;
frame _ ValidFrame[frame.returnlink ! VM.AddressFault => EXIT];
ENDLOOP;
SpyLog.WriteData[@stack,
SpyOps.stackHeader + length*SpyOps.Frame.SIZE, 
SpyOps.Stack.CODE];
};

Initialize[];

}.

4SpyKernelImpl.mesa
Copyright Σ 1984, 1985, 1986, 1987 by Xerox Corporation.  All rights reserved.
Maxwell	September 16, 1983 3:44 pm
Bob Hagmann	February 6, 1986 8:53:31 am PST
Russ Atkinson (RRA) February 19, 1987 11:49:14 am PST
Mike Spreitzer September 24, 1986 12:04:35 pm PDT
Last tweaked by Mike Spreitzer on August 5, 1987 1:07:37 pm PDT
SpyKernel parameters
General statistics
Initializing the Spy and data
PrincOpsUtils.DisableInterrupts[]; -- stops the clock. NO PAGE FAULTS ALLOWED!
PrincOpsUtils.EnableInterrupts[];
Starting and stopping the Spy
Note:  These procedures need not be resident.
Watching CPU    
All code invoked by this process should be resident
sometimes the user gets the machine gets into a state where searching the ready list is a bad idea.  This boolean allows the user to stop the Spy from searching the ready list.
MAIN LOOP
Search the ready list for a good candidate
want the SECOND psb.
Don't count the idle process or anything above the limit
no SV, so not really running
skip over a process that appears in the ready queue because it just timed out.
(The Spy wakes up with all of the other timeouts.  Since it is the highest priority, it will run first.  All of the other timeouts will appear on the ready list.  Most likely, they will just check some condition and then go back to sleep.  This will mask the more interesting processes.)
we have a good process!
waiting SV
prempted by a higher priority process 
garbage protection
Watching pagefaults    
stolen from Ben.mesa
NO PAGE FAULTS ALLOWED!
wait for a page fault:
timed out
figure out who faulted:
walk to tail, then to head.
wake up the Pilot fault handler:
log the fault:
is the current pc pointing to some sort of xfer?
Used ONLY to notify a condition from a high priority process outside the relevant monitor.
Recording the information
data: FastBreakData, frame: PrincOps.FrameHandle, sv: PrincOps.SVPointer
This break is taken at exit from AllocatorImpl.NewSystemObject, at which time the new REF is the only thing on the stack; so we read it, and get the actual size from the header.
Log the stack on the Trace Log --
This procedure is supposed to validate a control link.  For various race conditions (presumably), we have observed address faults when the accesslink gets clobbered.  Since we can't handle the address faults in here, we insist that the caller be prepared for such an eventuality. (RRA)
Note: as a side-effect, this procedure sets 'gf', which is used by the other local procedures below and the main loop of IncrementBucket.
save the current frame
this also saves the last ignored frame

22-Jan-82 Maxwell: Removed cross-partition code; converted to Cedar
4-Feb-82 Maxwell: Added stack active option
11-Mar-82 Maxwell: Added page fault recorder
October 14, 1982 10:07 am Maxwell: Removed Pilot Spy code
Bob Hagmann February 6, 1986 8:34:24 am PST
SetTimeouts can be invoked twice.  If the index is alread at maxIndex, it tries to store past the end of the timeout array.  Moved maxIndex up to 25 from 20
changes to: SetTimeouts
Bob Hagmann October 24, 1986 11:29:24 am PDT
added calls to WriteProcess to avoid deadlock
Last tweaked by Mike Spreitzer on August 5, 1987 1:05:50 pm PDT
Computation of baseWait in non-Dorado case was absurd --- it gave ~100 seconds on a DLion!  Guessed "e-3" was missing, and so divided by 1000.
changes to: baseWait
 

Κˆ˜
codeš
œ™Kš
œN™NK–1.5 in tabStopsš
œ"™"K–1.5 in tabStops™+K™5K™1K™?—˜š
Οk	˜	Kšœ
œ˜(Kšœœœ˜Kšœ
œ˜)Kšœ
œ˜"Kšœ
œ˜ Kšœœ˜Kšœœ
˜!Kš
œ	˜	Kšœœ€
˜“
Kšœœ₯
˜²
Kšœœœ˜Kšœœ$˜5Kšœœ2˜>Kšœ
œ˜&Kšœœ=˜IKšœœd˜pKšœœ˜"Kšœ
œ&˜.Kšœ
œ˜ ——
head2šœ˜Kšœž
œ˜΅
Kšœ˜Kšœœ˜K˜Kšœ
œ˜#Kšœœ˜—š
œ™Kšœ
œ˜'Kšœ
œœ
˜'Kšœœ˜Kšœ
œ
œ˜—š
œ™Kšœ
œΟc˜;Kšœœ
œ
˜Kšœœ
œ˜*Kšœœ
œ
˜Kšœœ
œ
˜K˜Kšœœž˜5Kšœœž˜5—š
œ™šΟn
œœ
œ
œ!œ5œœœ	œœ˜Ύ
K˜
Kšœ
œœ(˜YKšœœ
œ
œ˜)Kšœœ
œ%˜HK˜K˜Kšœ	œœ	œ˜3Kš
œ˜Kš
œ3˜3Kš
œ!˜!K˜Kš
œ˜—K˜šŸœœ˜K˜K˜K˜$Kš
œ˜K˜—šŸ
œœ˜K˜"Kš
œ%˜%Kš
œ(˜(Kš
œ0˜0K˜+K˜1K˜Kš
œ˜K˜—šŸœœ˜Kš
œ
˜
Kš
œ˜Kšœœ
˜K˜Kšœœ
œ
˜(Kšœœ
œ
˜ K˜$Kšœ#ž+™NKš
œ ˜ šœœ0œ˜RKšœœœ˜0Kšœœ
œ
˜Kšœœ
œž˜8šœ
œ˜'Kšœ	œ
œ!˜>Kšœœ˜4—Kšœœ
˜šœœ
œ˜ Kšœ+œ
œœ˜GKšœ
˜—Kšœœ
œ
˜K˜.K˜Kšœœ
œ
˜Kšœ
˜—Kš
œ!™!Kš
œ˜—K˜—š
œ™Kš
œ-™-K˜Kšœ
	œ
˜Kšœœœ
˜K˜#K˜K˜Kšœœ
˜Kšœœ
˜Kšœœ
˜K˜šΟb
œœ
œ˜7K˜K˜Kšœœœ
œ
œœ˜DKš	œœ
œœž˜PKš
œ*˜*K˜4K˜4K˜'Kšœœ
œ˜HKšœœœ)˜ZKšœž9˜HK˜!Kš
œ.˜.šœ
˜Kšœ7œ	˜GKšœ*œ˜DK˜-Kšœ˜—K˜Kšœœ˜Kš
œ˜K˜—š œœ
œ˜6Kš	œœ
œœž˜BK˜Kšœœ
œž˜;Kš
œ˜Kš
œC˜CKš
œD˜DK˜VK˜VKšœœ˜Kš
œ˜K˜—šŸ
œœ˜Kšœœ
œ
˜#K˜K˜Kš
œ˜K˜—KšŸ	œœ˜+—š
œ™š
œ3™3K˜Kš	œœ
œ
œœ
˜8šœ
œœ˜6Kš
œ(˜(Kšœ&˜-—Kš
œ@˜@Kšœ	œœž˜4Kšœœ˜Kš	œ	œœ
œ'œ˜WKšœ
œ˜Kšœ	œ˜Kšœœž˜:šœœœ
˜Kš
ϡ
™°
—K˜—šŸœœ˜
K˜K˜K˜0š
œ˜Kšœœœ!œ˜N—Kšœ
œ˜+š
Ÿ
œœœœœ˜@Kšœœœœ˜=Kš
œ˜—K˜Kš
œ	™	š
˜Kš
œ ˜ Kšœ
œ
œ
˜Kšœœ
œ
˜!Kšœ	œ˜šœœœ˜'K™*Kš
œ˜Kš
 "˜"˜
Kšœœœ
˜Kšœ(œ
œ	˜=šœ(œ
œ˜MKšœ	œ™—šœ2œ
œ˜TKš	œœ
œ
œœ
˜7K˜K˜(Kšœœ
œœ
œ
œœ
˜Ešœœœ
œ
˜0K™8—Kšœœ
œ
˜"š
œœ
œ&œ
œ
˜GKšœœ™—Kš	œœ
œ
œœ˜P˜
š
œN™NKš
œŸ™Ÿ—šœœ
œ˜#Kšœœœ
œ
˜#Kšœ+œ
œ
œ˜=Kšœ
˜—Kš
œ™Kš
œ.˜.Kšœ
˜Kšœ˜K˜—Kšœ
˜—K˜—Kš
 !˜!K˜—šœ
œ
˜K˜(Kšœ-œž
˜KKšœ/œž
˜Mšœœ&˜:Kšœœž˜4—šœœ(˜<Kšœœž˜4—šœœ˜(šœ
œ
˜šœ=œ˜bKšœ™
Kšœœ
˜—šœœ˜#Kš
œ&™&Kšœœ
˜—šœ˜
Kšœœ
ž˜$———Kšœœž˜A—Kšœ	œ˜Kšœ
˜—Kšœ
œ
˜K˜K˜K˜0Kš
œ˜K˜—š
Ÿœœ4œœœ˜[K˜Kšœ$œ
œœ˜:K˜šœœœ˜.Kš
œ™Kšœœ˜4Kšœ
œ
œœ˜"K˜Kšœ
œ
œœ˜#Kšœ
˜—Kšœœž0˜?Kš
œ˜——š
œ™Kšœœœ
˜ Kš	œœœ
œœ˜6Kšœ
œœ
œ
œ
œ
œœ
˜DK˜šŸœœ˜Kš
œ™K˜Kš
œ˜Kšœ
œ
˜Kš
œ˜K˜Kšœ!œ
˜%Kš
œ6˜6šœœ
œ
œ˜:K˜!—š	œœ
œ
œ
	œ˜0Kšœ˜—Kšœœ
˜Kšœœœ
˜!Kš
œ™K˜šœ˜Kš
œ™Kš
œ>˜>Kšœ?œ
œ
˜Ošœ5œ˜=Kš
œ	™	šœœ:œ˜YK˜%Kšœœ
˜Kš
œ˜—Kšœ
œ
œ
˜Kšœž˜!Kš
œ˜—Kš
œ™š
œF˜FKš
œ™—K˜7Kšœ
œA˜Pšœœ˜#Kšœ&˜*Kšœ˜—KšœœA˜Nšœ
œ
˜šœ!˜$Kš
œ˜Kš
œ˜Kš
œ˜—˜3K˜K˜K˜—šœ˜Kš
œ˜Kš
œ˜Kš
œ˜——Kš
œ ™ Kš
 "˜"šœ.˜0Kšœœž"˜BKšœ&˜*—Kš
 !˜!Kš
œ™Kšœ
œ
œ
˜Kšœœœœ˜KKšœœ˜!Kšœ
˜—Kšœ
œ
˜K˜K˜K˜0Kš
œ˜K˜—š
Ÿœœ'œœœ˜JKš
œ0™0Kš
œ
œ"œ
œœ˜CKšœœ˜Kš
œ˜K˜—šŸœœœ
œ
œ
	œœ˜HKš
œZ™ZKš	œœ
œ
œœ
˜AKš
 "˜"šœ˜ Kšœœ  œ
˜=Kšœ !œ'˜N—š
œ˜K˜——Kš
Ÿœœ
œœœ˜=—š
œ™K˜Kšœœœ
˜Kšœœœ
˜Kšœœ˜#Kšœœ˜K˜š œœ˜3Kš
œH™HKšœœ˜Kš
œ#˜#šŸœœœ˜"Kš
œœ/œ
œ
œ
œ
œ˜iKš	œœ
œœ
œ˜.K˜—Kšœœ
œ
˜Kš
œ
œ
œœ
œ
˜=Kšœœœ˜:Kš
œ!˜!šœ˜šœœœ˜=KšœVœX™±
—šœ
œ
œ˜'Kš
œ˜Kšœœ˜6Kš
œ˜—šœ
œ
œ˜$Kš
œ˜Kšœœ˜6Kš
œ˜—Kšœœ
˜—šœœœœ
œ˜:Kš
œ/˜/—Kšœ
œ@˜UKš
œ˜K˜—š 	œœœ˜5Kšœœ˜Kš
œ#˜#Kšœœ
œœ˜2Kšœœ
œœ˜;Kšœœ
œœœ
œ
œ˜LKšœœ,˜;Kšœœ˜Kš
œ˜K˜—šŸœœ
œEœ	˜išœ
œ
œ˜K˜Kšœœ
œ
œ˜'Kšœœ
œ
œ
˜2šœœ˜!šœ
œ1œ
œ2˜pKšœœ˜)Kšœœž˜J—Kšœ
˜Kš
œ˜—Kšœœ'˜1K˜šœ	œ
œ
˜Kš	œœœ
œœ˜T—K˜*K˜—Kšœœ
˜Kšœœ
˜Kš
œ<˜<Kšœœ
œ
œ!œœ
œ
œ"œ
œ
˜–
K˜K˜K˜—šŸœœ
œIœ ˜ˆ
Kšœž™!Kšœ
œœ˜6Kšœœ
˜Kšœœ˜šŸ
œœœ˜;Kšœ™œ
™Kšœ
˜Kš
œ‰
™‰
š
œœœœ
œœ
˜NKš
œ
œœœœ
œœ˜5—Kšœ
˜Kš
œ˜—Kšœœ
œ
˜K˜K˜K˜K˜Kš	œœ
œœœ˜Qšœœ	œ
˜/Kš
œ™Kš
œ&™&Kšœœœ˜IK˜%šœœ-˜>Kšœž˜2—K˜Kšœ&œœ˜?Kšœ
˜—š
œ˜Kšœ)œ˜/Kšœ
œ˜—Kš
œ˜—K˜K˜
K˜—Kš
œ˜K™Kš
œC™CKš
œ+™+Kš
œ,™,Kš
œ9™9™+KšΟrœ‘
™œ
Kšœ‘™—š
œ,™,Kš‘œ‘™-—™?Kš
œŽ
™Ž
Kšœ‘	œ
‘
™—K™—…—=v_2