AddressForPageNumber, Allocate, CantAllocate, DataState, Interval, IOErrorType, nullInterval, PageCount, PageNumber, PageState],

AllocateForSwapIn, Age, CleanDone, CleanOutcome, ConsiderCleaning, Crash, DoIO, HasBackingStorage, IOResult, lastVMPage, MakeReadOnly, MakeReadWrite, NoteFreePages, NoteDirtyVictim, Outcome, RealPageNumber, SetDataState, State, swapBufferSize, SwapInDone, SwapInDoneWithoutIO, SwapInOutcome, Unpin, Victim, VictimWriteDone],

RETURN[VMInternal.SetDataState[vmPage, dataState]]

};

1) Disk reads are not requested individually; rather, runs of consecutive swapped-out pages are built up and passed to the DoReads procedure, which typically can initiate all reads as a single disk request.

2) DoReads (actually, VMInternal.DoIO) breaks up a run of virtual page reads into runs of physically contiguous disk page reads. Typically, the entire virtual page run will be a single physical page run.

3) The call of DoReads after a virtual page run has been completed is generally deferred until the first page of the next run is known. This permits DoReads to issue the physical I/O request and follow it immediately with a request to seek to the starting disk address of the subsequent run.

4) The swap buffer (and the state vector needed to protect it) are not acquired until it is known that a disk operation will occur. This optimizes the frequent case of kill=pin=TRUE, which is used by the file system's Read operation.

5) The swap buffer is of fixed size, and a request to SwapIn an interval larger than the swap buffer may be broken into multiple calls of DoReads, and consequently multiple disk requests, even though the interval could have been swapped in with a single disk request. The size chosen for the swap buffer is supposed to be large enough that this is a rare event.

6) Dirty victims cause the virtual page run being built up to be terminated and DoReads called immediately. Dirty victims are supposed to occur rarely; if they don't, the Laundry process isn't working properly. For the same reason, no attempt is made to build up writes of dirty victims into successive runs.

swapIndex: PageCount ← 0;

--*stats*-- IF pagesInSwapBuffer > 0 THEN swapInVirtualRuns ← swapInVirtualRuns.SUCC;

UNTIL swapIndex >= pagesInSwapBuffer DO

pagesInSwapBuffer ← 0;

};

IF ~haveSwapBuffer THEN {ReserveSwapBuffer[]; haveSwapBuffer ← TRUE};

IF SwapBufferEmpty[] THEN swapBufferBase ← vmPage;

Assert: swapBufferBase + pagesInSwapBuffer = vmPage

PrincOpsUtils.SetPageFlags[

pagesInSwapBuffer ← pagesInSwapBuffer.SUCC;

};

RETURN[pagesInSwapBuffer = 0]};

RETURN[pagesInSwapBuffer = swapBuffer.count]};

winner: PageNumber, victim: dirty VMInternal.Victim, willReadWinner: BOOL]

RETURNS [worked: BOOL] = {

Cleaning a victim may require acquisition of the swap buffer and/or allocation of the state vector for the first time. The victim is always written from the first page of the swap buffer and a single page at a time.

AddToSwapBuffer[victim.vmPage, victim.realPage];

The reasoning behind setting subsequentSeek as indicated below is a little subtle. If "willReadWinner" is TRUE, we are about to put "winner" into the swap buffer (at the next level up) to be read. Since the swap buffer has been flushed in preparation for the dirty victim write, "winner" will be the first page in the swap buffer and therefore will be the target of the next I/O request we make.

worked ← VMInternal.DoIO[

--*stats*--

VMInternal.VictimWriteDone[winner, swapBuffer.page, victim, worked];

pagesInSwapBuffer ← 0;

VMInternal.NoteDirtyVictim[];

};

outcome: VMInternal.SwapInOutcome;

victim: VMInternal.Victim;

[outcome, victim] ← VMInternal.AllocateForSwapIn[vmPage: page, kill: kill, pin: pin];

--*stats*-- swapInPages ← swapInPages.SUCC;

SELECT outcome FROM

page ← page.SUCC;

ENDLOOP;

swapIndex: PageCount ← 0;

--*stats*-- IF dirtyPagesInSwapBuffer > 0 THEN cleanVirtualRuns ← cleanVirtualRuns.SUCC;

There is a (potentially empty) tail of clean pages in the swap buffer that need not be written. We mark them clean again (i.e., check them in) and cut the swap buffer back to the last dirty page.

FOR page: PageCount IN [dirtyPagesInSwapBuffer..pagesInSwapBuffer) DO

--*stats*-- cleanUnneededCheckOutCleans ←

pagesInSwapBuffer ← dirtyPagesInSwapBuffer;

UNTIL swapIndex >= pagesInSwapBuffer DO

pagesInSwapBuffer ← dirtyPagesInSwapBuffer ← 0;

};

IF ~haveSwapBuffer THEN {ReserveSwapBuffer[]; haveSwapBuffer ← TRUE};

IF SwapBufferEmpty[] THEN swapBufferBase ← vmPage;

Assert: swapBufferBase + pagesInSwapBuffer = vmPage

PrincOpsUtils.SetPageFlags[

pagesInSwapBuffer ← pagesInSwapBuffer.SUCC;

};

RETURN[pagesInSwapBuffer = 0]};

RETURN[pagesInSwapBuffer = swapBuffer.count]};

outcome: VMInternal.CleanOutcome ← cantWrite;

realPage: VMInternal.RealPageNumber;

IF VMInternal.HasBackingStorage[page] THEN

SELECT outcome FROM

page ← page.SUCC;

ENDLOOP;

SELECT perPage[page] FROM

ENDLOOP;

ERROR AddressFault[AddressForPageNumber[VMInternal.lastVMPage + 1]]

WHILE swapBufferReserved DO WAIT swapBufferAvailable; ENDLOOP;

swapBufferReserved ← TRUE;

};

swapBuffer ← VM.Allocate[count: swapBufferSize ! VM.CantAllocate => VMInternal.Crash[]];

swapBufferReserved ← FALSE;

NOTIFY swapBufferAvailable;

};

WHILE stateVectorReserved DO WAIT stateVectorAvailable; ENDLOOP;

stateVectorReserved ← TRUE;

};

stateVectorReserved ← FALSE;

NOTIFY stateVectorAvailable;

};