DIRECTORY
BootStartList USING [
EntryPointer, Enumerate, IndexToEntryPointer, IndexToSpaceEntryPointer, Proc],
DebuggerSwap USING [CallDebugger, WorryCallDebugger],
GermSwap USING [switches],
MPCodes USING [vmInitialized],
PrincOps USING [
AV, AVItem, FaultIndex, FrameHandle, LargeReturnSlot, NoTimeout, PDA, PsbHandle, PsbNull, qFrameFault, qPageFault, qWriteProtectFault, Queue, QueueEmpty, StateVector],
PrincOpsUtils USING
[DisableInterrupts, EnableInterrupts, FrameSize, Free, GetReturnFrame, LongEnter, LongExit, LongReEnter, LongWait, LowHalf, MyLocalFrame, PsbIndexToHandle, Requeue, SetReturnFrame],
Process USING [
Detach, DisableTimeout, priorityFaultHandlers, SecondsToTicks, SetPriority, SetTimeout, Ticks, Yield],
ProcessorFace USING [SetMP],
VM USING [
AddressFault, AddressForPageNumber, Free, Interval, PageCount, PageNumber, PageNumberForAddress, PagesForWords, SwapIn, WordsForPages, WriteProtectFault],
VMInternal USING [
AllocateRealMemoryForLocalFrames, AllocateVirtualMemoryInternal, allocationLock, AllocationOutcome, AnyFrameSizeIndex, FrameHeapPiece, FrameHeapPieceHeader, FsiFrame, LargeFrame, LargeFrameHeader, largeFrameThresholdFsi, NormalFrameSizeIndex],
VMStatistics USING [];

VMFaultsImpl: MONITOR LOCKS monitor^ USING monitor: POINTER TO MONITORLOCK
IMPORTS BootStartList, DebuggerSwap, GermSwap, PrincOpsUtils, Process, ProcessorFace, VM, VMInternal
EXPORTS VMInternal, VMStatistics =

BEGIN

OPEN PrincOps;


largeFramesLock: MONITORLOCK;

largeFramesInUse: CONDITION;
largeFrameTimeout: Process.Ticks = Process.SecondsToTicks[1];

pageFaults, writeFaults: PUBLIC INT _ 0;
frameFaults: PUBLIC INT _ 0;
smallFramesAllocated, frameHeapExtensions: PUBLIC INT _ 0;
largeFramesAllocated, largeFramesFreed: PUBLIC INT _ 0;

frameHeapPieceList: PUBLIC VMInternal.FrameHeapPiece _ NIL;
largeFrameList: PUBLIC VMInternal.LargeFrame _ NIL;  -- protected by largeFramesLock

PageFaultProcess: PROC = {
Process.SetPriority[Process.priorityFaultHandlers];
DO
process: PsbHandle = WaitForFaultee[qPageFault];
interval: VM.Interval =
MapAddressToContainingInterval[PDA[PDA[process].context.state].memPointer];
VM.SwapIn[interval: interval, nextPage: GetNextPageHint[process]
! VM.AddressFault => {ReportFault[process, VM.AddressFault]; CONTINUE}];
RestartFaultee[qPageFault, process];
--*stats*-- pageFaults _ pageFaults.SUCC;
ENDLOOP;
};

WriteProtectFaultProcess: PROC = {
Process.SetPriority[Process.priorityFaultHandlers];
DO
process: PsbHandle = WaitForFaultee[qWriteProtectFault];
ReportFault[process, VM.WriteProtectFault];
RestartFaultee[qWriteProtectFault, process];
--*stats*-- writeFaults _ writeFaults.SUCC;
ENDLOOP;
};

frameAllocs: ARRAY VMInternal.NormalFrameSizeIndex OF INT _ ALL[0];  -- **temporary**

