(FILECREATED "20-Apr-84 15:35:18" {PHYLUM}<LISPCORE>SOURCES>LLFAULT.;6 315240Q
changes to: (FNS \WRITEDIRTYPAGE)
previous date: " 7-Apr-84 19:17:40" {PHYLUM}<LISPCORE>SOURCES>LLFAULT.;5)
(* Copyright (c) 1982, 1983, 1984 by Xerox Corporation)
(PRETTYCOMPRINT LLFAULTCOMS)
(RPAQQ LLFAULTCOMS [(FNS \FAULTHANDLER)
(VARS (FAULTTEST T))
(FNS \FAULTINIT \D01.FAULTINIT \D01.ASSIGNBUFFERS)
(FNS \DL.FAULTINIT \DL.NEWFAULTINIT \DL.UNMAPPAGES \DL.MARK.PAGES.UNAVAILABLE
\DL.ASSIGNBUFFERS)
(FNS \PAGEFAULT \INVALIDADDR \INVALIDVP \FLUSHPAGE \LOADVMEMPAGE \LOOKUPPAGEMAP
\MARKPAGEVACANT \SELECTREALPAGE \SPECIALRP \TRANSFERPAGE \MOVEPAGE \ZEROPAGE
\UPDATECHAIN)
(FNS \NEWPAGE \DONEWPAGE \MAKESPACEFORLOCKEDPAGE \MOVEVMEMFILEPAGE \NEWEPHEMERALPAGE
\DONEWEPHEMERALPAGE \LOCKPAGES \DOLOCKPAGES \TEMPLOCKPAGES \TEMPUNLOCKPAGES \UNLOCKPAGES
\FLUSHVM \LOGOUT0 \DOFLUSHVM \RELEASEWORKINGSET \WRITEDIRTYPAGE \WRITEDIRTYPAGE1
\COUNTREALPAGES)
(FNS \DOCOMPRESSVMEM VMEM.PURE.STATE)
(INITVARS (\UPDATECHAINFREQ 100)
(\PAGEFAULTCOUNTER 0)
(\DIRTYPAGECOUNTER 0)
(\DIRTYPAGEHINT 0)
(\LASTACCESSEDVMEMPAGE 0)
(\MAXSHORTSEEK 1000)
(\MINSHORTSEEK 20)
(\MAXCLEANPROBES 20)
(\VMEM.INHIBIT.WRITE)
(\VMEM.PURE.LIMIT)
(VMEM.COMPRESS.FLG)
(\DOFAULTINIT 0)
(\FPTOVP)
(\VMEMACCESSFN)
(\SYSTEMCACHEVARS)
(\MAXSWAPBUFFERS 1))
(INITVARS (\LASTDIRTYCNT)
(\LASTDIRTYFOUND)
(\LASTDIRTYSCANPTR)
(\DIRTYSEEKMAX 50))
(COMS (* Errors)
(FNS \MP.ERROR))
(COMS (* Debugging)
(FNS \ACTONVMEMFILE \SHOWPAGETABLE CHECKPAGEMAP CHECKFPTOVP \LOCKED?STRING \PRINTFPTOVP
\PRINTVP))
(E (RESETSAVE (RADIX 8)))
(DECLARE: EVAL@COMPILE DONTCOPY (MACROS \ACTONVMEMFILE)
(COMS (* Virtual page flags)
(CONSTANTS \VMAP.DIRTY \VMAP.CLEAN \VMAP.REF \VMAP.VACANT \VMAP.FLAGS
\VMAP.NOTFLAGS)
(RECORDS VMEMFLAGS)
(MACROS LOGNOT16))
(COMS (* RPT constants)
(CONSTANTS \PAGEMAPLOCKBIT \RPT.EMPTY \RPT.UNAVAILABLE \PAGETABLESTOPFLG
\RPTENTRYLENGTH)
(RECORDS RPT)
(MACROS RPFROMRPT RPTFROMRP NPAGESMACRO))
(COMS (* Virtual to file pagemap)
(EXPORT (CONSTANTS \MAXVMPAGE \MAXVMSEGMENT \MAXFILEPAGE))
(CONSTANTS \EMPTYPMTENTRY)
(RECORDS VP PAGEMAPENTRY)
(MACROS .PAGEMAPBASE.))
(COMS (* FP to VP stuff)
(RECORDS FPTOVP)
(CONSTANTS \NO.VMEM.PAGE)
(MACROS DLRPFROMFP DLFPFROMRP))
(PROP DOPVAL \TOUCHPAGE TIMES3)
(CONSTANTS \MAXDIRTYSCANCOUNT \MINVMEMSPAREPAGES \DLBUFFERPAGES)
(CONSTANTS 2MBPAGES)
(GLOBALVARS \UPDATECHAINFREQ \REALPAGETABLE \RPOFFSET \RPTSIZE \EMBUFBASE \EMBUFVP
\EMBUFRP \PAGEFAULTCOUNTER \LASTDIRTYCNT \LASTDIRTYFOUND
\LASTDIRTYSCANPTR \MACHINETYPE \LASTACCESSEDVMEMPAGE \MAXSHORTSEEK
\MAXCLEANPROBES \MINSHORTSEEK \DIRTYSEEKMAX \DIRTYPAGECOUNTER
\DIRTYPAGEHINT \VMEM.INHIBIT.WRITE \VMEM.PURE.LIMIT VMEM.COMPRESS.FLG
\KBDSTACKBASE \MISCSTACKBASE \DOFAULTINIT \FPTOVP \VMEMACCESSFN
\SYSTEMCACHEVARS)
(GLOBALVARS \#SWAPBUFFERS \#EMUBUFFERS \#DISKBUFFERS \MAXSWAPBUFFERS
\EMUSWAPBUFFERS \EMUBUFFERS \TELERAIDBUFFER \EMUDISKBUFFERS
\EMUDISKBUFEND))
[COMS (* * MAKEINIT stuff)
(FNS ADDPME CHECKIFPAGE FIXIFPAGE DUMPINITPAGES MAKEROOMFORPME MAPPAGES READPAGEMAP
READPAGEMAPBLOCK SETUPPAGEMAP)
(DECLARE: DONTCOPY (MACROS CHECKIF)
(ADDVARS (INEWCOMS (FNS DUMPINITPAGES)
(VARS INITCONSTANTS)
(FNS SETUPPAGEMAP ADDPME MAKEROOMFORPME MAPPAGES))
(RDCOMS (FNS READPAGEMAP READPAGEMAPBLOCK CHECKIFPAGE FIXIFPAGE))
(EXPANDMACROFNS CHECKIF)
(MKI.SUBFNS (\NEWPAGE . MKI.NEWPAGE)
(\LOCKPAGES . MKI.LOCKPAGES))
(RD.SUBFNS (\NEWPAGE . VNEWPAGE)
(\LOCKPAGES . VLOCKPAGES)))
EVAL@COMPILE
(ADDVARS (DONTCOMPILEFNS DUMPINITPAGES SETUPPAGEMAP ADDPME MAKEROOMFORPME
MAPPAGES READPAGEMAP READPAGEMAPBLOCK CHECKIFPAGE]
(FNS \LOCKFN \LOCKCODE \LOCKVAR \LOCKCELL \LOCKWORDS)
[DECLARE: DONTCOPY
(ADDVARS (INEWCOMS (ALLOCAL (ADDVARS (LOCKEDFNS \FAULTHANDLER \FAULTINIT
\D01.FAULTINIT \DL.FAULTINIT
\MAKESPACEFORLOCKEDPAGE \PAGEFAULT
\READRP \READFLAGS \WRITEMAP
\LOOKUPPAGEMAP \LOADVMEMPAGE
\INVALIDADDR RAID \INVALIDVP
\SELECTREALPAGE \TRANSFERPAGE
\UPDATECHAIN \MARKPAGEVACANT
\FLUSHPAGE \MOVEPAGE \ZEROPAGE
\FLUSHVM \DONEWPAGE
\DONEWEPHEMERALPAGE
\WRITEDIRTYPAGE1 \COPYSYS0
\COPYSYS0SUBR \RELEASEWORKINGSET
\DOFLUSHVM \DOLOCKPAGES
\TEMPLOCKPAGES \TEMPUNLOCKPAGES
\MP.ERROR \DL.NEWFAULTINIT
\DL.MARK.PAGES.UNAVAILABLE
\DL.UNMAPPAGES \DL.ASSIGNBUFFERS
\D01.ASSIGNBUFFERS \DOCOMPRESSVMEM
\MOVEVMEMFILEPAGE)
(LOCKEDVARS \REALPAGETABLE \PAGEFAULTCOUNTER
\UPDATECHAINFREQ \RPOFFSET
\RPTSIZE \EMBUFBASE \EMBUFVP
\EMBUFRP \LASTACCESSEDVMEMPAGE
\MAXSHORTSEEK \MAXCLEANPROBES
\MINSHORTSEEK \DIRTYPAGECOUNTER
\DIRTYPAGEHINT \VMEM.INHIBIT.WRITE
\VMEM.PURE.LIMIT VMEM.COMPRESS.FLG
\KBDSTACKBASE \MISCSTACKBASE
\DOFAULTINIT \FPTOVP \MACHINETYPE
\VMEMACCESSFN \TELERAIDBUFFER
\EMUDISKBUFFERS \EMUDISKBUFEND
\MAXSWAPBUFFERS)))
(FNS \LOCKFN \LOCKVAR \LOCKCELL \LOCKWORDS \LOCKCODE]
[COMS (* Clock stuff)
(FNS \CLOCK0 \DAYTIME0 \GETINTERNALCLOCK \SETDAYTIME0 CLOCKDIFFERENCE
\SECONDSCLOCKGREATERP \CLOCKGREATERP \RCLOCK0)
(FNS CLOCK0)
(MACROS \RCLOCK0)
(DECLARE: DONTCOPY (EXPORT (MACROS \UPDATETIMERS)))
[DECLARE: DONTEVAL@LOAD DOCOPY (P (MOVD (QUOTE \DAYTIME0)
(QUOTE DAYTIME0]
(VARS (\RCLKMILLISECOND 1680))
(GLOBALVARS \RCLKSECOND \RCLKMILLISECOND)
(DECLARE: DONTCOPY (* Locations in alto emulator)
(EXPORT (CONSTANTS (\RTCSECONDS 378)
(\RTCMILLISECONDS 380)
(\RTCBASE 382)
(\OFFSET.SECONDS 0)
(\OFFSET.MILLISECONDS 2)
(\OFFSET.BASE 4)
(\ALTO.RCLKSECOND 1680000)
(\ALTO.RCLKMILLISECOND 1680)
(\DLION.RCLKMILLISECOND 35)
(\DLION.RCLKSECOND 34746))
(MACROS RWMufMan))
(* Locked stuff. Have to lock anything used by pagefault code, including the
ufns that they use until all microcodes have them)
(ADDVARS (INEWCOMS (ALLOCAL (ADDVARS (LOCKEDFNS \CLOCK0 \GETINTERNALCLOCK
\BOXIDIFFERENCE \BOXIPLUS
\BLT \SLOWIQUOTIENT)
(LOCKEDVARS \RCLKSECOND \RCLKMILLISECOND
\MISCSTATS]
(DECLARE: DONTEVAL@LOAD DOEVAL@COMPILE DONTCOPY COMPILERVARS (ADDVARS (NLAMA)
(NLAML)
(LAMA VMEM.PURE.STATE])
(DEFINEQ
(\FAULTHANDLER
[LAMBDA NIL (* bvm: "31-MAR-83 17:34")
(PROG NIL
LP [OR (AND \DOFAULTINIT (\FAULTINIT))
(\PAGEFAULT (\VAG2 (fetch (IFPAGE FAULTHI) of \InterfacePage)
(fetch (IFPAGE FAULTLO) of \InterfacePage]
(\CONTEXTSWITCH \FAULTFXP)
(GO LP])
)
(RPAQQ FAULTTEST T)
(DEFINEQ
(\FAULTINIT
[LAMBDA NIL (* bvm: "31-MAR-83 17:42")
(* * retrieves some constants from Interface page for the swapper and performs other initialization that must
happen immediately. Called when starting up, and also when \FAULTHANDLER context starts, in case init hasn't
happened yet, as e.g. from MAKEINIT)
(SETQ \FPTOVP (AND (NOT (ZEROP (fetch FPTOVPStart of \InterfacePage)))
(create POINTER
PAGE# ← \VP.FPTOVP)))
(SETQ \LASTDIRTYSCANPTR)
(SELECTC (SETQ \MACHINETYPE (fetch MachineType of \InterfacePage))
(\DANDELION (\DL.FAULTINIT))
(\D01.FAULTINIT))
(COND
((EQ (PROG1 \DOFAULTINIT (SETQ \DOFAULTINIT NIL))
T) (* true after \FLUSHVM. Need to rebuild some contexts)
(replace (IFPAGE KbdFXP) of \InterfacePage with (\MAKEFRAME (COND
((fetch (LITATOM CCODEP)
of (QUOTE \KEYHANDLER))
(FUNCTION \KEYHANDLER))
(T (QUOTE \DUMMYKEYHANDLER)))
\KBDSTACKBASE
(IPLUS \KBDSTACKBASE
\StackAreaSize)
0 0))
(replace (IFPAGE MiscFXP) of \InterfacePage with (\MAKEFRAME (FUNCTION \DOMISCAPPLY)
\MISCSTACKBASE
(IPLUS \MISCSTACKBASE
\StackAreaSize)
0 0))
T])
(\D01.FAULTINIT
(LAMBDA NIL (* JonL "14-Mar-84 04:14")
(SETQ \VMEMACCESSFN (FUNCTION \M44ACTONVMEMFILE))
(SETQ \REALPAGETABLE (EMPOINTER (fetch (IFPAGE REALPAGETABLE) of \InterfacePage)))
(* Note: these SETQ's do not reference count, since the
values are all smallp's and emulator addresses
(in atom space))
(SETQ \RPOFFSET (SIGNED (fetch (IFPAGE RPOFFSET) of \InterfacePage)
BITSPERWORD))
(SETQ \RPTSIZE (fetch (IFPAGE RPTSIZE) of \InterfacePage))
(* Initialize the software clocks from alto emulator)
(\BLT (LOCF (fetch SECONDSCLOCK of \MISCSTATS))
(EMADDRESS \RTCSECONDS)
(UNFOLD 3 WORDSPERCELL))
(SETQ \RCLKMILLISECOND (CONSTANT (OR (SMALLP \ALTO.RCLKMILLISECOND)
(ERROR \ALTO.RCLKMILLISECOND
"\ALTO.RCLKMILLISECOND isn't a SMALLP???"))))
(* * \ALTO.RCLKMILLISECOND must be a SMALLP here so as not to cause any refcnt or pagefault activity.
\RCLKSECOND is large and has to live on \MISCSTATS, since there is no convenient way to lock a random cell.)
(SETQ.NOREF \RCLKSECOND (LOCF (fetch RCLKSECOND of \MISCSTATS)))
(* * Note the SETQ.NOREF for \RCLKSECOND in order to guarantee no refcnt'ing (which might pagefault) Note that
these LOADBYTE expressions are compiled as constants)
(replace (FIXP HINUM) of \RCLKSECOND with (LOADBYTE \ALTO.RCLKSECOND 16 16))
(replace (FIXP LONUM) of \RCLKSECOND with (LOADBYTE \ALTO.RCLKSECOND 0 16))
(if (AND (EQ \MACHINETYPE \DORADO)
(ILEQ 5124 (fetch RVersion of \InterfacePage)))
then (replace NSHost0 of \InterfacePage with 0)
(replace NSHost1 of \InterfacePage with 21898)
(replace NSHost2 of \InterfacePage
with (IPLUS (MASK.1'S 15 1)
(for I (N ← 0) from 1168 to 1175
do (* Mufflers "2220Q" thru "2227Q" hold the bits of the
basic serial number)
(SETQ N (IPLUS (LLSH N 1)
(if (BITTEST (RWMufMan I)
(MASK.1'S 15 1))
then 0
else 1)))
finally (RETURN N)))))
(\D01.ASSIGNBUFFERS)))
(\D01.ASSIGNBUFFERS
[LAMBDA NIL (* bvm: "12-JUL-83 18:25")
(PROGN (* Assign swap buffer)
(SETQ \EMBUFVP (fetch (IFPAGE EMBUFVP) of \InterfacePage))
(SETQ \EMBUFBASE (EMPOINTER (UNFOLD \EMBUFVP WORDSPERPAGE)))
(SETQ \EMBUFRP (\READRP \EMBUFVP)))
(PROG ((EMBUF (fetch (IFPAGE EMUBUFFERS) of \InterfacePage))
(EMLEN (fetch (IFPAGE EMUBUFLENGTH) of \InterfacePage))
EXTRALEN NPAGES)
[add EMLEN (IDIFFERENCE EMBUF (SETQ EMBUF (CEIL EMBUF WORDSPERPAGE]
(* Round up to a page boundary and throw out the excess)
(SETQ EXTRALEN (IMOD EMLEN WORDSPERPAGE))
(add EXTRALEN (COND
((ILESSP EXTRALEN 100)
(TIMES 2 WORDSPERPAGE))
(T WORDSPERPAGE)))
(SETQ NPAGES (FOLDLO (SETQ EMLEN (IDIFFERENCE EMLEN EXTRALEN))
WORDSPERPAGE))
(OR (IGEQ NPAGES 4)
(RAID "No swap buffer space"))
(SETQ \TELERAIDBUFFER (EMPOINTER EMBUF))
(SETQ \EMUBUFFERS (\ADDBASE \TELERAIDBUFFER WORDSPERPAGE))
(SETQ \#EMUBUFFERS (SETQ NPAGES (SUB1 NPAGES)))
(SETQ \#SWAPBUFFERS (IMIN \MAXSWAPBUFFERS (IQUOTIENT NPAGES 2)))
(SETQ \#DISKBUFFERS (IDIFFERENCE \#EMUBUFFERS \#SWAPBUFFERS))
(SETQ \EMUDISKBUFFERS \EMUBUFFERS)
(SETQ \EMUDISKBUFEND (\ADDBASE \EMUDISKBUFFERS (UNFOLD \#DISKBUFFERS WORDSPERPAGE)))
(SETQ \EMUSWAPBUFFERS \EMUDISKBUFEND)
(\INITBFS (\ADDBASE \EMUBUFFERS (UNFOLD NPAGES WORDSPERPAGE))
EXTRALEN T])
)
(DEFINEQ
(\DL.FAULTINIT
[LAMBDA NIL (* bvm: " 8-APR-83 14:52")
(SETQ \VMEMACCESSFN (FUNCTION \DL.ACTONVMEMFILE))
(SETQ \IOCBPAGE (create POINTER
PAGE# ← \VP.IOCBS))
(COND
((NEQ (fetch (IFPAGE Key) of \InterfacePage)
\IFPValidKey)
(\MP.ERROR \MP.INVALIDVMEM)))
(COND
((NULL \FPTOVP)
(SETQ \REALPAGETABLE (EMPOINTER (fetch (IFPAGE REALPAGETABLE) of \InterfacePage)))
(SETQ \RPOFFSET (SIGNED (fetch (IFPAGE RPOFFSET) of \InterfacePage)
BITSPERWORD))
(SETQ \RPTSIZE (fetch (IFPAGE RPTSIZE) of \InterfacePage))
(SETQ \EMBUFVP (fetch (IFPAGE EMBUFVP) of \InterfacePage))
(SETQ \EMBUFBASE (EMPOINTER (UNFOLD \EMBUFVP WORDSPERPAGE)))
(SETQ \EMBUFRP (\READRP \EMBUFVP))
(* * the bootstrapping process leaves some information about the disk in page 1 of the display bank.
BLT this up into the IOCB page)
(\BLT \IOCBPAGE (create POINTER
PAGE# ←(ADD1 \VP.DISPLAY))
WORDSPERPAGE))
(T (\DL.NEWFAULTINIT)))
(SETQ \RCLKMILLISECOND \DLION.RCLKMILLISECOND) (* These are fortunately both small)
(SETQ \RCLKSECOND \DLION.RCLKSECOND)
(\RCLK (LOCF (fetch BASECLOCK of \MISCSTATS))) (* Reset base clock)
[COND
((ZEROP (fetch DLTODVALID of \IOPAGE)) (* Time not valid, so store zero in the clock)
(\PUTBASEPTR (LOCF (fetch SECONDSCLOCK of \MISCSTATS))
0 NIL))
(T (bind TMP (BASE ←(LOCF (fetch SECONDSCLOCK of \MISCSTATS)))
do (* Loop until clock reads the same as we wrote, in case
it was being updated)
(\PUTBASE BASE 1 (SETQ TMP (fetch DLTODLO of \IOPAGE)))
(\PUTBASE BASE 0 (fetch DLTODHI of \IOPAGE))
repeatuntil (EQ (fetch DLTODLO of \IOPAGE)
TMP]
(\PUTBASEPTR (LOCF (fetch MILLISECONDSCLOCK of \MISCSTATS))
0 NIL) (* Clear the milliseconds timer)
(repeatwhile (IGEQ (fetch DLPROCESSORCMD of \IOPAGE)
\DL.PROCESSORBUSY)) (* Wait for IOP readiness)
(replace DLPROCESSORCMD of \IOPAGE with \DL.READPID) (* Ask it to give the processor ID
(3 words))
(repeatwhile (IGEQ (fetch DLPROCESSORCMD of \IOPAGE)
\DL.PROCESSORBUSY))
(replace NSHost0 of \InterfacePage with (fetch DLPROCESSOR0 of \IOPAGE))
(replace NSHost1 of \InterfacePage with (fetch DLPROCESSOR1 of \IOPAGE))
(replace NSHost2 of \InterfacePage with (fetch DLPROCESSOR2 of \IOPAGE))
(\DL.DISKINIT T])
(\DL.NEWFAULTINIT
[LAMBDA NIL (* bvm: "14-Jan-84 14:45")
(* We have just started up on a DLion. Boot code has loaded the first n pages of the sysout into pages 2 thru n-3,
except for the area covered by the map and IO page, and has built the map accordingly. Our principal task is to
build \REALPAGETABLE)
(PROG ((NREALPAGES (fetch (IFPAGE NRealPages) of \InterfacePage))
(FIRSTBUFFERRP \RP.STARTBUFFERS)
(SCRATCHVP \VP.INITSCRATCH)
(SCRATCHBASE (create POINTER
PAGE# ← \VP.INITSCRATCH))
(DISPLAYBASE (create POINTER
PAGE# ← \VP.DISPLAY))
FIRSTUSEFULRP IFPAGERP IOCBRP RPTBASE VP DEBUGGING)
[do (COND
((for I from 0 to (SUB1 \DLBUFFERPAGES) as (FPBASE ←(\ADDBASE \FPTOVP (DLFPFROMRP
FIRSTBUFFERRP)))
by (\ADDBASE FPBASE 1)
do (COND
((OR (NOT (fetch FPOCCUPIED of FPBASE))
(fetch FPLOCKED of FPBASE)) (* Can't use as buffer. This is just a check for
consistency; you should pick \RP.STARTBUFFERS so that
this isn't a problem)
(RETURN T))) (* Unmap this page so we can use it for buffers)
(\WRITEMAP (fetch FPVIRTUALPAGE of FPBASE)
0 \VMAP.VACANT)) (* Bad starting place, try again)
(add FIRSTBUFFERRP 1))
(T (RETURN]
(SETQ FIRSTUSEFULRP (IPLUS FIRSTBUFFERRP \DLBUFFERPAGES))
(PROGN (* Copy vital info that booting left in page 1)
(SETQ IOCBRP (IPLUS (LOGAND (SUB1 (IMIN NREALPAGES 3072))
65280)
\VP.IOCBS))
(* Put IOCB page near the end of memory, but in the first 1.5 mb so that Burdock can see it.
Temporary until Steve fixes swap code to not care what RP contains IOCB's)
(SETQ VP (\GETBASE \FPTOVP (DLFPFROMRP IOCBRP)))
(COND
((fetch LOCKEDP of VP)
(\MP.ERROR \MP.IOCBPAGE))
(T (\WRITEMAP VP 0 \VMAP.VACANT))) (* Unmap whoever lived in our target page)
(\WRITEMAP \VP.IOCBS IOCBRP \VMAP.CLEAN)
(\WRITEMAP SCRATCHVP 1 \VMAP.CLEAN)
(\BLT \IOCBPAGE SCRATCHBASE WORDSPERPAGE))
(PROGN (* Copy InterfacePage out of segment zero)
(\WRITEMAP SCRATCHVP FIRSTBUFFERRP \VMAP.CLEAN)
(\BLT SCRATCHBASE \InterfacePage WORDSPERPAGE)
(\WRITEMAP \VP.IFPAGE (SETQ IFPAGERP FIRSTBUFFERRP)
\VMAP.CLEAN)
(add FIRSTBUFFERRP 1))
(\DL.UNMAPPAGES (ADD1 \FP.IFPAGE)
(DLFPFROMRP \RP.IOPAGE)) (* Unmap everything that might have been mapped into
real segment zero or to map or IOPAGE)
(for NEXTBANK0 from 2MBPAGES by 2MBPAGES until (IGREATERP NEXTBANK0 NREALPAGES)
do (* All the "shadows of the display bank" in higher
memory have restricted use; take them out of commission
for now)
(\DL.UNMAPPAGES NEXTBANK0 (IPLUS NEXTBANK0 PAGESPERSEGMENT -1)))
(PROGN (* Copy Display into segment zero)
(for I from 0 to (SUB1 \NP.DISPLAY) do (\WRITEMAP (IPLUS SCRATCHVP I)
(IPLUS \RP.DISPLAY I)
\VMAP.CLEAN))
(* Point scratch area at real segment zero)
(\BLT SCRATCHBASE DISPLAYBASE (UNFOLD \NP.DISPLAY WORDSPERPAGE))
(* Copy display from wherever boot put it)
(for I from 0 to (SUB1 \NP.DISPLAY)
do (\WRITEMAP (IPLUS SCRATCHVP I)
0 \VMAP.VACANT)
(\WRITEMAP (IPLUS \VP.DISPLAY I)
(IPLUS \RP.DISPLAY I)
\VMAP.CLEAN)) (* Display is now where hardware wants it, so enable
display)
(replace (IOPAGE DLDISPCONTROL) of \IOPAGE with 0))
(PROG ((RPSIZE (IDIFFERENCE NREALPAGES (SETQ \RPOFFSET -1)))
(FIRSTRP \RP.AFTERDISPLAY)
(FIRSTVP \VP.RPT)
RPTPAGES) (* Construct real page table in segment zero after the
display)
(SETQ RPTPAGES (FOLDHI (TIMES3 RPSIZE)
WORDSPERPAGE))
[COND
[(IGREATERP (IPLUS RPTPAGES FIRSTRP)
PAGESPERSEGMENT)
(* No space in bank zero, so put RPT in first segment after 2 megabytes, where the first "shadow" display bank
lives. Anyone mapped into there is out by now.)
(SETQ FIRSTRP 2MBPAGES)
(COND
((IGREATERP (IPLUS FIRSTVP RPTPAGES)
\VP.BUFFERS) (* Move virtual assignment backwards if necessary)
(SETQ FIRSTVP (IDIFFERENCE \VP.BUFFERS RPTPAGES]
((SETQ DEBUGGING (EQ (\GETBASE \InterfacePage 255)
7)) (* hack for staging this change)
(SETQ FIRSTRP (IDIFFERENCE NREALPAGES RPTPAGES))
(\DL.UNMAPPAGES (DLFPFROMRP FIRSTRP)
(DLFPFROMRP (IPLUS FIRSTRP RPTPAGES -1]
(for I from 0 to (SUB1 RPTPAGES)
do (* Assign pages to real page table now)
(\WRITEMAP (IPLUS FIRSTVP I)
(IPLUS FIRSTRP I)
\VMAP.CLEAN))
(SETQ \REALPAGETABLE (create POINTER
PAGE# ← FIRSTVP))
[\ZEROWORDS \REALPAGETABLE (\ADDBASE \REALPAGETABLE (SUB1 (TIMES3 RPSIZE]
(AND DEBUGGING (\DL.MARK.PAGES.UNAVAILABLE FIRSTRP (IPLUS FIRSTRP RPTPAGES -1)))
(SETQ \RPTSIZE RPSIZE))
[PROGN (* Fill in RPT with info from \FPTOVP)
(SETQ RPTBASE \REALPAGETABLE)
[for I from 0 to (SUB1 \NP.DISPLAY)
do (SETQ RPTBASE (\ADDBASE RPTBASE \RPTENTRYLENGTH))
(* Fill in Display pages)
(replace (RPT VP) of RPTBASE with (IPLUS \VP.DISPLAY I))
(replace (RPT FILEPAGE&LOCK) of RPTBASE with (LOGOR \PAGEMAPLOCKBIT
(DLFPFROMRP (IPLUS
\RP.TEMPDISPLAY I]
(\DL.MARK.PAGES.UNAVAILABLE \NP.DISPLAY \RP.IOPAGE)
(* Mark rest of segment zero plus Map and IOPAGE
unavailable)
(for NEXTBANK0 from 2MBPAGES by 2MBPAGES until (IGREATERP NEXTBANK0 NREALPAGES)
do (* Mark the shadow display bank pages unavailable)
(\DL.MARK.PAGES.UNAVAILABLE NEXTBANK0 (IPLUS NEXTBANK0 PAGESPERSEGMENT -1)))
(for I from (ADD1 \RP.IOPAGE) to (SUB1 NREALPAGES)
as [FPBASE ←(\ADDBASE \FPTOVP (DLFPFROMRP (ADD1 \RP.IOPAGE]
by (\ADDBASE FPBASE 1) as RPTBASE ←(fetch RPTRBASE of (RPTFROMRP (ADD1 \RP.IOPAGE)
))
by (\ADDBASE RPTBASE \RPTENTRYLENGTH)
do
(* Fill in rest of RPT from \FPTOVP. Could optimize this a little by special casing the area occupied by the
display, but this is simpler)
(COND
((fetch (RPT UNAVAILABLE) of RPTBASE))
((AND (fetch FPOCCUPIED of FPBASE)
[NOT (fetch (VMEMFLAGS VACANT) of (\READFLAGS (SETQ VP
(fetch FPVIRTUALPAGE
of FPBASE]
(EQ I (\READRP VP)))
(* There is a VP assigned to this filepage, and it is still there. False for display that got moved and any real
pages that didn't get filled)
(replace (RPT VP) of RPTBASE with VP)
(replace (RPT FILEPAGE) of RPTBASE with (DLFPFROMRP I))
(replace (RPT LOCKED) of RPTBASE with (fetch FPLOCKED of FPBASE)))
(T (replace (RPT EMPTY) of RPTBASE with T]
(PROGN (* Touch up RPT with the exceptions)
(SETQ RPTBASE (fetch RPTRBASE of (RPTFROMRP IFPAGERP)))
(* Interface Page)
(replace (RPT VP) of RPTBASE with \VP.IFPAGE)
(replace (RPT FILEPAGE&LOCK) of RPTBASE with (LOGOR \PAGEMAPLOCKBIT \FP.IFPAGE))
(replace (RPT UNAVAILABLE) of (fetch RPTRBASE of (RPTFROMRP IOCBRP)) with T)
(* \IOCBPAGE)
(\DL.MARK.PAGES.UNAVAILABLE FIRSTBUFFERRP (SUB1 FIRSTUSEFULRP))
(* buffer pages unavailable to swapper)
)
(PROG ((LASTEMPTY \REALPAGETABLE)
(LASTUSED (\ADDBASE \REALPAGETABLE 1))
LASTUSEDRP) (* Chain RPT pages together)
(SETQ RPTBASE (fetch RPTRBASE of (RPTFROMRP \RP.IOPAGE)))
[for I from (ADD1 \RP.IOPAGE) to (SUB1 NREALPAGES)
do (SETQ RPTBASE (\ADDBASE RPTBASE \RPTENTRYLENGTH))
(COND
((fetch (RPT UNAVAILABLE) of RPTBASE))
((fetch (RPT EMPTY) of RPTBASE)
(replace (RPT NEXTRP) of LASTEMPTY with (RPTFROMRP I))
(SETQ LASTEMPTY RPTBASE))
(T (replace (RPT NEXTRP) of LASTUSED with (RPTFROMRP I))
(SETQ LASTUSED RPTBASE)
(SETQ LASTUSEDRP I] (* Finally, link the end of empty chain to front of in
use chain)
(replace (RPT NEXTRP) of LASTEMPTY with (fetch (RPT NEXTRP) of (\ADDBASE
\REALPAGETABLE 1)))
(replace (IFPAGE RPTLAST) of \InterfacePage with (RPTFROMRP LASTUSEDRP))
(replace (RPT UNAVAILABLE) of \REALPAGETABLE with T)
(* Dummy first entry)
)
(PROG ((NBUFFERS (IDIFFERENCE FIRSTUSEFULRP FIRSTBUFFERRP)))
(* Allocate buffers)
(for I from 0 to (SUB1 NBUFFERS) do (\WRITEMAP (IPLUS \VP.BUFFERS I)
(IPLUS FIRSTBUFFERRP I)
\VMAP.CLEAN))
(\DL.ASSIGNBUFFERS (create POINTER
PAGE# ← \VP.BUFFERS)
NBUFFERS])
(\DL.UNMAPPAGES
[LAMBDA (FIRSTFP LASTFP) (* bvm: "14-Jan-84 14:20")
(* * At initialization time, unmap anything that originally lived in filepages FIRSTFP thru LASTFP)
(for FP from FIRSTFP to LASTFP as (FPBASE ←(\ADDBASE \FPTOVP FIRSTFP)) by (\ADDBASE FPBASE 1)
when (fetch FPOCCUPIED of FPBASE) do (\WRITEMAP (fetch FPVIRTUALPAGE of FPBASE)
0 \VMAP.VACANT])
(\DL.MARK.PAGES.UNAVAILABLE
[LAMBDA (FIRSTRP LASTRP) (* bvm: "14-Jan-84 14:32")
(for I from FIRSTRP to LASTRP as (RPTBASE ←(fetch RPTRBASE of (RPTFROMRP FIRSTRP)))
by (\ADDBASE RPTBASE \RPTENTRYLENGTH) do (replace (RPT UNAVAILABLE) of RPTBASE with T])
(\DL.ASSIGNBUFFERS
[LAMBDA (BASE NPAGES) (* bvm: "12-JUL-83 17:13")
(PROGN (* Allocate a page to hold name and password, and
perhaps other ephemeral things)
(\ZEROWORDS BASE (\ADDBASE BASE (SUB1 WORDSPERPAGE)))
(replace (IFPAGE UserNameAddr) of \InterfacePage with (\LOLOC (\ADDBASE BASE 1)))
(replace (IFPAGE UserPswdAddr) of \InterfacePage with (\LOLOC (\ADDBASE BASE 33)))
(SETQ BASE (\ADDBASE BASE WORDSPERPAGE))
(add NPAGES -1))
(PROGN (* Assign swap buffer)
(SETQ \EMBUFBASE BASE)
(SETQ \EMBUFVP (fetch (POINTER PAGE#) of BASE))
(SETQ \EMBUFRP (\READRP \EMBUFVP))
(SETQ BASE (\ADDBASE BASE WORDSPERPAGE))
(add NPAGES -1))
(PROGN (* Assign ether buffers)
(replace (IFPAGE MDSZoneLength) of \InterfacePage with (UNFOLD 2 WORDSPERPAGE))
(replace (IFPAGE MDSZone) of \InterfacePage with (\LOLOC BASE))
(SETQ BASE (\ADDBASE BASE (UNFOLD 2 WORDSPERPAGE)))
(SETQ \TELERAIDBUFFER BASE)
(SETQ BASE (\ADDBASE BASE WORDSPERPAGE))
(add NPAGES -3))
(PROGN (* Divvy up buffer space)
(SETQ \#SWAPBUFFERS (SETQ \#EMUBUFFERS NPAGES))
(SETQ \#DISKBUFFERS 0)
(SETQ \EMUSWAPBUFFERS (SETQ \EMUBUFFERS BASE])
)
(DEFINEQ
(\PAGEFAULT
[LAMBDA (PTR) (* bvm: " 1-APR-83 15:30")
(\CLOCK0 (LOCF (fetch SWAPTEMP0 of \MISCSTATS))) (* Note time of start)
(PROG ((VP (fetch (POINTER PAGE#) of PTR))
FLAGS FILEPAGE)
(COND
((fetch (VP INVALID) of VP) (* Map out of bounds on Dolphin always produces -1 as
the vp. Don't know about other machines)
(\MP.ERROR \MP.MOB "Page Fault: Map out of bounds" (AND (NEQ VP 177777Q)
PTR)
T))
([NOT (fetch (VMEMFLAGS VACANT) of (SETQ FLAGS (\READFLAGS VP]
(\MP.ERROR \MP.RESIDENT "Fault on resident page" PTR T))
((ZEROP (SETQ FILEPAGE (\LOOKUPPAGEMAP VP)))
(\INVALIDADDR PTR))
(T (COND
((EQ (\HILOC PTR)
\STACKHI) (* should never happen. For debugging)
(\MP.ERROR \MP.STACKFAULT "Fault on stack" PTR T)))
(\LOADVMEMPAGE VP FILEPAGE)))
[\BOXIPLUS (LOCF (fetch SWAPWAITTIME of \MISCSTATS))
(\BOXIDIFFERENCE (\CLOCK0 (LOCF (fetch SWAPTEMP1 of \MISCSTATS)))
(LOCF (fetch SWAPTEMP0 of \MISCSTATS]
(* Count the time used.)
(RETURN PTR])
(\INVALIDADDR
[LAMBDA (ADDR) (* bvm: " 6-AUG-83 22:25")
(\MP.ERROR \MP.INVALIDADDR "Invalid address" ADDR T])
(\INVALIDVP
[LAMBDA (VP) (* bvm: " 6-AUG-83 22:25")
(\MP.ERROR \MP.INVALIDVP "Invalid VP" VP])
(\FLUSHPAGE
[LAMBDA (RPTINDEX FROMFLUSHVM) (* bvm: " 7-Apr-84 17:20")
(* * Write out real page RPTINDEX if it is dirty.)
(PROG ((RPTR (fetch RPTRBASE of RPTINDEX))
VP FP NEWFP)
(COND
([AND (fetch (RPT OCCUPIED) of RPTR)
(fetch (VMEMFLAGS DIRTY) of (\READFLAGS (SETQ VP (fetch (RPT VP) of RPTR]
(* Yes, page is dirty)
(SETQ FP (fetch (RPT FILEPAGE) of RPTR))
[COND
[(AND \VMEM.PURE.LIMIT (NOT FROMFLUSHVM)) (* Don't sully vmem; write page out beyond the original
end of vmem)
(COND
((ILEQ FP \VMEM.PURE.LIMIT)
(COND
((fetch (RPT LOCKED) of RPTR)
(\MP.ERROR \MP.WRITING.LOCKED.PAGE)))
(SETQ NEWFP (add (fetch NActivePages of \InterfacePage)
1))
(COND
((IGREATERP NEWFP \MAXFILEPAGE)
(\MP.ERROR \MP.VMEMTOOLONG "Virtual memory backing file is full (8MB)")))
(\PUTBASE (.PAGEMAPBASE. VP)
0 NEWFP)
(\PUTBASE \FPTOVP NEWFP VP)
(\PUTBASE \FPTOVP FP \NO.VMEM.PAGE)
(replace (RPT FILEPAGE) of RPTR with (SETQ FP NEWFP]
((EQ (fetch (IFPAGE Key) of \InterfacePage)
\IFPValidKey)
(replace (IFPAGE Key) of \InterfacePage with (LOGNOT16 \IFPValidKey))
(* Invalidate vmem and write out the Interface page)
(SETQ \DIRTYPAGEHINT 0) (* So that the dirty page background writer wakes up)
(PROG ((IFVP (fetch (POINTER PAGE#) of \InterfacePage)))
(\TRANSFERPAGE IFVP \FirstVmemBlock (RPTFROMRP (\READRP IFVP))
T NIL] (* Write it out)
(COND
((IGREATERP \DIRTYPAGEHINT 0)
(add \DIRTYPAGEHINT -1)))
(\TRANSFERPAGE VP FP RPTINDEX T NIL])
(\LOADVMEMPAGE
[LAMBDA (VPAGE FILEPAGE NEWPAGEFLG SPECIALRP DONTMOVETOPFLG)
(* bvm: "31-MAR-83 15:07")
(COND
((IGREATERP \PAGEFAULTCOUNTER \UPDATECHAINFREQ)
(\UPDATECHAIN)))
(add \PAGEFAULTCOUNTER 1)
(PROG ((PREVRP (\SELECTREALPAGE (fetch FILEPAGEONLY of FILEPAGE)))
RPTINDEX RPTRBASE)
(SETQ RPTINDEX (fetch (RPT NEXTRP) of PREVRP))
(SETQ RPTRBASE (fetch RPTRBASE of RPTINDEX))
(COND
((NOT DONTMOVETOPFLG)
(replace (RPT NEXTRP) of PREVRP with (fetch (RPT NEXTRP) of RPTRBASE))
(* Splice RPTINDEX out of chain)
(replace (RPT NEXTRP) of (fetch RPTRBASE of (fetch (IFPAGE RPTLAST) of \InterfacePage))
with RPTINDEX) (* Put new page at end of chain)
(replace (IFPAGE RPTLAST) of \InterfacePage with RPTINDEX)
(replace (RPT NEXTRP) of RPTRBASE with 0)))
[COND
(SPECIALRP (* Must actually put FILEPAGE into special RP, and thus
move old contents of SPECIALRP into RPTINDEX)
(PROG ((SRINDEX (RPTFROMRP SPECIALRP))
SRPTR SVP NEWFLAGS) (* SPECIALRP is a "real page", while RPTINDEX is an
index into the real page table)
(SETQ SRPTR (fetch RPTRBASE of SRINDEX))
(SETQ SVP (fetch (RPT VP) of SRPTR))
(replace (RPT VP) of RPTRBASE with SVP)
(* Copy info about old occupants of SPECIALRP into
selected RP)
(replace (RPT FILEPAGE&LOCK) of RPTRBASE with (fetch (RPT FILEPAGE&LOCK)
of SRPTR))
(COND
((fetch (RPT OCCUPIED) of SRPTR)
(* THERE WAS ACTUALLY A PAGE THERE)
(SETQ NEWFLAGS (\READFLAGS SVP))
(\WRITEMAP \EMBUFVP (RPFROMRPT RPTINDEX)
0) (* Map buffer to target page)
(\MOVEPAGE \EMBUFVP SVP) (* MOVE DATA TO BUFFER PAGE)
(\WRITEMAP \EMBUFVP \EMBUFRP 0)
(* Restore buffer to its proper page)
(\WRITEMAP SVP (RPFROMRPT RPTINDEX)
NEWFLAGS) (* Set flags for page)
))
(SETQ RPTINDEX SRINDEX)
(SETQ RPTRBASE SRPTR] (* Fill in new RPTINDEX with appropriate data)
(replace (RPT VP) of RPTRBASE with VPAGE)
(replace (RPT FILEPAGE&LOCK) of RPTRBASE with FILEPAGE)
(* This sets both FILEPAGEONLY and LOCKEDP)
(\TRANSFERPAGE VPAGE (fetch FILEPAGEONLY of FILEPAGE)
RPTINDEX NIL NEWPAGEFLG])
(\LOOKUPPAGEMAP
[LAMBDA (VP) (* bvm: "13-OCT-82 15:21")
(* Returns the pagemap entry for VP, which is expected to be in bounds. High bit of result is the lock bit.
Zero denotes absence)
(PROG [(PRIMENTRY (\GETBASE \PageMapTBL (fetch (VP PRIMARYKEY) of VP]
(RETURN (COND
((EQ PRIMENTRY \EMPTYPMTENTRY)
0)
(T (\GETBASE \PAGEMAP (IPLUS PRIMENTRY (fetch (VP SECONDARYKEY) of VP])
(\MARKPAGEVACANT
[LAMBDA (RPTR) (* bvm: " 8-APR-82 16:06")
(* * Marks the real page in this pagemap table entry VACANT)
(CHECK (NOT \INTERRUPTABLE))
(\WRITEMAP (fetch (RPT VP) of RPTR)
0 \VMAP.VACANT)
(replace (RPT EMPTY) of RPTR with T])
(\SELECTREALPAGE
[LAMBDA (NEWFP) (* bvm: " 7-Apr-84 17:20")
(* Selects a real page, flushing it if necessary, and returns the pagenumber of the PREVIOUS page in the chain, so
it can be easily spliced out. NEWFP, if supplied, is the filepage that will be read into here.
This might influence page choice by minimizing seek time)
(PROG ((TRIES 0)
(CNTR \MAXCLEANPROBES)
(DISTANCE \MINSHORTSEEK)
LAST RP RPTR FLAGS)
RETRY
(SETQ LAST \REALPAGETABLE)
(RETURN (until (EQ (SETQ RP (fetch (RPT NEXTRP) of LAST))
\PAGETABLESTOPFLG)
do (SETQ RPTR (fetch RPTRBASE of RP))
[COND
((fetch (RPT EMPTY) of RPTR)
(RETURN LAST))
((NOT (fetch (RPT OCCUPIED) of RPTR))
(\MP.ERROR \MP.CHAIN.UNAVAIL "UNAVAILABLE page on Chain"))
([AND (NOT (fetch (RPT LOCKED) of RPTR))
(NOT (fetch (VMEMFLAGS REFERENCED)
of (SETQ FLAGS (\READFLAGS (fetch (RPT VP) of RPTR]
(* Page is unlocked and unreferenced, so is good
candidate for flushing)
(COND
([OR (NOT (fetch (VMEMFLAGS DIRTY) of FLAGS))
(COND
((SELECTQ \VMEM.INHIBIT.WRITE
(NIL T)
(NEW (* Only allowed to write old pages, since new pages
might just have to get moved a second time)
(ILEQ (fetch (RPT FILEPAGE) of RPTR)
\VMEM.PURE.LIMIT))
(PROGN (* We are forbidden from writing any page)
NIL))
(COND
((OR (ILEQ CNTR 0)
(NULL NEWFP)
(ILESSP (IABS (IDIFFERENCE (fetch (RPT FILEPAGE)
of RPTR)
NEWFP))
DISTANCE))
(* Page is near replacement, or we have given up trying
for closeness)
T)
(T (* Page is too far away from replacement page)
(SETQ CNTR (SUB1 CNTR))
[COND
((ILESSP DISTANCE \MAXSHORTSEEK)
(* Get more liberal)
(SETQ DISTANCE (LLSH DISTANCE 1]
NIL]
(\FLUSHPAGE RP)
(\MARKPAGEVACANT RPTR)
(RETURN LAST]
(SETQ LAST RPTR)
finally (* Couldn't find an unreffed page because all pages were
touched since last \UPDATECHAIN.
Do another, which clears ref bits, and try again)
(COND
((EQ TRIES 0)
(SETQ TRIES 1)
(\UPDATECHAIN)
(GO RETRY))
((AND (EQ TRIES 1)
\VMEM.INHIBIT.WRITE)
(SETQ \VMEM.INHIBIT.WRITE)
(COND
((NEQ \MACHINETYPE \DANDELION)
(RAID
"No clean vmem pages to reuse, must write one. ↑N to continue")))
(GO RETRY))
(T (\MP.ERROR \MP.SELECTLOOP "Loop in \SELECTREALPAGE"])
(\SPECIALRP
[LAMBDA (VP) (* bvm: "29-MAR-83 17:43")
(* for \DANDELION, some virtual pages must be mapped
into special real pages. This function returns the
corresponding real page)
(COND
((AND (IGEQ VP \VP.STACK)
(ILESSP VP (IPLUS \VP.STACK PAGESPERSEGMENT)))
(IPLUS \RP.STACK (IDIFFERENCE VP \VP.STACK])
(\TRANSFERPAGE
[LAMBDA (VP FILEPAGE RPTINDEX WRITE? NEWPAGE?) (* bvm: "31-MAR-83 14:55")
(* Transfers virtual page VP between page FILEPAGE of the vmem and real page RPTINDEX. WRITE? indicates direction
of transfer. If NEWPAGE?, then page does not exist on file, and is simply cleared)
(PROG (NEWFLAGS)
(COND
(WRITE? (FLIPCURSORBAR 17Q))
(T (FLIPCURSORBAR 0)))
(SETQ NEWFLAGS (COND
(NEWPAGE? \VMAP.DIRTY)
(WRITE? (LOGAND (\READFLAGS VP)
(LOGNOT16 \VMAP.DIRTY)))
(T 0)))
(\INSUREVMEMFILE FILEPAGE FILEPAGE) (* Make sure vmem knows about page.
This may extend the file)
(COND
((AND WRITE? (fetch (RPT LOCKED) of (fetch RPTRBASE of RPTINDEX)))
(* Writing a locked page: can't diddle map, because
others might die, so do this in the straightforward way)
(\MOVEPAGE \EMBUFVP VP) (* Copy page into buffer, then write the buffer out)
(\ACTONVMEMFILE FILEPAGE \EMBUFBASE 1 T)
(SETQ \LASTACCESSEDVMEMPAGE FILEPAGE))
((NOT NEWPAGE?) (* Map the buffer page into the target real page,
read/write the page, then set the map back)
(\WRITEMAP VP 0 \VMAP.VACANT) (* Unmap VP so that we don't have two virtual pages
pointing at same real page)
(\WRITEMAP \EMBUFVP (RPFROMRPT RPTINDEX)
0) (* Map buffer to target page)
(\ACTONVMEMFILE FILEPAGE \EMBUFBASE 1 WRITE?)
(* Do the i/o)
(\WRITEMAP \EMBUFVP \EMBUFRP 0) (* Restore buffer to its proper page)
(SETQ \LASTACCESSEDVMEMPAGE FILEPAGE)))
(\WRITEMAP VP (RPFROMRPT RPTINDEX)
NEWFLAGS) (* Set flags for page)
(COND
(NEWPAGE? (* Not on file yet, so clear it.
Couldn't do this sooner because the flags weren't set)
(\ZEROPAGE VP)))
(COND
(WRITE? (FLIPCURSORBAR 17Q)
(\BOXIPLUS (LOCF (fetch SWAPWRITES of \MISCSTATS))
1))
(T (FLIPCURSORBAR 0)
(\BOXIPLUS (LOCF (fetch PAGEFAULTS of \MISCSTATS))
1])
(\MOVEPAGE
[LAMBDA (TOVP FROMVP) (* bvm: "27-JUN-82 15:56")
(\BLT (create POINTER
PAGE# ← TOVP)
(create POINTER
PAGE# ← FROMVP)
WORDSPERPAGE])
(\ZEROPAGE
[LAMBDA (VP) (* bvm: "18-JUL-82 16:15")
(bind (BASE ←(create POINTER
PAGE# ← VP))
from 1 to CELLSPERPAGE do (* Do two at a time by storing NILs)
(\PUTBASEPTR BASE 0 NIL)
(SETQ BASE (\ADDBASE BASE WORDSPERCELL])
(\UPDATECHAIN
[LAMBDA NIL (* bvm: "31-MAR-83 14:56")
(* Sorts the page chain by reference bit)
(CHECK (NOT \INTERRUPTABLE))
(PROG ((RPTINDEX (fetch (RPT NEXTRP) of \REALPAGETABLE))
(CHAIN0 \REALPAGETABLE)
(CHAIN1 \EMBUFBASE)
RPTR VP FLAGS HEAD1)
(SETQ HEAD1 CHAIN1)
(* HEAD1 = CHAIN1 is just a holding cell for the second Chain we temporarily create inside here.
Has to be something that doesn't fault, so use the swap buffer for it)
(replace (RPT NEXTRP) of CHAIN0 with \PAGETABLESTOPFLG)
(replace (RPT NEXTRP) of CHAIN1 with \PAGETABLESTOPFLG)
(do (SETQ RPTR (fetch RPTRBASE of RPTINDEX))
(SETQ VP (fetch (RPT VP) of RPTR))
[SETQ FLAGS (COND
((fetch (RPT EMPTY) of RPTR)
0)
(T (\READFLAGS VP]
(COND
((OR (fetch (VMEMFLAGS REFERENCED) of FLAGS)
(fetch (RPT LOCKED) of RPTR)) (* Page referenced or locked, put on CHAIN1)
(\WRITEMAP VP (RPFROMRPT RPTINDEX)
(LOGAND FLAGS (LOGNOT16 \VMAP.REF)))
(* Turn off ref bit)
(replace (RPT NEXTRP) of CHAIN1 with RPTINDEX)
(SETQ CHAIN1 RPTR))
(T (* Page was not referenced recently, put on CHAIN0)
(replace (RPT NEXTRP) of CHAIN0 with RPTINDEX)
(SETQ CHAIN0 RPTR)))
(SETQ RPTINDEX (fetch (RPT NEXTRP) of RPTR))
(* Look at next page in old chain)
repeatuntil (EQ RPTINDEX \PAGETABLESTOPFLG))
(replace (RPT NEXTRP) of CHAIN1 with \PAGETABLESTOPFLG)
(* End of the line)
(replace (RPT NEXTRP) of CHAIN0 with (fetch (RPT NEXTRP) of HEAD1))
(* Link end of CHAIN0 to beginning of CHAIN1)
(replace (IFPAGE RPTLAST) of \InterfacePage
with (IQUOTIENT (IDIFFERENCE (LOLOC (COND
((EQ HEAD1 CHAIN1)
(* Nothing on CHAIN1 ??!!)
CHAIN0)
(T CHAIN1)))
(LOLOC \REALPAGETABLE))
3)) (* Pointer to end of complete chain)
(SETQ \DIRTYPAGECOUNTER (SETQ \PAGEFAULTCOUNTER 0])
)
(DEFINEQ
(\NEWPAGE
[LAMBDA (BASE NOERROR LOCK?) (* bvm: " 1-APR-83 15:22")
(* * Creates and returns a new page located at virtual addr BASE)
(UNINTERRUPTABLY
(PROG (FILEPAGE)
[COND
[(NOT (SETQ FILEPAGE (\MISCAPPLY*(FUNCTION \DONEWPAGE)
BASE LOCK?))) (* Failed, page exists)
(COND
((NOT NOERROR)
(\MP.ERROR \MP.NEWPAGE "Attempt to allocate already existing page" BASE T)))
(COND
(LOCK? (\LOCKPAGES BASE 1]
(T (COND
((SETQ FILEPAGE (\MAYBE.EXTENDVMEMFILE (IPLUS FILEPAGE \MINVMEMSPAREPAGES)))
(\DISKERROR FILEPAGE]
(RETURN BASE)))])
(\DONEWPAGE
[LAMBDA (BASE LOCK?) (* bvm: " 6-AUG-83 22:23")
(* * Allocates new page at BASE, locking it if LOCK? is true. Returns vmemfile page# on success, NIL if page
already exists. Must be run in safe context! because it can cause vmem activity)
(AND \DOFAULTINIT (\FAULTINIT)) (* Only an issue when INIT.SYSOUT starts.
Perhaps there is a better place to put this)
(PROG ((VP (fetch (POINTER PAGE#) of BASE))
MAPBASE FILEPAGE NEXTPM ERRCODE)
(RETURN (COND
((fetch (VP INVALID) of VP)
(\INVALIDVP VP)
NIL)
(T (SETQ MAPBASE (\GETBASE \PageMapTBL (fetch (VP PRIMARYKEY) of VP)))
(COND
((EQ MAPBASE \EMPTYPMTENTRY) (* Need to create a new second-level block)
(SETQ NEXTPM (fetch (IFPAGE NxtPMAddr) of \InterfacePage))
[COND
((EVENP NEXTPM WORDSPERPAGE) (* New page map page)
(OR (\DONEWPAGE (\ADDBASE \PAGEMAP NEXTPM)
T)
(RETURN (\MP.ERROR \MP.NEWMAPPAGE
"\DONEWPAGE failed to allocate new map page"]
(\PUTBASE \PageMapTBL (fetch (VP PRIMARYKEY) of VP)
NEXTPM)
(replace (IFPAGE NxtPMAddr) of \InterfacePage with (IPLUS NEXTPM
\PMblockSize))
(SETQ MAPBASE NEXTPM)))
[SETQ MAPBASE (\ADDBASE \PAGEMAP (IPLUS MAPBASE (fetch (VP SECONDARYKEY)
of VP]
(COND
((NEQ (\GETBASE MAPBASE 0)
0) (* Page exists)
(RETURN NIL)))
(SETQ FILEPAGE (add (fetch (IFPAGE NActivePages) of \InterfacePage)
1))
(replace (IFPAGE NDirtyPages) of \InterfacePage with FILEPAGE)
(* Currently a redundant field)
[COND
(LOCK? (SETQ FILEPAGE (\MAKESPACEFORLOCKEDPAGE VP FILEPAGE]
[AND \FPTOVP (\PUTBASE \FPTOVP FILEPAGE (COND
(LOCK? (LOGOR VP \PAGEMAPLOCKBIT))
(T VP]
(\PUTBASE MAPBASE 0 (COND
(LOCK? (SETQ FILEPAGE (LOGOR FILEPAGE \PAGEMAPLOCKBIT)))
(T FILEPAGE)))
(* (COND ((AND (IGEQ VP \VP.DISPLAY) (ILESSP VP (IPLUS \VP.DISPLAY PAGESPERSEGMENT))) (* display pages are not on
the chain, and if unmapped are otherwise unavailable) (\TRANSFERPAGE VP FILEPAGE (SETQ RP
(IPLUS \RP.DISPLAY (IDIFFERENCE VP \VP.DISPLAY))) NIL T) (* * now fix up RPT to point to this VP)
(SETQ MAPBASE (fetch RPTRBASE of (IDIFFERENCE RP \RPOFFSET))) (replace VP of MAPBASE with VP)
(replace FILEPAGE&LOCK of MAPBASE with FILEPAGE) (RETURN (fetch FILEPAGEONLY of FILEPAGE)))))
(\LOADVMEMPAGE VP FILEPAGE T (AND (EQ \MACHINETYPE \DANDELION)
(\SPECIALRP VP)))
(fetch FILEPAGEONLY of FILEPAGE])
(\MAKESPACEFORLOCKEDPAGE
[LAMBDA (VP FILEPAGE) (* bvm: " 4-AUG-83 14:24")
(* VP is a page to be locked, FILEPAGE its home. Returns a possibly new file page where VP will now live, after
having kicked the former resident of the new file page into VP's old FILEPAGE)
(COND
((NOT \FPTOVP) (* Old sysout)
FILEPAGE)
(T (PROG ((RP (\SPECIALRP VP))
DESIREDFP OLDVP FPBASE)
[SETQ DESIREDFP (COND
(RP (* Dlion has constraints about the real page, hence
about FP)
(DLFPFROMRP RP))
((AND (ILEQ FILEPAGE (fetch LastLockedFilePage of \InterfacePage))
(IGREATERP FILEPAGE (DLFPFROMRP \RP.TYPETABLE)))
(* Page is in a good place already.
It probably was once locked, then unlocked)
(RETURN FILEPAGE))
(T (* Put it after all the other locked pages)
(add (fetch LastLockedFilePage of \InterfacePage)
1]
(COND
((AND (fetch FPOCCUPIED of (SETQ FPBASE (\ADDBASE \FPTOVP DESIREDFP)))
(NEQ (SETQ OLDVP (fetch FPVIRTUALPAGE of FPBASE))
VP)) (* Someone else lives here, so move it out)
(COND
((fetch FPLOCKED of FPBASE)
(\MP.ERROR \MP.BADLOCKED "Locked page is in the way" OLDVP)))
(\MOVEVMEMFILEPAGE OLDVP DESIREDFP FILEPAGE)))
(RETURN DESIREDFP])
(\MOVEVMEMFILEPAGE
[LAMBDA (VP OLDFP NEWFP) (* bvm: " 3-AUG-83 22:26")
(PROG ((FLAGS (\READFLAGS VP))
RP)
(COND
((fetch (VMEMFLAGS VACANT) of FLAGS) (* Page not resident, so pull it in)
(\LOADVMEMPAGE VP OLDFP)
(SETQ FLAGS \VMAP.CLEAN)))
(\WRITEMAP VP (SETQ RP (\READRP VP))
(LOGOR FLAGS \VMAP.DIRTY)) (* Mark page dirty, so that it will eventually be
written to its new home)
(replace (RPT FILEPAGE) of (fetch RPTRBASE of (RPTFROMRP RP)) with NEWFP)
(* Tell RPT where VP now lives)
(\PUTBASE (.PAGEMAPBASE. VP)
0 NEWFP) (* Tell \PAGEMAP about it)
(\PUTBASE \FPTOVP NEWFP VP) (* ... and \FPTOVP)
])
(\NEWEPHEMERALPAGE
[LAMBDA (BASE NOERROR) (* bvm: "26-NOV-82 15:40")
(* * Creates and returns a new page located at virtual addr BASE, mapping it permanently into some real page but
leaving it out of the vmem file)
(\MISCAPPLY*(FUNCTION \DONEWEPHEMERALPAGE)
BASE NOERROR])
(\DONEWEPHEMERALPAGE
[LAMBDA (BASE NOERROR) (* bvm: " 6-AUG-83 22:24")
(* * Creates and returns a new page located at virtual addr BASE, mapping it permanently into some real page but
leaving it out of the vmem file)
(PROG ((VP (fetch (POINTER PAGE#) of BASE))
MAPBASE PREVRP RPTINDEX RPTR)
(RETURN (COND
((fetch (VP INVALID) of VP)
(\INVALIDVP VP)
NIL)
(T (SETQ MAPBASE (\GETBASE \PageMapTBL (fetch (VP PRIMARYKEY) of VP)))
(* First check that the page doesn't exist)
(COND
([OR [AND (NEQ MAPBASE \EMPTYPMTENTRY)
(NOT (ZEROP (\GETBASE \PAGEMAP (IPLUS MAPBASE (fetch (VP
SECONDARYKEY)
of VP]
(NOT (fetch (VMEMFLAGS VACANT) of (\READFLAGS VP]
(* Page is in the vmem already, so no hope)
(COND
((NOT NOERROR)
(\MP.ERROR \MP.NEWPAGE "Page already exists " BASE T)))
(RETURN BASE)))
(COND
((IGREATERP \PAGEFAULTCOUNTER \UPDATECHAINFREQ)
(\UPDATECHAIN)))
(add \PAGEFAULTCOUNTER 1)
(SETQ PREVRP (\SELECTREALPAGE)) (* Find a page to put this in)
(SETQ RPTINDEX (fetch (RPT NEXTRP) of PREVRP))
(SETQ RPTR (fetch RPTRBASE of RPTINDEX))
(replace (RPT NEXTRP) of PREVRP with (fetch (RPT NEXTRP) of RPTR))
(* Splice RPTINDEX out of chain)
(replace (RPT NEXTRP) of RPTR with 0)
(* Fill in new RPTINDEX with appropriate data)
(replace (RPT VP) of RPTR with \RPT.UNAVAILABLE)
(replace (RPT FILEPAGE&LOCK) of RPTR with VP)
(* For debugging only)
(FLIPCURSORBAR 0)
(\WRITEMAP VP (RPFROMRPT RPTINDEX)
\VMAP.DIRTY) (* Set flags for page)
(\ZEROPAGE VP) (* Clear new page)
(FLIPCURSORBAR 0)
(\BOXIPLUS (LOCF (fetch PAGEFAULTS of \MISCSTATS))
1)
BASE])
(\LOCKPAGES
[LAMBDA (BASE NPAGES) (* bvm: "26-NOV-82 15:17")
(* Needs to be done in safe stack context because might
cause vmem transfer)
(\MISCAPPLY*(FUNCTION \DOLOCKPAGES)
BASE NPAGES)
BASE])
(\DOLOCKPAGES
[LAMBDA (BASE NPAGES) (* bvm: "31-MAR-83 18:20")
(for I from 0 to (SUB1 NPAGES) bind (VP ←(fetch (POINTER PAGE#) of BASE))
FILEPAGE MAPBASE
do [COND
((fetch (VP INVALID) of VP)
(\INVALIDVP VP))
[(EQ (SETQ MAPBASE (\GETBASE \PageMapTBL (fetch (VP PRIMARYKEY) of VP)))
\EMPTYPMTENTRY)
(\INVALIDADDR (ADDBASE BASE (UNFOLD I WORDSPERPAGE]
(T [SETQ MAPBASE (\ADDBASE \PAGEMAP (IPLUS MAPBASE (fetch (VP SECONDARYKEY) of VP]
(SETQ FILEPAGE (\GETBASE MAPBASE 0))
(COND
((NOT (fetch (PAGEMAPENTRY LOCKEDP) of FILEPAGE))
(* Not locked yet)
[COND
((fetch VACANT of (\READFLAGS VP)) (* Bring locked page into core so we can move it if
necessary)
(\LOADVMEMPAGE VP (LOGOR FILEPAGE \PAGEMAPLOCKBIT)
NIL
(AND (EQ \MACHINETYPE \DANDELION)
(\SPECIALRP VP]
[COND
((NEQ FILEPAGE (SETQ FILEPAGE (\MAKESPACEFORLOCKEDPAGE VP FILEPAGE)))
(* Moving to a new page, so have to mark this locked page dirty so that it will eventually get written to its new
home)
(\WRITEMAP VP (\READRP VP)
(LOGOR \VMAP.DIRTY \VMAP.REF]
(AND \FPTOVP (\PUTBASE \FPTOVP FILEPAGE (LOGOR VP \PAGEMAPLOCKBIT)))
(\PUTBASE MAPBASE 0 (SETQ FILEPAGE (LOGOR FILEPAGE \PAGEMAPLOCKBIT)))
(* Set lock bit in page map)
(replace (RPT FILEPAGE&LOCK) of (fetch RPTRBASE of (RPTFROMRP (\READRP VP)))
with FILEPAGE]
(add VP 1])
(\TEMPLOCKPAGES
[LAMBDA (BASE NPAGES) (* bvm: "31-MAR-83 15:01")
(* "Temporarily" locks BASE for NPAGES, i.e. ensures that the swapper will not move the pages.
Information vanishes at logout etc. This function must be locked because it manipulates the page table)
(while (IGREATERP NPAGES 0) bind (VP ←(fetch (POINTER PAGE#) of BASE))
RPTR
do (UNINTERRUPTABLY
(\TOUCHPAGE BASE) (* Touch page in case not resident)
(COND
((AND (NEQ (SETQ RPTR (\READRP VP))
0)
(EQ [fetch (RPT VP) of (SETQ RPTR (fetch RPTRBASE of (RPTFROMRP RPTR]
VP))
(replace (RPT LOCKED) of RPTR with T))
(T (HELP "Page table changed out from under me!" VP))))
(add VP 1)
(add NPAGES -1)
(SETQ BASE (\ADDBASE BASE WORDSPERPAGE])
(\TEMPUNLOCKPAGES
[LAMBDA (BASE NPAGES) (* bvm: "31-MAR-83 15:01")
(* Unlocks pages that were locked by \TEMPLOCKPAGES.
This function must be locked because it manipulates the
page table)
(while (IGREATERP NPAGES 0) bind (VP ←(fetch (POINTER PAGE#) of BASE))
RPTR
do (UNINTERRUPTABLY
(\TOUCHPAGE BASE) (* Touch page in case not resident.
Should only happen if page wasn't locked to begin with)
(COND
((AND (NEQ (SETQ RPTR (\READRP VP))
0)
(EQ [fetch (RPT VP) of (SETQ RPTR (fetch RPTRBASE of (RPTFROMRP RPTR]
VP))
(replace (RPT LOCKED) of RPTR with NIL))
(T (HELP "Page table changed out from under me!" VP))))
(add VP 1)
(add NPAGES -1)
(SETQ BASE (\ADDBASE BASE WORDSPERPAGE])
(\UNLOCKPAGES
[LAMBDA (BASE NPAGES) (* bvm: " 4-APR-83 12:00")
(* * Unlocks NPAGES virtual pages from BASE onward)
(UNINTERRUPTABLY
(for I from 0 to (SUB1 NPAGES) bind (VP ←(fetch (POINTER PAGE#) of BASE))
MAPBASE FILEPAGE
do [COND
((fetch (VP INVALID) of VP)
(\INVALIDVP VP))
[(EQ (SETQ MAPBASE (\GETBASE \PageMapTBL (fetch (VP PRIMARYKEY) of VP)))
\EMPTYPMTENTRY)
(\INVALIDADDR (\ADDBASE BASE (UNFOLD I WORDSPERPAGE]
(T [SETQ MAPBASE (\ADDBASE \PAGEMAP (IPLUS MAPBASE (fetch (VP SECONDARYKEY)
of VP]
(SETQ FILEPAGE (\GETBASE MAPBASE 0))
(COND
((fetch (PAGEMAPENTRY LOCKEDP) of FILEPAGE)
(* Yes, page was locked, so turn the bit off now)
(SETQ FILEPAGE (fetch (PAGEMAPENTRY FILEPAGEONLY) of FILEPAGE))
(\PUTBASE MAPBASE 0 FILEPAGE) (* Update pagemap, then update real page table)
(AND \FPTOVP (replace FPLOCKED of (\ADDBASE \FPTOVP FILEPAGE) with NIL))
(* Remove Lock bit in \FPTOVP)
(replace (RPT LOCKED) of (fetch RPTRBASE of (RPTFROMRP (\READRP VP)))
with NIL]
(add VP 1)))])
(\FLUSHVM
[LAMBDA NIL (* bvm: "12-JUL-83 16:55")
(* Writes out all dirty pages to vmem, making it
consistent. Returns NIL now, T if Bcpl starts up the
vmem)
(UNINTERRUPTABLY (* Write stuff out from a safe place)
(PROG1 (COND
((\MISCAPPLY*(FUNCTION \DOFLUSHVM)) (* Return from Bcpl startup. Need to rebuild the
context, since it was not written out consistently)
(SETQ \DOFAULTINIT T) (* Tell pagefault handler to initialize itself.
Want the initialization to happen in Fault context to
avoid stack overflow messiness)
(\CONTEXTSWITCH \FAULTFXP)
(for VAR in \SYSTEMCACHEVARS do (SET VAR NIL))
T))
(SETQ \DIRTYPAGEHINT 32767)))])
(\LOGOUT0
[LAMBDA (FAST) (* bvm: "29-MAR-83 18:06")
[COND
((NEQ (fetch MachineType of \InterfacePage)
\DANDELION) (* update alto clock)
(\BLT (EMADDRESS \RTCSECONDS)
(LOCF (fetch SECONDSCLOCK of \MISCSTATS))
(UNFOLD 3 WORDSPERCELL]
(UNINTERRUPTABLY
(OR (AND (OR (NOT FAST)
(AND (EQ FAST (QUOTE ?))
(NEQ (fetch (IFPAGE Key) of \InterfacePage)
\IFPValidKey)))
(\FLUSHVM))
(\LISPFINISH)))])
(\DOFLUSHVM
[LAMBDA NIL (* bvm: " 7-Apr-84 17:53")
(* * Write everything out in a resumable way. Value is NIL if returned from directly, T if from saved state.
Always invoked via \MISCAPPLY*)
(CHECK (NOT \INTERRUPTABLE)) (* NOTE: need stats gathering off in here.
Also avoid touching pages)
(PROG ((IFPVP (fetch (POINTER PAGE#) of \InterfacePage))
(SCRATCHBUF \EMUSWAPBUFFERS)
(SCRATCHVP (fetch (POINTER PAGE#) of \EMUSWAPBUFFERS))
IFPRPT)
(replace (IFPAGE MISCSTACKRESULT) of \InterfacePage with T)
(* This will make it look like we have returned from
BCPL if caller gets control from the saved state)
[COND
((EQ \MACHINETYPE \DANDELION) (* Mark all active stack pages dirty, since the
microcode doesn't)
(for VP from \VP.STACK to (IPLUS \VP.STACK (fetch HIBYTE of (fetch EndOfStack
of \InterfacePage)))
as RP from \RP.STACK do (\WRITEMAP VP RP (LOGOR \VMAP.REF \VMAP.DIRTY)))
(* Similarly, the GC table does not get marked dirty)
(for VP from \VP.GCTABLE to (IPLUS \VP.GCTABLE (SUB1 \NP.GCTABLE)) as RP from
\RP.GCTABLE
do (\WRITEMAP VP RP (LOGOR \VMAP.REF \VMAP.DIRTY]
[COND
(\VMEM.PURE.LIMIT (* Maintaining file consistency: move high water mark
up)
(COND
(VMEM.COMPRESS.FLG (\DOCOMPRESSVMEM)))
(SETQ \VMEM.PURE.LIMIT (fetch (IFPAGE NActivePages) of \InterfacePage]
(COND
((EQ (fetch (IFPAGE Key) of \InterfacePage)
\IFPValidKey)
(replace (IFPAGE Key) of \InterfacePage with (LOGNOT16 \IFPValidKey))
(* Invalidate vmem and write out the Interface page)
(\TRANSFERPAGE IFPVP \FirstVmemBlock (RPTFROMRP (\READRP IFPVP))
T NIL)))
(SETQ IFPRPT (RPTFROMRP (\READRP IFPVP)))
(for RPTINDEX from 0 to (SUB1 \RPTSIZE) do (\FLUSHPAGE RPTINDEX T) unless (EQ RPTINDEX
IFPRPT))
(replace (IFPAGE Key) of \InterfacePage with \IFPValidKey)
(\MOVEPAGE SCRATCHVP IFPVP) (* Make its current fx point at user context, i.e. the
\FLUSHVM frame)
(replace (IFPAGE CurrentFXP) of SCRATCHBUF with (fetch (IFPAGE MiscFXP) of \InterfacePage))
(\ACTONVMEMFILE (fetch FILEPAGEONLY of (\LOOKUPPAGEMAP IFPVP))
SCRATCHBUF 1 T) (* Write the page out from a safe place)
(RETURN NIL])
(\RELEASEWORKINGSET
[LAMBDA NIL (* bvm: "31-MAR-83 15:03")
(COND
((\FLUSHVM) (* Returning from Lisp startup)
T)
(T (* Unmap any unlocked page)
(for RPTINDEX from 0 to (SUB1 \RPTSIZE) bind RPTR
when (AND (fetch (RPT OCCUPIED) of (SETQ RPTR (fetch RPTRBASE of RPTINDEX)))
(NOT (fetch (RPT LOCKED) of RPTR)))
do (\WRITEMAP (fetch (RPT VP) of RPTR)
(RPFROMRPT RPTINDEX)
\VMAP.VACANT)
(replace (RPT EMPTY) of RPTR with T])
(\WRITEDIRTYPAGE
[LAMBDA (MINDIRTY) (* bvm: "20-Apr-84 15:32")
(COND
((OR (NEQ (fetch (IFPAGE Key) of \InterfacePage)
\IFPValidKey)
\VMEM.PURE.LIMIT)
(PROG ((RPTR (OR \LASTDIRTYSCANPTR \REALPAGETABLE))
(NUMDIRTY (OR \LASTDIRTYCNT 0))
(CNT \MAXDIRTYSCANCOUNT)
RP FP FLAGS)
[COND
((AND (NULL \LASTDIRTYSCANPTR)
(IGREATERP (IPLUS (add \DIRTYPAGECOUNTER 1)
\PAGEFAULTCOUNTER)
\UPDATECHAINFREQ)) (* Take this time to update the page chain instead)
(RETURN (UNINTERRUPTABLY
(\MISCAPPLY*(FUNCTION \UPDATECHAIN)))]
(OR MINDIRTY (SETQ MINDIRTY 1))
LP [COND
[(EQ (SETQ RP (fetch (RPT NEXTRP) of RPTR))
\PAGETABLESTOPFLG) (* Hit end of chain. Write out what we found if enough
were dirty)
(COND
((AND (IGEQ NUMDIRTY MINDIRTY)
(NOT (ZEROP NUMDIRTY))
(SETQ RP \LASTDIRTYFOUND))
(GO GOTPAGE))
(T (SETQ \LASTDIRTYSCANPTR (SETQ \LASTDIRTYCNT (SETQ \LASTDIRTYFOUND NIL)))
[COND
((AND (NEQ NUMDIRTY 0)
(ILESSP \DIRTYSEEKMAX (LRSH MAX.SMALL.INTEGER 1)))
(* Failed because page not close enough, so widen the
tolerance)
(SETQ \DIRTYSEEKMAX (LLSH \DIRTYSEEKMAX 1]
(RETURN]
((fetch (RPT EMPTY) of (SETQ RPTR (fetch RPTRBASE of RP)))
(* Page is empty. Should never happen if key is valid)
(RETURN))
((NOT (fetch (RPT LOCKED) of RPTR)) (* Don't bother writing out locked pages, since they
don't help us in our swapping quest)
(SETQ FLAGS (\READFLAGS (fetch (RPT VP) of RPTR)))
(COND
((NOT (fetch (VMEMFLAGS DIRTY) of FLAGS))
(* Page not dirty; skip)
)
[(PROGN (SETQ FP (fetch (RPT FILEPAGE) of RPTR))
(IGREATERP (IABS (IDIFFERENCE (COND
((AND \VMEM.PURE.LIMIT (ILESSP FP
\VMEM.PURE.LIMIT))
(* We'd have to write page to a new place, not here)
(fetch (IFPAGE NActivePages)
of \InterfacePage))
(T FP))
\LASTACCESSEDVMEMPAGE))
\DIRTYSEEKMAX)) (* Page too far away, don't write it)
(COND
((fetch (VMEMFLAGS REFERENCED) of FLAGS)
(* but still count it)
(add NUMDIRTY 1]
((fetch (VMEMFLAGS REFERENCED) of FLAGS)
(* Page dirty but referenced.
Note it, but keep looking for a better one)
(COND
((ZEROP NUMDIRTY)
(SETQ \LASTDIRTYFOUND RP)))
(add NUMDIRTY 1))
(T (* Dirty, not referenced: do it)
(GO GOTPAGE]
(COND
((ZEROP (add CNT -1)) (* Scanned for long enough; don't lock user out)
(SETQ \LASTDIRTYSCANPTR RPTR)
(SETQ \LASTDIRTYCNT NUMDIRTY)
(RETURN)))
(GO LP)
GOTPAGE
(UNINTERRUPTABLY
(SETQ \LASTDIRTYSCANPTR (SETQ RPTR (fetch RPTRBASE of RP)))
(* Keep traveling pointer)
(SETQ \LASTDIRTYCNT (SETQ \LASTDIRTYFOUND NIL))
(COND
((ILEQ (IABS (IDIFFERENCE (fetch (RPT FILEPAGE) of RPTR)
\LASTACCESSEDVMEMPAGE))
\DIRTYSEEKMAX) (* Could fail if swapping since the selection has moved
the disk arm too far)
(\MISCAPPLY*(FUNCTION \WRITEDIRTYPAGE1)
RP RPTR)))
(SETQ \DIRTYSEEKMAX \MAXSHORTSEEK))
(RETURN T])
(\WRITEDIRTYPAGE1
[LAMBDA (RP RPTR) (* bvm: "20-APR-82 15:21")
(* Write out buffer RP. This fn is locked and
uninterruptable)
(COND
([AND (NOT (fetch (RPT LOCKED) of RPTR))
(fetch (VMEMFLAGS DIRTY) of (\READFLAGS (fetch (RPT VP) of RPTR]
(* Verify that the page is still a candidate, so
previous loop could be interruptable)
(\FLUSHPAGE RP])
(\COUNTREALPAGES
[LAMBDA (TYPE) (* bvm: " 7-Dec-83 15:11")
(SELECTQ TYPE
[(DIRTY REF)
(PROG [(FLAGBITS (COND
((EQ TYPE (QUOTE DIRTY))
\VMAP.DIRTY)
(T \VMAP.REF]
(RETURN (NPAGESMACRO (NEQ (LOGAND (\READFLAGS VP)
FLAGBITS)
0]
(LOCKED (NPAGESMACRO (fetch (RPT LOCKED) of RPTR)))
(\ILLEGAL.ARG TYPE])
)
(DEFINEQ
(\DOCOMPRESSVMEM
[LAMBDA NIL (* bvm: " 7-Apr-84 17:53")
(* * Called underneath \DOFLUSHVM to write the pages above the high water mark back to the places vacated below
that mark)
(PROG ((EMPTYFP (DLFPFROMRP \RP.GCTABLE))
(LASTFP (fetch NActivePages of \InterfacePage))
(OLDVIW \VMEM.INHIBIT.WRITE)
VP)
[COND
((NULL OLDVIW) (* Encourage \SELECTREALPAGE to select only "old" file
pages for displacement, so that we don't needlessly
write the same page twice)
(SETQ \VMEM.INHIBIT.WRITE (QUOTE NEW]
LP (COND
((IGEQ EMPTYFP LASTFP)
(SETQ \VMEM.INHIBIT.WRITE OLDVIW)
(RETURN)))
[COND
((EQ (\GETBASE \FPTOVP EMPTYFP)
\NO.VMEM.PAGE)
(while (EQ (SETQ VP (\GETBASE \FPTOVP LASTFP))
\NO.VMEM.PAGE)
do (SETQ LASTFP (SUB1 LASTFP)))
(\MOVEVMEMFILEPAGE VP LASTFP EMPTYFP)
(replace NActivePages of \InterfacePage with (SETQ LASTFP (SUB1 LASTFP]
(add EMPTYFP 1)
(GO LP])
(VMEM.PURE.STATE
[LAMBDA FLG (* bvm: " 7-Apr-84 16:59")
(PROG1 (NOT (NULL \VMEM.PURE.LIMIT))
(COND
((IGREATERP FLG 0)
(* Set \VMEM.PURE.LIMIT appropriately. If turning on, and it wasn't on before, set it to -1 so that it takes
effect only at the next FLUSHVM)
(SETQ \VMEM.PURE.LIMIT (AND (ARG FLG 1)
(OR \VMEM.PURE.LIMIT (SETQ \VMEM.PURE.LIMIT -1])
)
(RPAQ? \UPDATECHAINFREQ 100)
(RPAQ? \PAGEFAULTCOUNTER 0)
(RPAQ? \DIRTYPAGECOUNTER 0)
(RPAQ? \DIRTYPAGEHINT 0)
(RPAQ? \LASTACCESSEDVMEMPAGE 0)
(RPAQ? \MAXSHORTSEEK 1000)
(RPAQ? \MINSHORTSEEK 20)
(RPAQ? \MAXCLEANPROBES 20)
(RPAQ? \VMEM.INHIBIT.WRITE )
(RPAQ? \VMEM.PURE.LIMIT )
(RPAQ? VMEM.COMPRESS.FLG )
(RPAQ? \DOFAULTINIT 0)
(RPAQ? \FPTOVP )
(RPAQ? \VMEMACCESSFN )
(RPAQ? \SYSTEMCACHEVARS )
(RPAQ? \MAXSWAPBUFFERS 1)
(RPAQ? \LASTDIRTYCNT )
(RPAQ? \LASTDIRTYFOUND )
(RPAQ? \LASTDIRTYSCANPTR )
(RPAQ? \DIRTYSEEKMAX 50)
(* Errors)
(DEFINEQ
(\MP.ERROR
[LAMBDA (CODE STRING ARG1 ARG2) (* bvm: " 1-APR-83 15:03")
(COND
((EQ \MACHINETYPE \DANDELION)
((OPCODES RAID)
CODE))
(T (RAID STRING ARG1 ARG2])
)
(* Debugging)
(DEFINEQ
(\ACTONVMEMFILE
[LAMBDA (FILEPAGE BUFFER NPAGES WRITEFLAG) (* bvm: "28-MAR-83 16:17")
(COND
((EQ \MACHINETYPE \DANDELION)
(\DL.ACTONVMEMFILE FILEPAGE BUFFER NPAGES WRITEFLAG))
(T (\M44ACTONVMEMFILE FILEPAGE BUFFER NPAGES WRITEFLAG])
(\SHOWPAGETABLE
[LAMBDA (MODE FILE) (* bvm: "23-SEP-82 18:51")
(RESETFORM (OUTPUT FILE)
(PROG ((RPTR \REALPAGETABLE)
(RP 0)
FLAGS VP STATE FIRSTONE LASTONE)
(printout NIL " RP VP FilePage Status" T)
(until (SELECTQ MODE
(CHAIN (EQ (SETQ RP (fetch (RPT NEXTRP) of RPTR))
\PAGETABLESTOPFLG))
(NIL (add RP 1)
(IGREATERP RP \RPTSIZE))
(\ILLEGAL.ARG MODE))
do (SETQ RPTR (fetch RPTRBASE of RP))
(SETQ VP (fetch (RPT VP) of RPTR))
(COND
((AND (NULL MODE)
(EQ VP STATE))
(SETQ LASTONE RP))
(T (COND
(LASTONE (printout NIL "ditto thru " LASTONE T)
(SETQ LASTONE NIL)))
(SETQ FIRSTONE RP)
(SETQ STATE VP)
(printout NIL .I7 RP)
[COND
((fetch (RPT EMPTY) of RPTR)
(PRIN1 " Empty"))
((NOT (fetch (RPT OCCUPIED) of RPTR))
(PRIN1 " Unavailable"))
(T (printout NIL .I8 VP .I8 (fetch (RPT FILEPAGE) of RPTR)
,,)
(COND
((fetch (RPT LOCKED) of RPTR)
(PRIN1 "Locked ")))
(COND
((fetch (VMEMFLAGS REFERENCED) of (SETQ FLAGS (\READFLAGS
VP)))
(PRIN1 "Ref ")))
(COND
((fetch (VMEMFLAGS DIRTY) of FLAGS)
(PRIN1 "Dirty"]
(TERPRI])
(CHECKPAGEMAP
[LAMBDA NIL (* bvm: " 4-APR-83 12:26")
(RESETFORM (RADIX 10Q)
(PROG (VP FP RPTR FPBASE LOCKED)
[COND
(\FPTOVP (for FP from 1 to (fetch NActivePages of \InterfacePage)
as (FPBASE ←(\ADDBASE \FPTOVP 1)) by (\ADDBASE FPBASE 1)
when (fetch FPOCCUPIED of FPBASE)
do (CHECKFPTOVP FP (fetch FPVIRTUALPAGE of FPBASE)
(fetch FPLOCKED of FPBASE]
(for RP from 0 to (SUB1 \RPTSIZE) when (fetch (RPT OCCUPIED)
of (SETQ RPTR (fetch RPTRBASE
of RP)))
do (SETQ VP (fetch (RPT VP) of RPTR))
(SETQ FP (fetch (RPT FILEPAGE) of RPTR))
(SETQ LOCKED (fetch (RPT LOCKED) of RPTR))
(OR (CHECKFPTOVP FP VP LOCKED RP)
(COND
([AND \FPTOVP (OR [NEQ VP (fetch FPVIRTUALPAGE
of (SETQ FPBASE (\ADDBASE \FPTOVP FP]
(NEQ LOCKED (fetch FPLOCKED of FPBASE]
(printout T "RPT for RP " (RPFROMRPT RP)
" says VP ")
(\PRINTVP VP T)
(printout T (\LOCKED?STRING LOCKED)
" lives in FP " FP "; but FP Map says that FP contains ")
(\PRINTVP (fetch FPVIRTUALPAGE of FPBASE)
T)
(printout T (\LOCKED?STRING (fetch FPLOCKED of FPBASE))
T])
(CHECKFPTOVP
[LAMBDA (FP VP LOCKED RPTINDEX) (* bvm: "31-MAR-83 15:05")
(PROG ((FP2 (\LOOKUPPAGEMAP VP)))
(RETURN (COND
((OR (NEQ (fetch FILEPAGEONLY of FP2)
FP)
(NEQ (fetch LOCKEDP of FP2)
LOCKED))
(COND
(RPTINDEX (printout T "RPT for RP " (RPFROMRPT RPTINDEX)))
(T (printout T "FP map")))
(printout T " says FP " FP " contains VP ")
(\PRINTVP VP T)
(printout T (\LOCKED?STRING LOCKED)
"; but PageMap says that page is in FP "
(fetch FILEPAGEONLY of FP2)
(\LOCKED?STRING (fetch LOCKEDP of FP2))
T)
T])
(\LOCKED?STRING
[LAMBDA (LOCKEDP) (* bvm: "31-MAR-83 14:20")
(COND
(LOCKEDP " (locked)")
(T " (unlocked)"])
(\PRINTFPTOVP
[LAMBDA (BASE NWORDS STREAM) (* bvm: "30-MAR-83 11:48")
(SETQ STREAM (GETSTREAM STREAM (QUOTE OUTPUT)))
(RESETFORM (RADIX 10Q)
(PROG (FIRSTFP FIRSTVP (LASTVP -2)
(NEXTFP 0)
NEXTVP LOCKEDP NEXTLOCKED)
(while (IGEQ NWORDS 0)
do (add NEXTFP 1)
[COND
((ZEROP NWORDS)
(SETQ NEXTVP -1))
(T (SETQ NEXTVP (\GETBASE (SETQ BASE (\ADDBASE BASE 1))
0))
(SETQ NEXTLOCKED (fetch LOCKEDP of NEXTVP]
[COND
([COND
((EQ NEXTVP \NO.VMEM.PAGE)
(NEQ LASTVP \NO.VMEM.PAGE))
(T (OR (NEQ (SETQ NEXTVP (fetch FILEPAGEONLY of NEXTVP))
(ADD1 LASTVP))
(NEQ NEXTLOCKED LOCKEDP]
[COND
((IGEQ LASTVP 0)
(COND
(FIRSTFP (printout STREAM FIRSTFP "-")))
(printout STREAM (SUB1 NEXTFP)
14Q)
(COND
((EQ LASTVP \NO.VMEM.PAGE)
(printout STREAM "empty"))
(T (COND
(FIRSTFP (\PRINTVP FIRSTVP STREAM)
(PRIN1 "-" STREAM)))
(\PRINTVP LASTVP STREAM)
(COND
(LOCKEDP (PRIN1 (QUOTE *)
STREAM]
(SETQ FIRSTFP)
(TERPRI STREAM)
(SETQ FIRSTVP NEXTVP))
(T (* in a run)
(OR FIRSTFP (SETQ FIRSTFP (SUB1 NEXTFP]
(SETQ LASTVP NEXTVP)
(SETQ LOCKEDP NEXTLOCKED)
(add NWORDS -1])
(\PRINTVP
[LAMBDA (VP STREAM) (* bvm: "28-MAR-83 12:40")
(printout STREAM "{" (LRSH VP 8)
","
(LOGAND VP 255)
"}"])
)
(DECLARE: EVAL@COMPILE DONTCOPY
(DECLARE: EVAL@COMPILE
(PUTPROPS \ACTONVMEMFILE MACRO ((X . Y)
(SPREADAPPLY* \VMEMACCESSFN X . Y)))
)
(* Virtual page flags)
(DECLARE: EVAL@COMPILE
(RPAQQ \VMAP.DIRTY 10000Q)
(RPAQQ \VMAP.CLEAN 0)
(RPAQQ \VMAP.REF 100000Q)
(RPAQQ \VMAP.VACANT 30000Q)
(RPAQQ \VMAP.FLAGS 170000Q)
(RPAQQ \VMAP.NOTFLAGS 7777Q)
(CONSTANTS \VMAP.DIRTY \VMAP.CLEAN \VMAP.REF \VMAP.VACANT \VMAP.FLAGS \VMAP.NOTFLAGS)
)
[DECLARE: EVAL@COMPILE
(ACCESSFNS VMEMFLAGS ((VACANT (EQ (LOGAND DATUM \VMAP.VACANT)
\VMAP.VACANT))
(DIRTY (NEQ (LOGAND DATUM \VMAP.DIRTY)
0))
(REFERENCED (NEQ (LOGAND DATUM \VMAP.REF)
0))))
]
(DECLARE: EVAL@COMPILE
(PUTPROPS LOGNOT16 MACRO ((X)
(LOGXOR X 177777Q)))
)
(* RPT constants)
(DECLARE: EVAL@COMPILE
(RPAQQ \PAGEMAPLOCKBIT 100000Q)
(RPAQQ \RPT.EMPTY 40000Q)
(RPAQQ \RPT.UNAVAILABLE 40400Q)
(RPAQQ \PAGETABLESTOPFLG 0)
(RPAQQ \RPTENTRYLENGTH 3)
(CONSTANTS \PAGEMAPLOCKBIT \RPT.EMPTY \RPT.UNAVAILABLE \PAGETABLESTOPFLG \RPTENTRYLENGTH)
)
[DECLARE: EVAL@COMPILE
(BLOCKRECORD RPT ((NEXTRP WORD) (* rp of next entry in page chain)
(VP WORD) (* Virtual page number occupying this real page)
(LOCKED FLAG)
(FILEPAGE BITS 17Q) (* Page in Lisp.VirtualMem)
)
(BLOCKRECORD RPT ((NIL WORD)
(UNOCCUPIEDVPBITS BITS 2)
(VPONLY BITS 16Q)
(FILEPAGE&LOCK WORD)))
[ACCESSFNS RPT ((RPTRBASE (\ADDBASE \REALPAGETABLE (TIMES3 DATUM)))
[EMPTY (EQ (fetch (RPT VP) of DATUM)
\RPT.EMPTY)
(COND
(NEWVALUE (replace (RPT VP) of DATUM with \RPT.EMPTY))
(T (ERROR "Invalid replace of RPT.EMPTY" DATUM]
[UNAVAILABLE (EQ (fetch (RPT VP) of DATUM)
\RPT.UNAVAILABLE)
(COND
(NEWVALUE (replace (RPT VP) of DATUM with
\RPT.UNAVAILABLE))
(T (ERROR "Invalid replace of RPT.UNAVAILABLE" DATUM]
(OCCUPIED (ZEROP (fetch (RPT UNOCCUPIEDVPBITS) of DATUM]
(* Given a RP, RPTRBASE produces a pointer to its entry
in the real page table)
)
]
(DECLARE: EVAL@COMPILE
(PUTPROPS RPFROMRPT MACRO ((RPTINDEX)
(IPLUS RPTINDEX \RPOFFSET)))
(PUTPROPS RPTFROMRP MACRO ((RP)
(IDIFFERENCE RP \RPOFFSET)))
(PUTPROPS NPAGESMACRO MACRO ((FORM)
(PROG ((RESULT 0)
(CNTR \RPTSIZE)
(RPTR \REALPAGETABLE)
VP)
LP (COND
((AND (ILESSP (SETQ VP (fetch (RPT VP) of RPTR))
\RPT.EMPTY)
FORM)
(add RESULT 1)))
(COND
([NOT (ZEROP (SETQ CNTR (SUB1 CNTR]
(SETQ RPTR (\ADDBASE RPTR 3))
(GO LP)))
(RETURN RESULT))))
)
(* Virtual to file pagemap)
(* FOLLOWING DEFINITIONS EXPORTED)
(DECLARE: EVAL@COMPILE
(RPAQQ \MAXVMPAGE 37777Q)
(RPAQQ \MAXVMSEGMENT 77Q)
(RPAQQ \MAXFILEPAGE 37777Q)
(CONSTANTS \MAXVMPAGE \MAXVMSEGMENT \MAXFILEPAGE)
)
(* END EXPORTED DEFINITIONS)
(DECLARE: EVAL@COMPILE
(RPAQQ \EMPTYPMTENTRY 177777Q)
(CONSTANTS \EMPTYPMTENTRY)
)
[DECLARE: EVAL@COMPILE
(ACCESSFNS VP ((PRIMARYKEY (LRSH DATUM 5))
(SECONDARYKEY (LOGAND DATUM 37Q))
(INVALID (IGREATERP DATUM \MAXVMPAGE))))
(ACCESSFNS PAGEMAPENTRY [(FILEPAGEONLY (LOGAND DATUM 77777Q))
(LOCKEDP (NOT (ZEROP (LOGAND DATUM 100000Q])
]
(DECLARE: EVAL@COMPILE
(PUTPROPS .PAGEMAPBASE. MACRO [OPENLAMBDA (VPAGE)
(\ADDBASE \PAGEMAP (IPLUS (\GETBASE \PageMapTBL
(fetch (VP PRIMARYKEY)
of VPAGE))
(fetch (VP SECONDARYKEY)
of VPAGE])
)
(* FP to VP stuff)
[DECLARE: EVAL@COMPILE
(BLOCKRECORD FPTOVP ((FPLOCKED FLAG)
(NIL FLAG)
(FPVIRTUALPAGE BITS 16Q))
[ACCESSFNS FPTOVP ((FPOCCUPIED (NEQ (\GETBASE DATUM 0)
\NO.VMEM.PAGE])
]
(DECLARE: EVAL@COMPILE
(RPAQQ \NO.VMEM.PAGE 177777Q)
(CONSTANTS \NO.VMEM.PAGE)
)
(DECLARE: EVAL@COMPILE
(PUTPROPS DLRPFROMFP MACRO ((FP)
(ADD1 FP)))
(PUTPROPS DLFPFROMRP MACRO ((RP)
(SUB1 RP)))
)
(PUTPROPS \TOUCHPAGE DOPVAL (1 GETBASE.N 0))
(PUTPROPS TIMES3 DOPVAL (1 COPY LLSH1 IPLUS2))
(DECLARE: EVAL@COMPILE
(RPAQQ \MAXDIRTYSCANCOUNT 144Q)
(RPAQQ \MINVMEMSPAREPAGES 144Q)
(RPAQQ \DLBUFFERPAGES 20Q)
(CONSTANTS \MAXDIRTYSCANCOUNT \MINVMEMSPAREPAGES \DLBUFFERPAGES)
)
(DECLARE: EVAL@COMPILE
(RPAQQ 2MBPAGES 10000Q)
(CONSTANTS 2MBPAGES)
)
(DECLARE: DOEVAL@COMPILE DONTCOPY
(ADDTOVAR GLOBALVARS \UPDATECHAINFREQ \REALPAGETABLE \RPOFFSET \RPTSIZE \EMBUFBASE \EMBUFVP \EMBUFRP
\PAGEFAULTCOUNTER \LASTDIRTYCNT \LASTDIRTYFOUND \LASTDIRTYSCANPTR \MACHINETYPE
\LASTACCESSEDVMEMPAGE \MAXSHORTSEEK \MAXCLEANPROBES \MINSHORTSEEK \DIRTYSEEKMAX
\DIRTYPAGECOUNTER \DIRTYPAGEHINT \VMEM.INHIBIT.WRITE \VMEM.PURE.LIMIT VMEM.COMPRESS.FLG
\KBDSTACKBASE \MISCSTACKBASE \DOFAULTINIT \FPTOVP \VMEMACCESSFN \SYSTEMCACHEVARS)
)
(DECLARE: DOEVAL@COMPILE DONTCOPY
(ADDTOVAR GLOBALVARS \#SWAPBUFFERS \#EMUBUFFERS \#DISKBUFFERS \MAXSWAPBUFFERS \EMUSWAPBUFFERS
\EMUBUFFERS \TELERAIDBUFFER \EMUDISKBUFFERS \EMUDISKBUFEND)
)
)
(* * MAKEINIT stuff)
(DEFINEQ
(ADDPME
[LAMBDA (VP NEWPAGEOK) (* bvm: "29-MAR-83 17:10")
(* add an entry for VP to the PAGEMAP.
Called only under MAKEINIT)
(PROG (PX PMP)
[COND
((IEQ (SETQ PMP (\GETBASE \PageMapTBL (fetch (VP PRIMARYKEY) of VP)))
\EmptyPMTEntry) (* empty entries in the PageMapTBL have 177777q as their
value)
(COND
((EVENP NEXTPM WORDSPERPAGE) (* must add a new page map page)
(SETQ PX (\ADDBASE \PAGEMAP NEXTPM))
(OR NEWPAGEOK (IGREATERP (PAGELOC PX)
VP)
(HELP "page map needs new page after page map written out"))
(\NEWPAGE PX NIL T)))
(\PUTBASE \PageMapTBL (fetch (VP PRIMARYKEY) of VP)
(SETQ PMP NEXTPM))
(SETQ NEXTPM (IPLUS NEXTPM \PMblockSize]
(SETQ PX (IPLUS PMP (fetch (VP SECONDARYKEY) of VP)))
[COND
((NEQ (\GETBASE \PAGEMAP PX)
0)
(HELP "page already in pagemap" VP))
(T (\PUTBASE \PAGEMAP PX (COND
((LOCKEDPAGEP VP)
(IPLUS \PAGEMAPLOCKBIT NEXTVMEM))
(T NEXTVMEM]
(SETQ NEXTVMEM (ADD1 NEXTVMEM])
(CHECKIFPAGE
[LAMBDA NIL (* lmm "20-AUG-81 13:11")
(CHECKIF LVersion EQUAL \LispVersion "Lisp Version")
(CHECKIF Key EQUAL \IFPValidKey "Interface page key"])
(FIXIFPAGE
[LAMBDA (RPT RPTSIZE RPOFFSET RPTLAST EMBUFVP) (* lmm "17-JUN-82 00:03")
(* for DANDELION only -
called, renamed, by DLFILEBUILD)
(replace RVersion of \InterfacePage with \MinRamVersion)
(replace BVersion of \InterfacePage with 177777Q)
(replace MachineType of \InterfacePage with \DANDELION)
(replace SerialNumber of \InterfacePage with 0)
(replace EmulatorSpace of \InterfacePage with 0)
(replace ScreenWidth of \InterfacePage with 100Q)
(replace UserNameAddr of \InterfacePage with 0)
(replace UserPswdAddr of \InterfacePage with 0)
(replace REALPAGETABLE of \InterfacePage with RPT)
(replace RPTSIZE of \InterfacePage with RPTSIZE)
(replace RPOFFSET of \InterfacePage with (UNSIGNED RPOFFSET BITSPERWORD))
(replace RPTLAST of \InterfacePage with RPTLAST)
(replace EMBUFVP of \InterfacePage with EMBUFVP) (* (replace NSHost0 of \InterfacePage with NSHost0)
(replace NSHost1 of \InterfacePage with NSHost1)
(replace NSHost2 of \InterfacePage with NSHost2))
NIL])
(DUMPINITPAGES
[LAMBDA (CODESTARTOFFSET CODELASTPAGE) (* bvm: " 1-NOV-83 20:59")
(* called only under MAKEINIT)
(ADDPME (PAGELOC \InterfacePage)
T) (* THE INTERFACE PAGE MUST BE THE FIRST PAGE)
(for I from (IPLUS (UNFOLD \ARRAYspace PAGESPERSEGMENT)
CODESTARTOFFSET)
to (SUB1 CODELASTPAGE)
do (* add the pagemap entries for the pages which were
written directly to the file)
(ADDPME I T))
(MAPPAGES 0 (ADD1 \MAXVMPAGE)
(FUNCTION MAKEROOMFORPME))
(MAPPAGES 0 (ADD1 \MAXVMPAGE)
(FUNCTION ADDPME))
(PROGN (* set interface page locations -
stack pointers already set up IN SETUPSTACK)
(replace (IFPAGE NxtPMAddr) of \InterfacePage with NEXTPM)
(replace (IFPAGE NActivePages) of \InterfacePage with (SUB1 NEXTVMEM))
(replace (IFPAGE NDirtyPages) of \InterfacePage with (SUB1 NEXTVMEM))
(replace (IFPAGE filePnPMP0) of \InterfacePage with (fetch FILEPAGEONLY
of (\GETBASE \PAGEMAP 0)))
[replace (IFPAGE filePnPMT0) of \InterfacePage
with (fetch FILEPAGEONLY of (\GETBASE \PAGEMAP (\GETBASE \PageMapTBL
(fetch PRIMARYKEY
of (PAGELOC \PageMapTBL]
(replace (IFPAGE LVersion) of \InterfacePage with \LispVersion)
(replace (IFPAGE MinRVersion) of \InterfacePage with \MinRamVersion)
(replace (IFPAGE MinBVersion) of \InterfacePage with \MinBcplVersion)
(replace (IFPAGE Key) of \InterfacePage with \IFPValidKey))
(MAPPAGES 0 (ADD1 \MAXVMPAGE)
(FUNCTION DUMPVP))
(ALLOCAL (PROG ((FILE (OUTPUT)))
[COND
((NOT (RANDACCESSP FILE)) (* SYSOUT file is sequential;
have to get it random access for this)
(OUTPUT (SETQ FILE (OPENFILE (CLOSEF FILE)
(QUOTE BOTH]
(SETFILEPTR FILE MKI.Page0Byte)))
(DUMPVP (PAGELOC \InterfacePage])
(MAKEROOMFORPME
[LAMBDA (VP) (* bvm: "29-MAR-83 17:11")
(* make sure that the pagemap-page for page VP exists;
we later will want to add it to the pagemap)
(COND
((IEQ (\GETBASE \PageMapTBL (fetch (VP PRIMARYKEY) of VP))
\EmptyPMTEntry) (* empty entries in the PageMapTBL have 177777q as their
value)
(COND
((EVENP NEXTPM WORDSPERPAGE) (* must add a new page map page)
(\NEWPAGE (\ADDBASE \PAGEMAP NEXTPM)
NIL T)))
(\PUTBASE \PageMapTBL (fetch (VP PRIMARYKEY) of VP)
NEXTPM)
(SETQ NEXTPM (IPLUS NEXTPM \PMblockSize])
(MAPPAGES
[LAMBDA (BOT TOP FN) (* lmm "26-MAR-81 12:23")
(PROG ((VP BOT)
(IVP (PAGELOC \InterfacePage)))
LP (COND
((AND (SETQ VP (MKI.NEXTPAGE VP))
(IGREATERP TOP VP))
(COND
((NOT (IEQ VP IVP))
(APPLY* FN VP)))
(SETQ VP (ADD1 VP))
(GO LP])
(READPAGEMAP
[LAMBDA NIL (* bvm: " 7-APR-82 14:35")
(* called only under READSYS)
(PROG (FIRSTPMT D)
(LOCAL (MAPVMPAGE (fetch (POINTER PAGE#) of \InterfacePage)
1)) (* Install interface page by magic)
(CHECKIFPAGE)
[LOCAL (MAPVMPAGE (PAGELOC \PAGEMAP)
(SUB1 (fetch (IFPAGE filePnPMP0) of \InterfacePage]
(* map in page map)
(SETQ FIRSTPMT (SUB1 (fetch (IFPAGE filePnPMT0) of \InterfacePage)))
(LOCAL (SETVMPTR \PAGEMAP))
(READPAGEMAPBLOCK (fetch (POINTER PAGE#) of \PAGEMAP))
(* read in all the page map table pages)
[for J from 0 to (SUB1 \NumPMTpages) do (LOCAL (MAPVMPAGE (IPLUS (PAGELOC \PageMapTBL)
J)
(IPLUS FIRSTPMT J]
(for I from 0 to (SUB1 (UNFOLD \NumPMTpages WORDSPERPAGE))
do (COND
((IEQ (SETQ D (GETBASE \PageMapTBL I))
\EmptyPMTEntry))
(T (LOCAL (SETVMPTR (ADDBASE \PAGEMAP D)))
(READPAGEMAPBLOCK (UNFOLD I \PMblockSize])
(READPAGEMAPBLOCK
[LAMBDA (VP) (* lmm " 4-MAY-82 21:12")
(PROG ((B VP)
P)
(FRPTQ \PMblockSize [COND
((NEQ (SETQ P (VBIN2))
0)
(LOCAL (MAPVMPAGE B (SUB1 P]
(SETQ B (ADD1 B])
(SETUPPAGEMAP
[LAMBDA NIL (* bvm: "29-MAR-83 17:11")
(* called only from MAKEINIT to initialize the page map)
(PROG (VPX) (* set up page map)
(\NEWPAGE \PAGEMAP NIL T)
(CREATEPAGES \PageMapTBL \NumPMTpages NIL T) (* init PageMapTBL pages to 177777q)
(for I from 0 to (SUB1 (UNFOLD \NumPMTpages WORDSPERPAGE)) do (\PUTBASE \PageMapTBL I
\EmptyPMTEntry))
(SETQ NEXTPM 0)
(SETQ VPX (fetch (VP PRIMARYKEY) of (PAGELOC \PAGEMAP)))
(for I from 0 to (SUB1 (fetch (VP PRIMARYKEY) of \NumPageMapPages))
do (\PUTBASE \PageMapTBL (IPLUS VPX I)
NEXTPM)
(SETQ NEXTPM (IPLUS NEXTPM \PMblockSize))) (* add entry for InterfacePage which must be on
FirstVMemBlock)
(SETQ NEXTVMEM \FirstVmemBlock])
)
(DECLARE: DONTCOPY
(DECLARE: EVAL@COMPILE
(PUTPROPS CHECKIF MACRO [(FLD COMPARISON VALUE STR)
(COND
((NOT (COMPARISON VALUE (fetch (IFPAGE FLD) of \InterfacePage)))
(printout T "Warning: " STR "= " (PROGN VALUE)
", but \InterfacePage says "
(fetch (IFPAGE FLD) of \InterfacePage)
T])
)
(ADDTOVAR INEWCOMS (FNS DUMPINITPAGES)
(VARS INITCONSTANTS)
(FNS SETUPPAGEMAP ADDPME MAKEROOMFORPME MAPPAGES))
(ADDTOVAR RDCOMS (FNS READPAGEMAP READPAGEMAPBLOCK CHECKIFPAGE FIXIFPAGE))
(ADDTOVAR EXPANDMACROFNS CHECKIF)
(ADDTOVAR MKI.SUBFNS (\NEWPAGE . MKI.NEWPAGE)
(\LOCKPAGES . MKI.LOCKPAGES))
(ADDTOVAR RD.SUBFNS (\NEWPAGE . VNEWPAGE)
(\LOCKPAGES . VLOCKPAGES))
EVAL@COMPILE
(ADDTOVAR DONTCOMPILEFNS DUMPINITPAGES SETUPPAGEMAP ADDPME MAKEROOMFORPME MAPPAGES READPAGEMAP
READPAGEMAPBLOCK CHECKIFPAGE)
)
(DEFINEQ
(\LOCKFN
[LAMBDA (FN) (* bvm: "22-NOV-82 17:39")
[\LOCKCELL (SETQ FN (fetch (LITATOM DEFINITIONCELL) of (EVQ FN]
(COND
((fetch (DEFINITIONCELL CCODEP) of FN)
(\LOCKCODE (fetch (DEFINITIONCELL DEFPOINTER) of FN])
(\LOCKCODE
[LAMBDA (CODEBLOCK) (* bvm: "22-NOV-82 17:35")
(\LOCKWORDS CODEBLOCK (UNFOLD (IDIFFERENCE (fetch (ARRAYBLOCK ARLEN) of (\ADDBASE CODEBLOCK
(IMINUS
\ArrayBlockHeaderWords)))
\ArrayBlockOverheadWords)
WORDSPERCELL])
(\LOCKVAR
[LAMBDA (VAR) (* lmm " 5-APR-82 00:43")
(\LOCKCELL (fetch (LITATOM VCELL) of (EVQ VAR])
(\LOCKCELL
[LAMBDA (X NPGS) (* bvm: "22-NOV-82 17:54")
(\LOCKPAGES (PAGEBASE X)
(OR NPGS 1])
(\LOCKWORDS
[LAMBDA (BASE NWORDS) (* bvm: "22-NOV-82 17:35")
(\LOCKPAGES (PAGEBASE BASE)
(COND
(NWORDS (FOLDHI (IPLUS (fetch (POINTER WORDINPAGE) of BASE)
NWORDS)
WORDSPERPAGE))
(T 1])
)
(DECLARE: DONTCOPY
(ADDTOVAR INEWCOMS (ALLOCAL (ADDVARS (LOCKEDFNS \FAULTHANDLER \FAULTINIT \D01.FAULTINIT \DL.FAULTINIT
\MAKESPACEFORLOCKEDPAGE \PAGEFAULT \READRP \READFLAGS
\WRITEMAP \LOOKUPPAGEMAP \LOADVMEMPAGE \INVALIDADDR
RAID \INVALIDVP \SELECTREALPAGE \TRANSFERPAGE
\UPDATECHAIN \MARKPAGEVACANT \FLUSHPAGE \MOVEPAGE
\ZEROPAGE \FLUSHVM \DONEWPAGE \DONEWEPHEMERALPAGE
\WRITEDIRTYPAGE1 \COPYSYS0 \COPYSYS0SUBR
\RELEASEWORKINGSET \DOFLUSHVM \DOLOCKPAGES
\TEMPLOCKPAGES \TEMPUNLOCKPAGES \MP.ERROR
\DL.NEWFAULTINIT \DL.MARK.PAGES.UNAVAILABLE
\DL.UNMAPPAGES \DL.ASSIGNBUFFERS \D01.ASSIGNBUFFERS
\DOCOMPRESSVMEM \MOVEVMEMFILEPAGE)
(LOCKEDVARS \REALPAGETABLE \PAGEFAULTCOUNTER \UPDATECHAINFREQ
\RPOFFSET \RPTSIZE \EMBUFBASE \EMBUFVP \EMBUFRP
\LASTACCESSEDVMEMPAGE \MAXSHORTSEEK \MAXCLEANPROBES
\MINSHORTSEEK \DIRTYPAGECOUNTER \DIRTYPAGEHINT
\VMEM.INHIBIT.WRITE \VMEM.PURE.LIMIT
VMEM.COMPRESS.FLG \KBDSTACKBASE \MISCSTACKBASE
\DOFAULTINIT \FPTOVP \MACHINETYPE \VMEMACCESSFN
\TELERAIDBUFFER \EMUDISKBUFFERS \EMUDISKBUFEND
\MAXSWAPBUFFERS)))
(FNS \LOCKFN \LOCKVAR \LOCKCELL \LOCKWORDS \LOCKCODE))
)
(* Clock stuff)
(DEFINEQ
(\CLOCK0
[LAMBDA (BOX) (* bvm: "13-OCT-82 15:10")
(* Stores millisecond clock in BOX. Do this by fetching the current millisecond clock and adding in the number of
milliseconds since the clock was last updated)
(SETQ BOX (\DTEST BOX (QUOTE FIXP)))
(UNINTERRUPTABLY
(\GETINTERNALCLOCK \OFFSET.MILLISECONDS BOX)
[bind (EXCESS ←(LOCF (fetch EXCESSTIMETMP of \MISCSTATS))) while (OR (IGREATERP EXCESS
\RCLKSECOND)
(ILESSP EXCESS 0))
do
(* Excess time. unsigned, is more than a second, so clock has not been updated in ages (perhaps someone sat in
Raid for a while). We don't want IQUOTIENT here to do a CREATECELL, so do some of the division by subtraction.
Instead of \RCLKSECOND, it would really be better to use \RCLKMILLISECOND*MAX.SMALL.INTEGER, but this is a rare
case already, so be lazy)
(\BOXIPLUS BOX 1750Q)
(\BOXIDIFFERENCE EXCESS \RCLKSECOND)
finally (* Now it is safe to use IQUOTIENT)
(RETURN (\BOXIPLUS BOX (IQUOTIENT EXCESS \RCLKMILLISECOND])])
(\DAYTIME0
[LAMBDA (BOX) (* bvm: "24-JUN-82 15:39")
(UNINTERRUPTABLY
(\GETINTERNALCLOCK \OFFSET.SECONDS (\DTEST BOX (QUOTE FIXP))))])
(\GETINTERNALCLOCK
[LAMBDA (CLOCKOFFSET BOX) (* bvm: "24-JUN-82 15:39")
(* Stores in BOX the contents of internal timer denoted by CLOCKOFFSET (0 = SECONDS, 2 = MILLISECONDS). Excess
time is in EXCESSTIMETEMP. Must be called UNINTERRUPTABLY)
(\BLT (LOCF (fetch SECONDSTMP of \MISCSTATS))
(LOCF (fetch SECONDSCLOCK of \MISCSTATS))
(UNFOLD 3 WORDSPERCELL)) (* Copy system clocks into scratch area, so there is no
update conflict)
(\BLT BOX (\ADDBASE (LOCF (fetch SECONDSTMP of \MISCSTATS))
CLOCKOFFSET)
WORDSPERCELL) (* Copy clock to caller)
(\BOXIDIFFERENCE (\RCLK (LOCF (fetch EXCESSTIMETMP of \MISCSTATS)))
(LOCF (fetch BASETMP of \MISCSTATS))) (* Compute processor time since clock was updated)
BOX])
(\SETDAYTIME0
[LAMBDA (BOX) (* bvm: "22-SEP-82 17:42")
(* Sets the seconds calendar to contents of BOX)
(SETQ BOX (\DTEST BOX (QUOTE FIXP)))
(UNINTERRUPTABLY
(\RCLK (LOCF (fetch BASETMP of \MISCSTATS))) (* Reset the base; clocks will not be adjusted for at
least a second after this)
(\BLT (LOCF (fetch SECONDSTMP of \MISCSTATS))
BOX WORDSPERCELL)
(\BLT (LOCF (fetch SECONDSCLOCK of \MISCSTATS))
(LOCF (fetch SECONDSTMP of \MISCSTATS))
(UNFOLD 3 WORDSPERCELL)) (* Finally store them all at once, uninterruptably)
[COND
((EQ \MACHINETYPE \DANDELION) (* Tell the iop the new time, too)
(repeatwhile (IGEQ (fetch DLPROCESSORCMD of \IOPAGE)
\DL.PROCESSORBUSY))
(replace DLPROCESSOR2 of \IOPAGE with (\GETBASE BOX 1))
(replace DLPROCESSOR1 of \IOPAGE with (\GETBASE BOX 0))
(replace DLPROCESSORCMD of \IOPAGE with \DL.SETTOD)
(replace DLTODVALID of \IOPAGE with 0)
(repeatwhile (IGEQ (fetch DLPROCESSORCMD of \IOPAGE)
\DL.PROCESSORBUSY))
(repeatwhile (ZEROP (fetch DLTODVALID of \IOPAGE])
BOX])
(CLOCKDIFFERENCE
[LAMBDA (OLDCLOCK) (* bvm: "24-JUN-82 15:40")
(UNINTERRUPTABLY
(IPLUS (\BOXIDIFFERENCE (\CLOCK0 (LOCF (fetch CLOCKTEMP0 of \MISCSTATS)))
OLDCLOCK)))])
(\SECONDSCLOCKGREATERP
[LAMBDA (OLDCLOCK SECONDS) (* bvm: " 7-Dec-83 15:27")
(UNINTERRUPTABLY
(\BLT (LOCF (fetch CLOCKTEMP0 of \MISCSTATS))
(LOCF (fetch SECONDSCLOCK of \MISCSTATS))
WORDSPERCELL)
(IGREATERP (\BOXIDIFFERENCE (LOCF (fetch CLOCKTEMP0 of \MISCSTATS))
OLDCLOCK)
SECONDS))])
(\CLOCKGREATERP
[LAMBDA (OLDCLOCK MSECS) (* bvm: "17-Dec-83 16:38")
(* * True if more than MSECS milliseconds have elapsed since OLDCLOCK was set)
(UNINTERRUPTABLY
(IGREATERP (\BOXIDIFFERENCE (\CLOCK0 (LOCF (fetch CLOCKTEMP0 of \MISCSTATS)))
OLDCLOCK)
MSECS))])
(\RCLOCK0
(LAMBDA (BOX) (* JonL "19-APR-83 01:47")
(\RCLK (\DTEST BOX (QUOTE FIXP)))))
)
(DEFINEQ
(CLOCK0
[LAMBDA (BOX) (* bvm: " 1-APR-83 15:26")
(* Store millisecond clock at BOX. Unfortunately, there are still a few folks that call this without a true box,
so accomodate them for now)
(COND
((EQ (NTYPX BOX)
\FIXP)
(\CLOCK0 BOX))
(T (\MP.ERROR \MP.CLOCK0 "Call to CLOCK0 with arg not a number box. ↑N to continue." BOX)
(UNINTERRUPTABLY
(\BLT BOX (\CLOCK0 (LOCF (fetch CLOCKTEMP0 of \MISCSTATS)))
WORDSPERCELL))
BOX])
)
(DECLARE: EVAL@COMPILE
(PUTPROPS \RCLOCK0 DMACRO [(BOX)
(\RCLK (\DTEST BOX (QUOTE FIXP])
)
(DECLARE: DONTCOPY
(* FOLLOWING DEFINITIONS EXPORTED)
(DECLARE: EVAL@COMPILE
(PUTPROPS \UPDATETIMERS MACRO [NIL
(* * Moves excess time from the processor clock to our software clocks. Needs to be run often, uninterruptably,
preferably from the vertical retrace interrupt)
(* Get processor clock)
(PROG [(EXCESS (\BOXIDIFFERENCE (\RCLK (LOCF (fetch RCLKTEMP0
of \MISCSTATS)))
(LOCF (fetch BASECLOCK
of \MISCSTATS]
(RETURN (COND
((OR (IGEQ EXCESS \RCLKSECOND)
(ILESSP EXCESS 0))
(* More than one second has elapsed since we updated
clocks)
(\BOXIPLUS (LOCF (fetch BASECLOCK of \MISCSTATS))
\RCLKSECOND)
(* Increment base by one second)
(\BOXIPLUS (LOCF (fetch MILLISECONDSCLOCK
of \MISCSTATS))
1750Q)
(* Increment clocks by 1 second)
(\BOXIPLUS (LOCF (fetch SECONDSCLOCK
of \MISCSTATS))
1)
T])
)
(* END EXPORTED DEFINITIONS)
)
(DECLARE: DONTEVAL@LOAD DOCOPY
(MOVD (QUOTE \DAYTIME0)
(QUOTE DAYTIME0))
)
(RPAQQ \RCLKMILLISECOND 3220Q)
(DECLARE: DOEVAL@COMPILE DONTCOPY
(ADDTOVAR GLOBALVARS \RCLKSECOND \RCLKMILLISECOND)
)
(DECLARE: DONTCOPY
(* Locations in alto emulator)
(* FOLLOWING DEFINITIONS EXPORTED)
(DECLARE: EVAL@COMPILE
(RPAQQ \RTCSECONDS 572Q)
(RPAQQ \RTCMILLISECONDS 574Q)
(RPAQQ \RTCBASE 576Q)
(RPAQQ \OFFSET.SECONDS 0)
(RPAQQ \OFFSET.MILLISECONDS 2)
(RPAQQ \OFFSET.BASE 4)
(RPAQQ \ALTO.RCLKSECOND 6321200Q)
(RPAQQ \ALTO.RCLKMILLISECOND 3220Q)
(RPAQQ \DLION.RCLKMILLISECOND 43Q)
(RPAQQ \DLION.RCLKSECOND 103672Q)
(CONSTANTS (\RTCSECONDS 572Q)
(\RTCMILLISECONDS 574Q)
(\RTCBASE 576Q)
(\OFFSET.SECONDS 0)
(\OFFSET.MILLISECONDS 2)
(\OFFSET.BASE 4)
(\ALTO.RCLKSECOND 6321200Q)
(\ALTO.RCLKMILLISECOND 3220Q)
(\DLION.RCLKMILLISECOND 43Q)
(\DLION.RCLKSECOND 103672Q))
)
(DECLARE: EVAL@COMPILE
(PUTPROPS RWMufMan DMACRO ((X)
(* Note that this is the MISC1 opcode with 11Q as the alpha byte.)
((OPCODES 170Q 11Q)
X)))
)
(* END EXPORTED DEFINITIONS)
(* Locked stuff. Have to lock anything used by pagefault code, including the ufns that they use
until all microcodes have them)
(ADDTOVAR INEWCOMS (ALLOCAL (ADDVARS (LOCKEDFNS \CLOCK0 \GETINTERNALCLOCK \BOXIDIFFERENCE \BOXIPLUS
\BLT \SLOWIQUOTIENT)
(LOCKEDVARS \RCLKSECOND \RCLKMILLISECOND \MISCSTATS))))
)
(DECLARE: DONTEVAL@LOAD DOEVAL@COMPILE DONTCOPY COMPILERVARS
(ADDTOVAR NLAMA )
(ADDTOVAR NLAML )
(ADDTOVAR LAMA VMEM.PURE.STATE)
)
(PUTPROPS LLFAULT COPYRIGHT ("Xerox Corporation" 3676Q 3677Q 3700Q))
(DECLARE: DONTCOPY
(FILEMAP (NIL (15264Q 16057Q (\FAULTHANDLER 15276Q . 16055Q)) (16111Q 31052Q (\FAULTINIT 16123Q .
21000Q) (\D01.FAULTINIT 21002Q . 25630Q) (\D01.ASSIGNBUFFERS 25632Q . 31050Q)) (31053Q 67455Q (
\DL.FAULTINIT 31065Q . 36504Q) (\DL.NEWFAULTINIT 36506Q . 62744Q) (\DL.UNMAPPAGES 62746Q . 63715Q) (
\DL.MARK.PAGES.UNAVAILABLE 63717Q . 64455Q) (\DL.ASSIGNBUFFERS 64457Q . 67453Q)) (67456Q 130523Q (
\PAGEFAULT 67470Q . 72222Q) (\INVALIDADDR 72224Q . 72477Q) (\INVALIDVP 72501Q . 72737Q) (\FLUSHPAGE
72741Q . 76642Q) (\LOADVMEMPAGE 76644Q . 104611Q) (\LOOKUPPAGEMAP 104613Q . 105604Q) (\MARKPAGEVACANT
105606Q . 106343Q) (\SELECTREALPAGE 106345Q . 114413Q) (\SPECIALRP 114415Q . 115350Q) (\TRANSFERPAGE
115352Q . 122273Q) (\MOVEPAGE 122275Q . 122624Q) (\ZEROPAGE 122626Q . 123370Q) (\UPDATECHAIN 123372Q
. 130521Q)) (130524Q 211163Q (\NEWPAGE 130536Q . 132020Q) (\DONEWPAGE 132022Q . 137643Q) (
\MAKESPACEFORLOCKEDPAGE 137645Q . 143025Q) (\MOVEVMEMFILEPAGE 143027Q . 144713Q) (\NEWEPHEMERALPAGE
144715Q . 145456Q) (\DONEWEPHEMERALPAGE 145460Q . 152242Q) (\LOCKPAGES 152244Q . 152764Q) (
\DOLOCKPAGES 152766Q . 156360Q) (\TEMPLOCKPAGES 156362Q . 160227Q) (\TEMPUNLOCKPAGES 160231Q . 162206Q
) (\UNLOCKPAGES 162210Q . 165026Q) (\FLUSHVM 165030Q . 166731Q) (\LOGOUT0 166733Q . 170041Q) (
\DOFLUSHVM 170043Q . 175753Q) (\RELEASEWORKINGSET 175755Q . 177255Q) (\WRITEDIRTYPAGE 177257Q .
207135Q) (\WRITEDIRTYPAGE1 207137Q . 210267Q) (\COUNTREALPAGES 210271Q . 211161Q)) (211164Q 214343Q (
\DOCOMPRESSVMEM 211176Q . 213423Q) (VMEM.PURE.STATE 213425Q . 214341Q)) (215541Q 216101Q (\MP.ERROR
215553Q . 216077Q)) (216130Q 231372Q (\ACTONVMEMFILE 216142Q . 216565Q) (\SHOWPAGETABLE 216567Q .
221463Q) (CHECKPAGEMAP 221465Q . 224364Q) (CHECKFPTOVP 224366Q . 225671Q) (\LOCKED?STRING 225673Q .
226151Q) (\PRINTFPTOVP 226153Q . 231065Q) (\PRINTVP 231067Q . 231370Q)) (244122Q 265444Q (ADDPME
244134Q . 246514Q) (CHECKIFPAGE 246516Q . 247065Q) (FIXIFPAGE 247067Q . 251557Q) (DUMPINITPAGES
251561Q . 256167Q) (MAKEROOMFORPME 256171Q . 257617Q) (MAPPAGES 257621Q . 260343Q) (READPAGEMAP
260345Q . 263043Q) (READPAGEMAPBLOCK 263045Q . 263424Q) (SETUPPAGEMAP 263426Q . 265442Q)) (267315Q
271640Q (\LOCKFN 267327Q . 270021Q) (\LOCKCODE 270023Q . 270543Q) (\LOCKVAR 270545Q . 270763Q) (
\LOCKCELL 270765Q . 271217Q) (\LOCKWORDS 271221Q . 271636Q)) (274236Q 305754Q (\CLOCK0 274250Q .
276562Q) (\DAYTIME0 276564Q . 277100Q) (\GETINTERNALCLOCK 277102Q . 300755Q) (\SETDAYTIME0 300757Q .
303556Q) (CLOCKDIFFERENCE 303560Q . 304145Q) (\SECONDSCLOCKGREATERP 304147Q . 304756Q) (\CLOCKGREATERP
304760Q . 305527Q) (\RCLOCK0 305531Q . 305752Q)) (305755Q 307057Q (CLOCK0 305767Q . 307055Q)))))
STOP