[Cyan]<CedarChest7.0>Spy>SpyKernelImpl.mesa!4

SpyKernelImpl.mesa

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

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;

SpyKernel parameters

spyState: PUBLIC SpyOps.SpyState ← off;

watching: PUBLIC SpyOps.DataType ← CPU;

justMe: PUBLIC PsbIndex ← 0;

freqDivisor: PUBLIC NAT ← 0;

General statistics

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

Initializing the Spy and 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];

PrincOpsUtils.DisableInterrupts[]; -- stops the clock. NO PAGE FAULTS ALLOWED!

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;

PrincOpsUtils.EnableInterrupts[];

};

Starting and stopping the Spy

Note: These procedures need not be resident.

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};

Watching CPU

All code invoked by this process should be resident

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;

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.

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;

MAIN LOOP

IntervalTimer.Wait[waitSeconds];

IF active <= 0 THEN EXIT;

IF spyState = disabled THEN LOOP;

IF monitor THEN SpyLog.Here[];

IF justMe = 0 OR searchReadyList THEN {

Search the ready list for a good candidate

top ← PrincOps.PsbNull;

PrincOpsUtils.DisableInterrupts[];

{

once: BOOL ← FALSE;

tailOfReadyList: PsbHandle ← NextHandle[LOOPHOLE[PDA.ready]];

headOfReadyList: PsbHandle ← NextHandle[LOOPHOLE[PDA[tailOfReadyList].link]];

want the SECOND psb.

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;

Don't count the idle process or anything above the limit

IF current = myPrincOps THEN LOOP;

IF ~link.vector AND PDA.state[level] = NullStateVectorHandle THEN LOOP;

no SV, so not really running

frame ← IF link.vector THEN PDA[psb.context.state].frame ELSE psb.context.frame;

{

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.)

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;

we have a good process!

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 =>

waiting SV

Record[justMe, NIL, waitingSV];

searchReadyList AND justMe # top =>

prempted by a higher priority process

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

garbage protection

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! --

};

Watching pagefaults

recordPageFaulted: BOOL ← FALSE;

Data: TYPE = RECORD[process: CARDINAL, page: INTEGER];

CodeBase: TYPE = LONG POINTER TO PACKED ARRAY [0..0) OF PrincOps.op;

PageFaultRecorder: PROC = {

stolen from Ben.mesa

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;

NO PAGE FAULTS ALLOWED!

spyState ← on;

wait for a page fault:

PrincOpsUtils.LongWait[@recorderLock, pPageFaultCONDITION, 1];

UNTIL PrincOpsUtils.LongReEnter[@recorderLock, pPageFaultCONDITION] DO ENDLOOP;

IF pda.fault[qPageFault].queue.tail = PrincOps.PsbNull THEN {

timed out

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.

};

figure out who faulted:

fault.process ← pda.block[pda.fault[qPageFault].queue.tail].link.next;

walk to tail, then to head.

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;

};

wake up the Pilot fault handler:

PrincOpsUtils.DisableInterrupts[];

IF pPageFaultCondition^.tail = PrincOps.PsbNull

THEN shouldNotifyKernel ← TRUE -- not ready for this fault yet...

ELSE LongNakedNotify[pPageFaultCONDITION];

PrincOpsUtils.EnableInterrupts[];

log the fault:

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 {

is the current pc pointing to some sort of xfer?

IF base[pc] IN [PrincOps.zEFC0..PrincOps.zKFCB] THEN RETURN [TRUE];

RETURN [FALSE];

};

LongNakedNotify: PROC [pCondition: LONG POINTER TO CONDITION] = INLINE {

Used ONLY to notify a condition from a high priority process outside the relevant monitor.

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};

Recording the information

stack: SpyOps.Stack;

break: BOOL ← FALSE;

breakAtom: ATOM ← NIL;

allocDivisorMinusOne: CARDINAL ← 0;

allocWait: CARDINAL ← 0;

AllocationBreak: PUBLIC FastBreak.FastBreakProc = {

data: FastBreakData, frame: PrincOps.FrameHandle, sv: PrincOps.SVPointer

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[];

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.

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] = {

Log the stack on the Trace Log --

sdLength: CARDINAL = PrincOps.SD[PrincOps.sGFTLength];

gf: GlobalFrameHandle ← NIL;

length: CARDINAL ← 0;

ValidFrame: PROC [f: ControlLink] RETURNS [FrameHandle] = {

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)

OPEN PrincOps;

Note: as a side-effect, this procedure sets 'gf', which is used by the other local procedures below and the main loop of IncrementBucket.

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

save the current frame

this also saves the last ignored frame

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[];

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