FrameFaultProcess: PROC = {
OPEN VMInternal;
Process.SetPriority[Process.priorityFaultHandlers];
DO
process: PsbHandle = WaitForFaultee[qFrameFault];
fsi: NormalFrameSizeIndex = PDA[PDA[process].context.state].fsi;
frSize: CARDINAL = PrincOpsUtils.FrameSize[fsi] + AnyFrameSizeIndex.SIZE;
newFrame: FrameHandle;  -- the frame we will allocate and paste into the AV.
IF fsi >= largeFrameThresholdFsi THEN {
pages: CARDINAL = VM.PagesForWords[frSize + LargeFrameHeader.SIZE];
largeFrame: LargeFrame = PageNumberToMDSAddress[AllocateForLocalFrames[pages].page];
largeFrame^ _ [next: NIL, prev: NIL, trueFsi: fsi, fsiFrame: NULL];
NotifyLargeFrame[largeFrame];
largeFrame.fsiFrame[0].fsi _ LargeReturnSlot;  -- (a fsi never generated by the compiler.)
newFrame _ @largeFrame.fsiFrame[0].frame;
--*stats*-- largeFramesAllocated _ largeFramesAllocated.SUCC;
}
ELSE {
piece: FrameHeapPiece _ frameHeapPieceList;
newFsiFrame: POINTER TO FsiFrame;  -- assert:  newFsiFrame MOD 4  = 3
IF piece ~= NIL AND piece.wordsInUse + frSize > piece.wordsAllocated THEN {
framePiecePages: VM.PageCount =
VM.PagesForWords[frSize + FrameHeapPieceHeader.SIZE];
framePieceWords: CARDINAL = VM.WordsForPages[framePiecePages];
minFrameSize: CARDINAL = PrincOpsUtils.FrameSize[0] + AnyFrameSizeIndex.SIZE;
wordsAvailable: CARDINAL;
trialFsi: NormalFrameSizeIndex _ fsi;
newFsiFrame _ @piece.fsiFrame[0] + piece.wordsInUse - FrameHeapPieceHeader.SIZE;
UNTIL (wordsAvailable _ piece.wordsAllocated - piece.wordsInUse) < minFrameSize DO
tFsiWords: CARDINAL =
PrincOpsUtils.FrameSize[trialFsi _ trialFsi.PRED] + AnyFrameSizeIndex.SIZE;
UNTIL wordsAvailable < tFsiWords DO
newFsiFrame.fsi _ trialFsi;
PrincOpsUtils.Free[@newFsiFrame.frame];  -- atomically paste onto frame heap.
newFsiFrame _ newFsiFrame + tFsiWords;
piece.wordsInUse _ piece.wordsInUse + tFsiWords;
wordsAvailable _ wordsAvailable - tFsiWords;
ENDLOOP;
ENDLOOP;
piece _ PageNumberToMDSAddress[AllocateForLocalFrames[framePiecePages].page];
piece^ _ [
next: frameHeapPieceList,
wordsAllocated: framePieceWords,
wordsInUse: FrameHeapPieceHeader.SIZE,
fsiFrame: NULL
];
frameHeapPieceList _ piece;
--*stats*-- frameHeapExtensions _ frameHeapExtensions.SUCC;
};
newFsiFrame _ @piece.fsiFrame[0] + piece.wordsInUse - FrameHeapPieceHeader.SIZE;
newFsiFrame.fsi _ fsi;
newFrame _ @newFsiFrame.frame;
piece.wordsInUse _ piece.wordsInUse + frSize;
--*stats*-- smallFramesAllocated _ smallFramesAllocated.SUCC;
};
PrincOpsUtils.DisableInterrupts[];
LOOPHOLE[newFrame, POINTER TO AVItem]^.link _ AV[fsi].link;
AV[fsi].frame _ newFrame;
--*temporary stats*-- frameAllocs[fsi] _ frameAllocs[fsi].SUCC;
PrincOpsUtils.EnableInterrupts[];
RestartFaultee[qFrameFault, process];
--*stats*-- frameFaults _ frameFaults.SUCC;
ENDLOOP;
};
FlushLargeFramesProcess: PROC = {
Process.SetPriority[Process.priorityFaultHandlers];
DO
largeFrame: VMInternal.LargeFrame = WaitForLargeFrame[];
VM.Free[
[page: VM.PageNumberForAddress[largeFrame],
count: VM.PagesForWords[PrincOpsUtils.FrameSize[largeFrame.trueFsi]]]];
--*stats*-- largeFramesFreed _ largeFramesFreed.SUCC;
ENDLOOP;
};

MapAddressToContainingInterval: PROC [address: LONG POINTER] RETURNS [VM.Interval] =
INLINE {RETURN[[page: VM.PageNumberForAddress[address], count: 1]]};

GetNextPageHint: PROC [process: PsbHandle] RETURNS [VM.PageNumber] = INLINE {
nextProcess: PsbHandle = PrincOpsUtils.PsbIndexToHandle[PDA[process].link.next];
RETURN[
IF nextProcess = process THEN 0
ELSE VM.PageNumberForAddress[PDA[PDA[nextProcess].context.state].memPointer]]
};

ReportFault: PROC [psb: PsbHandle, error: ERROR [LONG POINTER]] = {
Return: PROC _ LOOPHOLE[PrincOpsUtils.GetReturnFrame[]];
state: StateVector = PDA[PDA[psb].context.state];
address: LONG POINTER = state.memPointer;  -- for easy inspection from the debugger.
PDA[PDA[psb].context.state].stkptr _ PDA[PDA[psb].context.state].instbyte _ 0;
PrincOpsUtils.SetReturnFrame[state.frame];
PDA[PDA[psb].context.state].frame _ LOOPHOLE[PrincOpsUtils.MyLocalFrame[]];
Return[];
IF PDA[psb].flags.cleanup ~= PsbNull THEN
DebuggerSwap.WorryCallDebugger["Address fault with dirty cleanup link (see a wizard)"L];
ERROR error[state.memPointer];
};

WaitForFaultee: PROC [q: FaultIndex] RETURNS [psb: PsbHandle] = INLINE {
lock: MONITORLOCK;
pCondition: LONG POINTER TO CONDITION = LOOPHOLE[@PDA.fault[q].condition];
--Temp kludge to allow Laundry to get in: -- Process.Yield[]; -- (ADB)
UNTIL PrincOpsUtils.LongEnter[@lock] DO ENDLOOP;
WHILE PDA.fault[q].queue = QueueEmpty DO
PrincOpsUtils.LongWait[@lock, pCondition, NoTimeout];
UNTIL PrincOpsUtils.LongReEnter[@lock, pCondition] DO ENDLOOP;
ENDLOOP;
psb _ PrincOpsUtils.PsbIndexToHandle[PDA.block[PDA.fault[q].queue.tail].link.next];
PrincOpsUtils.LongExit[@lock];
};
RestartFaultee: PROC [q: FaultIndex, psb: PsbHandle] = INLINE {
PrincOpsUtils.Requeue[@PDA.fault[q].queue, @PDA.ready, psb];
};
WaitForLargeFrame: PROC RETURNS [largeFrame: VMInternal.LargeFrame] = INLINE {
WaitForLargeFrameEntry: ENTRY PROC [monitor: POINTER TO MONITORLOCK] = INLINE {
OPEN VMInternal;
DO
IF AV[LargeReturnSlot].tag = frame THEN EXIT;
IF largeFrameList = NIL THEN Process.DisableTimeout[@largeFramesInUse]
ELSE Process.SetTimeout[@largeFramesInUse, largeFrameTimeout];
WAIT largeFramesInUse;
ENDLOOP;
PrincOpsUtils.DisableInterrupts[];  -- prevent AV manipulation
largeFrame _ LOOPHOLE[
AV[LargeReturnSlot].frame - LargeFrameHeader.SIZE - AnyFrameSizeIndex.SIZE];
AV[LargeReturnSlot].link _ AV[LargeReturnSlot].link^.link;
PrincOpsUtils.EnableInterrupts[];  -- AV is now consistent
IF largeFrame = largeFrameList THEN
IF (largeFrameList _ largeFrame.next) ~= NIL THEN largeFrameList.prev _ NIL ELSE NULL
ELSE
IF (largeFrame.prev.next _ largeFrame.next) ~= NIL THEN
largeFrame.next.prev _ largeFrame.prev;
};
WaitForLargeFrameEntry[@largeFramesLock];
};

NotifyLargeFrame: PROC [largeFrame: VMInternal.LargeFrame] = INLINE {
NotifyLargeFrameEntry: ENTRY PROC [monitor: POINTER TO MONITORLOCK] = INLINE {
largeFrame.next _ largeFrameList;
IF largeFrameList ~= NIL THEN largeFrameList.prev _ largeFrame;
largeFrameList _ largeFrame;
Process.SetTimeout[@largeFramesInUse, largeFrameTimeout];  -- OK because it's INLINE
NOTIFY largeFramesInUse;
};
NotifyLargeFrameEntry[@largeFramesLock];
};
AllocateForLocalFrames: PROC [count: VM.PageCount]
RETURNS [interval: VM.Interval] = INLINE {
outcome: VMInternal.AllocationOutcome;
AllocateForLocalFramesEntry: ENTRY PROC [monitor: POINTER TO MONITORLOCK] = INLINE {
[outcome, interval] _ VMInternal.AllocateVirtualMemoryInternal[count, $mds];
};
AllocateForLocalFramesEntry[@VMInternal.allocationLock];
IF outcome ~= ok THEN DebuggerSwap.WorryCallDebugger["No VM for frame heap"L];
FOR page: VM.PageNumber IN [interval.page..interval.page+interval.count) DO
VMInternal.AllocateRealMemoryForLocalFrames[page];
ENDLOOP;
};

PageNumberToMDSAddress: PROC [page: VM.PageNumber] RETURNS [address: POINTER] = INLINE {
RETURN[PrincOpsUtils.LowHalf[VM.AddressForPageNumber[page]]]
};


Initialize: PROC = {
myFramePage: VM.PageNumber = VM.PageNumberForAddress[PrincOpsUtils.MyLocalFrame[]];
FindOriginalFrameHeap: BootStartList.Proc = {
OPEN BootStartList;
entry: EntryPointer = IndexToEntryPointer[index];
WITH e: entry SELECT FROM
space => NULL;
swapUnit => {
suPage: VM.PageNumber = IndexToSpaceEntryPointer[e.parent].vmPage + e.base;
IF myFramePage IN [suPage..suPage + e.pages) THEN {
frameHeapPieceList _ PageNumberToMDSAddress[suPage];
RETURN[TRUE]
};
};
ENDCASE;
};
PDA.fault[qFrameFault] _ PDA.fault[qPageFault] _ PDA.fault[qWriteProtectFault] _
[queue: QueueEmpty, condition: [tail: PsbNull, abortable: FALSE, wakeup: FALSE]];
Process.Detach[FORK PageFaultProcess];
Process.Detach[FORK WriteProtectFaultProcess];
BootStartList.Enumerate[FindOriginalFrameHeap];
Process.Detach[FORK FrameFaultProcess];
Process.DisableTimeout[@largeFramesInUse];
Process.Detach[FORK FlushLargeFramesProcess];
};

Initialize[];
IF GermSwap.switches[two] THEN DebuggerSwap.CallDebugger["Key stop 2 (VM)"];
ProcessorFace.SetMP[MPCodes.vmInitialized];

END.


&VMFaultsImpl.mesa
last edited by Levin on November 15, 1983 1:46 pm
Last Edited by: Birrell, April 25, 1983 1:54 pm

Global Variables

Exports to VMStatistics

Exports to VMInternal

Fault-Handling Processes
Reserve a state vector for this process
Reserve a state vector for this process
Reserve a state vector for this process.
We will allocate a large frame (i.e., an integral number of pages).
We will allocate a small frame, which may or may not require extension of the heap.
Assert: frSize MOD 4 = 0.
The remaining space in the most recent extension piece is insufficient for the faultee.  We subdivide the available space into the smallest set of frames that will exhaust (or nearly exhaust) it.
We now allocate a new piece from which to build frames.
Fabricate a new frame
Atomically chain the new frame onto the AV:
Note that we can not do a Frame.Free[] here because large frames
have an fsi different than that of the AV slot we put them in.
Restart faulted process:

This process can run at any priority and without a reserved state vector.


Internal Procedures
If the successor of "process" on the queue differs from "process", we extract the page number on which it has faulted.  Note that another process may come along and be inserted between the two, but this is unlikely and we're only looking for a hint to optimize disk arm motion.
Splice me in as top-of-stack of psb.
Return to caller without disturbing this frame.
Control returns here in the context of the faulting process.  If it has
a dirty cleanup link, disaster may ensue if a signal is raised, since it is
almost certain to be uncaught and the AMEvents stuff will doubtless do a WAIT.
If someone caught it and did a wait, similar bad things would happen.  So, we
call the world-swap debugger instead.
Implementation note:  The explicit use of PrincOpsUtils to invoke monitor instructions is required because FaultQueues do not have full CONDITION variables in them.  Rather, they have only the Queue portion; there is no timeout field.  Since the generated code for WAIT assumes a timeout word follows the Queue, the language construct can't be used.  Of course, the use of monitor locks is really unnecessary anyway, since there is only a single process doing waits and the condition variable is notified by microcode with a naked notify.  However, it is the easiest way to achieve the desired effect.


Note:  AV[LargeReturnSlot] can go from non-empty to empty only as a result of this procedure.  Therefore, the test of AV[LargeReturnSlot] need not be made with interrupts disabled.
The following are legal only because they are INLINEs.
head of large frame list is being freed.

This is a specialized procedure for use by the frame fault handler.  It is semantically equivalent to {interval _ Allocate[count, mds]; SwapIn[interval, kill: TRUE, pin: TRUE]}, but must be implemented carefully because of the delicate state of the world at the time it is invoked.
The following is actually a coroutine call (to avoid frame allocation).
The following is actually a coroutine call (to avoid frame allocation).
Initialization
Κ–

"Cedar" style˜Jš
œ™Jš
œ1™1J™/J˜š
Οk	˜	šœœ˜Jš
œN˜N—Jšœ
œ#˜5Jšœ	œ˜Jšœœ˜šœ	œ˜JšœAœc˜§
—šœ˜Jš
œ΅
˜΅
—šœœ˜Jš
œf˜f—Jšœœ	˜šœ
œ˜
Jš
œš
˜š
—šœœ˜Jš
œσ
˜σ
—Jšœ
œ˜J˜—šœœ
œ
œ
œ
œ
˜JJšœOœ˜dJšœ˜"J˜—Jš
˜J˜Jšœ
˜J˜J™J™J˜Jšœœ
˜J˜Jšœ	œ
˜J˜=J™J™J˜Jšœœ
œ˜(Jšœ
œ
œ˜Jšœ+œ
œ˜:Jšœ(œ
œ˜7J™J™J˜Jšœœœ
˜;JšœœœΟc˜TJ™J™J˜šΟnœœ˜Jš
œ'™'J˜3š
˜Jš
œ0˜0šœ
œ˜Jšœœ
œ%˜K—šœ>˜@Jšœœ'œœ˜H—Jš
œ$˜$Jšžœœ
˜)Jšœ
˜—J˜—J˜šŸœœ˜"Jš
œ'™'J˜3š
˜Jš
œ8˜8Jšœœ˜+Jš
œ,˜,Jšžœœ
˜+Jšœ
˜—J˜—J˜Jš
œ
œ!œ
œœž˜UJ˜šŸœœ˜Jš
œ(™(Jšœ˜J˜3š
˜Jš
œ1˜1Jšœœ
œ˜@Jšœœ4œ
˜IJšœž4˜Lšœœ˜'Jš
œC™CJšœœœ)œ˜CJš
œT˜TJšœœœœ˜CJš
œ˜Jšœ/ž+˜ZJš
œ)˜)Jšžœ-œ
˜=Jš
œ
˜
—šœ˜Jš
œS™SJšœœ™Jš
œ+˜+Jšœ
œ
œž"˜Ešœ
œ
œ2œ˜KJš
œΓ
™Γ
šœœ˜Jšœ-œ˜5—Jšœœœ ˜>Jšœœ2œ
˜MJšœœ
˜Jš
œ%˜%JšœKœ
˜PšœK˜Ršœœ˜Jšœ,œœ
˜K—šœ˜#Jš
œ˜Jšœ)ž$˜MJš
œ&˜&Jš
œ0˜0Jš
œ,˜,Jšœ
˜—Jšœ
˜—Jš
œ7™7Jšœ
œE˜Mš
œ
˜
Jš
œ˜Jš
œ ˜ Jšœ!œ
˜&Jšœ
˜Jš
œ˜—Jš
œ˜Jšžœ+œ
˜;Jš
œ˜—Jš
œ™JšœKœ
˜PJ˜J˜Jš
œ-˜-Jšžœ-œ
˜=Jš
œ˜—Jš
œ+™+Jš
œ@™@Jš
œ>™>Jš
œ"˜"Jšœœ
œœ˜;Jšœ˜Jšžœ%œ
˜?J˜!Jš
œ™J˜%Jšžœœ
˜+Jšœ
˜—J˜—J™šŸœœ˜!Jš
œI™IJš
œ3˜3š
˜Jš
œ8˜8šœ˜Jšœœ"˜+Jšœœ>˜G—Jšžœ%œ
˜5Jšœ
˜—J˜—J™J™Jš
œ™J˜šŸœœœ
œ
œœ˜TJšœœœ,˜D—J˜š
Ÿœœœœœ˜MJš
œ•™•Jšœ8œ˜Pšœ
˜Jšœœ˜Jšœ
œœ
œ)˜M—Jš
œ˜J˜—š
Ÿœœœœ
œ˜CJšŸœœœ!˜8Jšœœ
œ˜1Jšœ	œ
œž)˜TJš
œ$™$Jšœ
œœ
œ"˜NJš
œ*˜*Jšœ
œœ˜KJš
œ/™/J˜	Jš
œG™GJš
œK™KJš
œN™NJš
œM™MJš
œ%™%šœ
œ˜)Jš
œX˜X—Jšœ˜J˜—J˜šŸœœœœ˜HJš
œΩ™ΩJšœœ
˜Jš
œœ
œ
œ
	œœœ˜JJšž,œž˜FJšœ œ
œ
˜0šœ
œ˜(Jš
œ5˜5Jšœ.œ
œ
˜>Jšœ
˜—Jšœ%œœ!˜SJš
œ˜J˜—J™šŸœœ#œ˜?Jšœœœ
˜<J˜—J™šŸœœ
œ'œ˜NšŸœœ
œœ
œ
œœ˜OJš
œ΄
™΄
Jšœ˜š
˜Jšœ
œœ
œ
˜-Jš
œ6™6Jšœœ
œ*˜FJšœ:˜>Jšœ˜Jšœ
˜—Jšœ$ž˜>šœ
œ
˜Jšœ+œœ˜L—Jšœœ˜:Jšœ#ž˜:šœ˜#Jš
œ(™(Jšœ'œ
œ
˜U—š
˜šœ-œ
˜7J˜'——J˜—Jš
œ)˜)J˜—J˜šŸœœ'œ˜EšŸœœ
œœ
œ
œœ˜NJš
œ!˜!Jšœœ
œ"˜?Jš
œ˜Jšœ;ž˜TJšœ˜J˜—Jš
œ(˜(J˜—J™šŸœœ	œ˜2Jšœœ
œ˜*J™™Jš
œ&˜&šŸœœ
œœ
œ
œœ˜TJš
œG™GJš
œL˜LJ˜—Jš
œ8˜8Jšœœ9˜Nšœœœ/˜KJš
œG™GJš
œ2˜2Jšœ
˜—J˜—J˜šŸœœœ
œœœ˜XJšœœ˜<J˜J˜—Jš
œ™J˜šŸ
œœ˜Jšœ
œœ4˜S˜-Jšœ˜J˜1šœ
œ
˜Jšœ	œ
˜š
œ
˜
Jšœœ7œ˜Kšœ
œœ˜3Jš
œ4˜4Jšœ
œ
˜Jš
œ˜—J˜—Jšœ
˜—Jš
œ˜—šœœœ˜PJšœ:œ
œ˜Q—Jšœœ˜&Jšœœ˜.J˜/Jšœœ˜'J˜*Jšœœ˜-Jš
œ˜—J˜J˜
Jšœœ.˜LJ˜+J˜Jšœ
˜J˜J˜—…—*B>