public class SwapFile { public static OpenFile swapFile; private static String swapName; private static int PAGESIZE = Machine.processor().pageSize; public static List<Integer> freePages; public static List<Integer> allocatedPages; private static Lock swapLock; private static byte[] memory = Machine.processor().getMemory(); public static void initialize(String filename) { swapFile = ThreadedKernel.fileSystem.open(filename, true); swapName = filename; freePages = new LinkedList<Integer>(); allocatedPages = new LinkedList<Integer>(); swapLock = new Lock(); } public static void close() { swapFile.close(); ThreadedKernel.fileSystem.remove(swapName); } public static int insertPage(int spn, int ppn) { swapLock.acquire(); int numBits = swapFile.write(spn * PAGESIZE, memory, ppn * PAGESIZE, PAGESIZE); // assert that numBits == PAGESIZE allocatedPages.add(spn); swapLock.release(); return spn; } /* we will try to allocate a free page from the freepages*/ public static int insertPage(int ppn) { int numBits = 0; int spn = swapFile.length() / PAGESIZE; if (freePages.size() > 0) { spn = freePages.remove(0); } return insertPage(spn, ppn); } public static void readPage(int spn, int ppn) { if (allocatedPages.contains(spn)) { swapLock.acquire(); swapFile.read(spn * PAGESIZE, memory, ppn * PAGESIZE, PAGESIZE); swapLock.release(); } else { } } public static void free(int page) { swapLock.acquire(); freePages.add(page); swapLock.release(); } }
private void syncTLB() { for (int i = 0; i < Machine.processor().getTLBSize(); i++) { TranslationEntry tE = Machine.processor().readTLBEntry(i); if (tE.valid) { pageTable[tE.vpn].dirty = tE.dirty; pageTable[tE.vpn].used = tE.used; } } }
/** * Save the state of this process in preparation for a context switch. Called by * <tt>UThread.saveState()</tt>. */ public void saveState() { for (int i = 0; i < Machine.processor().getTLBSize(); i++) { TranslationEntry tE = Machine.processor().readTLBEntry(i); if (tE.valid) { pageTable[tE.vpn].dirty = tE.dirty; pageTable[tE.vpn].used = tE.used; } tE.valid = false; Machine.processor().writeTLBEntry(i, tE); // savedState[i] = tE.vpn; } }
/** * The exception handler. This handler is called by the processor whenever * a user instruction causes a processor exception. * * <p> * When the exception handler is invoked, interrupts are enabled, and the * processor's cause register contains an integer identifying the cause of * the exception (see the <tt>exceptionZZZ</tt> constants in the * <tt>Processor</tt> class). If the exception involves a bad virtual * address (e.g. page fault, TLB miss, read-only, bus error, or address * error), the processor's BadVAddr register identifies the virtual address * that caused the exception. */ public void exceptionHandler() { Lib.assert(KThread.currentThread() instanceof UThread); UserProcess process = ((UThread) KThread.currentThread()).process; int cause = Machine.processor().readRegister(Processor.regCause); process.handleException(cause); }
/** * Transfer data from the specified array to this process's virtual memory. This method handles * address translation details. This method must <i>not</i> destroy the current process if an * error occurs, but instead should return the number of bytes successfully copied (or zero if no * data could be copied). * * @param vaddr the first byte of virtual memory to write. * @param data the array containing the data to transfer. * @param offset the first byte to transfer from the array. * @param length the number of bytes to transfer from the array to virtual memory. * @return the number of bytes successfully transferred. */ public int writeVirtualMemory(int vaddr, byte[] data, int offset, int length) { Lib.assertTrue(offset >= 0 && length >= 0 && offset + length <= data.length); byte[] memory = Machine.processor().getMemory(); int transferred = 0; while (length > 0 && offset < data.length) { int addrOffset = vaddr % 1024; int virtualPage = vaddr / 1024; if (virtualPage >= pageTable.length || virtualPage < 0) { break; } TranslationEntry pte = pageTable[virtualPage]; if (!pte.valid || pte.readOnly) { break; } pte.used = true; pte.dirty = true; int physPage = pte.ppn; int physAddr = physPage * 1024 + addrOffset; int transferLength = Math.min(data.length - offset, Math.min(length, 1024 - addrOffset)); System.arraycopy(data, offset, memory, physAddr, transferLength); vaddr += transferLength; offset += transferLength; length -= transferLength; transferred += transferLength; } return transferred; }
/** * Initialize this kernel. Creates a synchronized console and sets the * processor's exception handler. */ public void initialize(String[] args) { super.initialize(args); console = new SynchConsole(Machine.console()); Machine.processor().setExceptionHandler(new Runnable() { public void run() { exceptionHandler(); } }); }
@Override protected void init() { super.init(); System.out.println("\ninitializing VMGrader.."); System.out.println("physical pages = " + Machine.processor().getNumPhysPages()); if (hasArgument(SwapFile)) swapFile = getStringArgument(SwapFile); }
@Override protected int handleTestSystemCall(int type, int a0, int a1, int a2) { switch (type) { case ActionPhyPages: return Machine.processor().getNumPhysPages(); case ActionGetSwapSize: return getSwapSize(); default: return super.handleTestSystemCall(type, a0, a1, a2); } }
/** * Handle a user exception. Called by <tt>UserKernel.exceptionHandler()</tt> . The <i>cause</i> * argument identifies which exception occurred; see the <tt>Processor.exceptionZZZ</tt> * constants. * * @param cause the user exception that occurred. */ public void handleException(int cause) { Processor processor = Machine.processor(); switch (cause) { case Processor.exceptionTLBMiss: handleTLBMiss(); break; default: super.handleException(cause); break; } }
/** * Initialize the processor's registers in preparation for running the program loaded into this * process. Set the PC register to point at the start function, set the stack pointer register to * point at the top of the stack, set the A0 and A1 registers to argc and argv, respectively, and * initialize all other registers to 0. */ public void initRegisters() { Processor processor = Machine.processor(); // by default, everything's 0 for (int i = 0; i < processor.numUserRegisters; i++) processor.writeRegister(i, 0); // initialize PC and SP according processor.writeRegister(Processor.regPC, initialPC); processor.writeRegister(Processor.regSP, initialSP); // initialize the first two argument registers to argc and argv processor.writeRegister(Processor.regA0, argc); processor.writeRegister(Processor.regA1, argv); }
/** * Allocates memory for this process, and loads the COFF sections into memory. If this returns * successfully, the process will definitely be run (this is the last step in process * initialization that can fail). * * @return <tt>true</tt> if the sections were successfully loaded. */ protected boolean loadSections() { if (numPages > Machine.processor().getNumPhysPages()) { coff.close(); Lib.debug(dbgProcess, "\tinsufficient physical memory"); return false; } pageTable = new TranslationEntry[numPages]; for (int i = 0; i < numPages; i++) { int physPage = UserKernel.allocatePage(); if (physPage < 0) { Lib.debug(dbgProcess, "\tunable to allocate pages; tried " + numPages + ", did " + i); for (int j = 0; j < i; j++) { if (pageTable[j].valid) { UserKernel.deallocatePage(pageTable[j].ppn); pageTable[j].valid = false; } } coff.close(); return false; } pageTable[i] = new TranslationEntry(i, physPage, true, false, false, false); } // load sections for (int s = 0; s < coff.getNumSections(); s++) { CoffSection section = coff.getSection(s); Lib.debug( dbgProcess, "\tinitializing " + section.getName() + " section (" + section.getLength() + " pages)"); for (int i = 0; i < section.getLength(); i++) { int vpn = section.getFirstVPN() + i; // for now, just assume virtual addresses=physical addresses int ppn = pageTable[vpn].ppn; section.loadPage(i, ppn); if (section.isReadOnly()) { pageTable[vpn].readOnly = true; } } } coff.close(); return true; }
/** Allocate a new process. */ public UserProcess() { map = new HashMap<Integer, childProcess>(); int numPhysPages = Machine.processor().getNumPhysPages(); pageTable = new TranslationEntry[numPhysPages]; for (int i = 0; i < numPhysPages; i++) pageTable[i] = new TranslationEntry(i, i, true, false, false, false); this.process_id = unique; unique++; openfiles = new HashMap<Integer, OpenFile>(); available_descriptors = new ArrayList<Integer>(Arrays.asList(2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)); openfiles.put(0, UserKernel.console.openForReading()); openfiles.put(1, UserKernel.console.openForWriting()); }
/** * Handle a user exception. Called by <tt>UserKernel.exceptionHandler()</tt>. The <i>cause</i> * argument identifies which exception occurred; see the <tt>Processor.exceptionZZZ</tt> * constants. * * @param cause the user exception that occurred. */ public void handleException(int cause) { Processor processor = Machine.processor(); switch (cause) { case Processor.exceptionSyscall: int result = handleSyscall( processor.readRegister(Processor.regV0), processor.readRegister(Processor.regA0), processor.readRegister(Processor.regA1), processor.readRegister(Processor.regA2), processor.readRegister(Processor.regA3)); processor.writeRegister(Processor.regV0, result); processor.advancePC(); break; default: Lib.debug(dbgProcess, "Unexpected exception: " + Processor.exceptionNames[cause]); handleExit(-1); Lib.assertNotReached("Unexpected exception"); } }
private PageTable() { table = new HashMap<PidAndVpn, TranslationEntry>(); globalTable = new TranslationEntryWithPid[Machine.processor().getNumPhysPages()]; }
/** * Restore the state of this process after a context switch. Called by * <tt>UThread.restoreState()</tt>. */ public void restoreState() { Machine.processor().setPageTable(pageTable); }
/** A <tt>UserProcess</tt> that supports demand-paging. */ public class VMProcess extends UserProcess { /** Allocate a new process. */ public VMProcess() { super(); } /** * Save the state of this process in preparation for a context switch. Called by * <tt>UThread.saveState()</tt>. */ public void saveState() { for (int i = 0; i < Machine.processor().getTLBSize(); i++) { TranslationEntry tE = Machine.processor().readTLBEntry(i); if (tE.valid) { pageTable[tE.vpn].dirty = tE.dirty; pageTable[tE.vpn].used = tE.used; } tE.valid = false; Machine.processor().writeTLBEntry(i, tE); // savedState[i] = tE.vpn; } } /** * Restore the state of this process after a context switch. Called by * <tt>UThread.restoreState()</tt>. */ public void restoreState() { /*for(int i = 0; i < Machine.processor().getTLBSize(); i++) { TranslationEntry tE = Machine.processor().readTLBEntry(i); tE.valid = false; Machine.processor().writeTLBEntry(i, tE); } for(int i = 0; i < Machine.processor().getTLBSize(); i++) { if(pageTable[savedState[i]].valid) { Machine.processor().writeTLBEntry(i, pageTable[savedState[i]]); } }*/ } /** * Initializes page tables for this process so that the executable can be demand-paged. * * @return <tt>true</tt> if successful. */ protected boolean loadSections() { UserKernel.memoryLock.acquire(); pageTable = new TranslationEntry[numPages]; for (int vpn = 0; vpn < numPages; vpn++) { pageTable[vpn] = new TranslationEntry(vpn, -1, false, false, false, false); } UserKernel.memoryLock.release(); // load sections for (int s = 0; s < coff.getNumSections(); s++) { CoffSection section = coff.getSection(s); Lib.debug( dbgProcess, "\tinitializing " + section.getName() + " section (" + section.getLength() + " pages)"); for (int i = 0; i < section.getLength(); i++) { int vpn = section.getFirstVPN() + i; pageTable[vpn].readOnly = section.isReadOnly(); // section.loadPage(i, pinVirtualPage(vpn, false)); } } return true; } /** Release any resources allocated by <tt>loadSections()</tt>. */ protected void unloadSections() { for (int vpn = 0; vpn < pageTable.length; vpn++) { if (pageTable[vpn].valid) { UserKernel.freePages.add(new Integer(pageTable[vpn].ppn)); // IPT[pageTable[vpn].ppn] = null; } } } /** * Handle a user exception. Called by <tt>UserKernel.exceptionHandler()</tt> . The <i>cause</i> * argument identifies which exception occurred; see the <tt>Processor.exceptionZZZ</tt> * constants. * * @param cause the user exception that occurred. */ public void handleException(int cause) { Processor processor = Machine.processor(); switch (cause) { case Processor.exceptionTLBMiss: handleTLBMiss(); break; default: super.handleException(cause); break; } } protected int pinVirtualPage(int vpn, boolean isUserWrite) { int ppn = super.pinVirtualPage(vpn, isUserWrite); if (ppn >= 0) { if (isUserWrite) { IPT[ppn].pinCount = true; } } else { if (vpn < 0 || vpn >= pageTable.length) return -1; if (!pageTable[vpn].valid) { allocatePage(vpn); } ppn = super.pinVirtualPage(vpn, isUserWrite); if (isUserWrite) { IPT[ppn].pinCount = true; } } return ppn; } protected void unpinVirtualPage(int vpn) { int ppn = super.pinVirtualPage(vpn, false); if (ppn >= 0) { IPT[ppn].pinCount = false; unpinnedPageLock.acquire(); unpinnedPage.wake(); unpinnedPageLock.release(); } } public void handleTLBMiss() { int vaddr = Machine.processor().readRegister(Processor.regBadVAddr); int vpn = Processor.pageFromAddress(vaddr); allocatePage(vpn); } private void syncTLB() { for (int i = 0; i < Machine.processor().getTLBSize(); i++) { TranslationEntry tE = Machine.processor().readTLBEntry(i); if (tE.valid) { pageTable[tE.vpn].dirty = tE.dirty; pageTable[tE.vpn].used = tE.used; } } } private void allocatePage(int vpn) { // System.out.println("TLBMiss: VPN:" + vpn + " of Process " + processID); TranslationEntry t = pageTable[vpn]; if (!t.valid) { // System.out.println("Allocating VPN: " + t.vpn); lock.acquire(); if (UserKernel.freePages.size() > 0) { int ppn = ((Integer) UserKernel.freePages.removeFirst()).intValue(); t.valid = true; if (!t.dirty) { t.ppn = ppn; IPT[ppn] = new IPTEntry(); IPT[ppn].process = this; IPT[ppn].tE = t; boolean isCoffSection = false; for (int s = 0; s < coff.getNumSections(); s++) { if (isCoffSection) { break; } CoffSection section = coff.getSection(s); if (section.getFirstVPN() > t.vpn) { continue; } for (int i = 0; i < section.getLength(); i++) { int svpn = section.getFirstVPN() + i; if (svpn == t.vpn) { section.loadPage(i, pinVirtualPage(t.vpn, false)); // System.out.println("VPN \"" + t.vpn + "\" is a COFF section"); // System.out.println("COFF section loaded into VPN \"" + t.vpn + "\" PPN \"" + // t.ppn + "\""); isCoffSection = true; break; } } } if (!isCoffSection) { // System.out.println("VPN \"" + t.vpn + "\" is NOT a COFF section"); // System.out.println("PPN \"" + t.ppn + "\" Zero'd Out"); byte[] data = new byte[Processor.pageSize]; // writeVirtualMemory(t.vpn, data, 0, Processor.pageSize); byte[] memory = Machine.processor().getMemory(); System.arraycopy(data, 0, memory, t.ppn * Processor.pageSize, Processor.pageSize); } } else // Dirty { // System.out.println("VPN \"" + t.vpn + "\" has been swapped out, swaping into // PPN \"" + ppn + "\""); int spn = t.ppn; byte[] data = new byte[pageSize]; byte[] memory = Machine.processor().getMemory(); OpenFile swap = ThreadedKernel.fileSystem.open(".Nachos.swp", false); swap.read(spn * pageSize, memory, ppn * pageSize, pageSize); swap.close(); t.ppn = ppn; // System.out.println(spn); freeSwapPages.set(spn, true); IPT[ppn] = new IPTEntry(); IPT[ppn].process = this; IPT[ppn].tE = t; // System.out.println("SPN \"" + spn + "\" has been swapped in."); } } else { syncTLB(); // Clock Algorithm unpinnedPageLock.acquire(); int numPinnedPages = 0; while (IPT[victim] == null || IPT[victim].tE.used || IPT[victim].pinCount) { if (IPT[victim] != null) { IPT[victim].tE.used = false; // System.out.println("PPN " + victim + " is used."); } if (IPT[victim].pinCount) { numPinnedPages++; // System.out.println("PPN " + victim + " is pinned."); } if (numPinnedPages == IPT.length) unpinnedPage.sleep(); // System.out.println("This Process is " + this.processID + " and the IPT's // process is " + IPT[victim].processID); victim = (victim + 1) % Machine.processor().getNumPhysPages(); } // System.out.println("PPN " + victim + " will be evicted."); unpinnedPageLock.release(); int evict = IPT[victim].tE.vpn; VMProcess evictedOwner = IPT[victim].process; int evictedPPN = victim; victim = (victim + 1) % Machine.processor().getNumPhysPages(); // System.out.println("Not enough pysical memory, evicting VPN \"" + evict + "\" of process // " + evictedOwner.processID); // Swap Files if (evictedOwner.isDirty(evict)) { // System.out.println("VPN \"" + evict + "\" is dirty, swapping out."); OpenFile swap = ThreadedKernel.fileSystem.open(".Nachos.swp", false); int spn = 0; for (spn = 0; spn < freeSwapPages.size(); spn++) { if (freeSwapPages.get(spn)) { break; } } if (spn == freeSwapPages.size()) { freeSwapPages.add(false); } else { freeSwapPages.set(spn, false); } UserKernel.freePages.add(evictedPPN); byte[] memory = Machine.processor().getMemory(); swap.write(spn * pageSize, memory, evictedPPN * pageSize, pageSize); swap.close(); if (evictedOwner.processID != this.processID) { evictedOwner.evict(evict, spn); } else { pageTable[evict].ppn = spn; pageTable[evict].valid = false; } for (int i = 0; i < Machine.processor().getTLBSize(); i++) { TranslationEntry tE = Machine.processor().readTLBEntry(i); if (tE.vpn == evict && tE.ppn == evictedPPN) { // System.out.println("TLBEntry " + i + " invalid"); tE.valid = false; Machine.processor().writeTLBEntry(i, tE); } } lock.release(); // System.out.println("VPN \"" + evict + "\" of Process " + this.processID + " // swapped out to SPN \"" + spn + "\"."); // Machine.processor().readTLBEntry(evict).valid = false; allocatePage(vpn); return; } else { if (evictedOwner.processID != this.processID) { // System.out.println("Evicted VPN " + evict + " of Process " + this.processID); evictedOwner.evict(evict); } else { pageTable[evict].valid = false; } UserKernel.freePages.add(evictedPPN); for (int i = 0; i < Machine.processor().getTLBSize(); i++) { TranslationEntry tE = Machine.processor().readTLBEntry(i); if (tE.vpn == evict && tE.ppn == evictedPPN) { // System.out.println("TLBEntry " + i + " invalid"); tE.valid = false; Machine.processor().writeTLBEntry(i, tE); } } lock.release(); allocatePage(vpn); return; } } lock.release(); } for (int i = 0; i < Machine.processor().getTLBSize(); i++) { TranslationEntry tE = Machine.processor().readTLBEntry(i); if (!tE.valid) { // System.out.println("Evicted TLBEntry " + i); Machine.processor().writeTLBEntry(i, t); // System.out.println(t.valid); return; } } syncTLB(); int evictedEntry = (int) (Math.random() * Machine.processor().getTLBSize()); TranslationEntry tE = Machine.processor().readTLBEntry(evictedEntry); pageTable[tE.vpn] = tE; Machine.processor().writeTLBEntry(evictedEntry, t); // System.out.println("Evicted TLBEntry " + evictedEntry + " randomly"); // System.out.println("TE entered is VPN \"" + t.vpn + "\" PPN \"" + t.ppn + "\""); } public void evict(int vpn, int spn) { pageTable[vpn].ppn = spn; pageTable[vpn].valid = false; } public void evict(int vpn) { pageTable[vpn].valid = false; } public boolean isDirty(int vpn) { return pageTable[vpn].dirty; } private static final int pageSize = Processor.pageSize; private static final char dbgProcess = 'a'; private static final char dbgVM = 'v'; private static int victim = 0; private static LinkedList<Boolean> freeSwapPages = new LinkedList<Boolean>(); private static IPTEntry[] IPT = new IPTEntry[Machine.processor().getNumPhysPages()]; private class IPTEntry { public VMProcess process; public TranslationEntry tE; public boolean pinCount; } public static Lock unpinnedPageLock = new Lock(); public static Condition unpinnedPage = new Condition(unpinnedPageLock); public static Lock lock = new Lock(); private int[] savedState = new int[Machine.processor().getTLBSize()]; }
public void handleTLBMiss() { int vaddr = Machine.processor().readRegister(Processor.regBadVAddr); int vpn = Processor.pageFromAddress(vaddr); allocatePage(vpn); }
private void allocatePage(int vpn) { // System.out.println("TLBMiss: VPN:" + vpn + " of Process " + processID); TranslationEntry t = pageTable[vpn]; if (!t.valid) { // System.out.println("Allocating VPN: " + t.vpn); lock.acquire(); if (UserKernel.freePages.size() > 0) { int ppn = ((Integer) UserKernel.freePages.removeFirst()).intValue(); t.valid = true; if (!t.dirty) { t.ppn = ppn; IPT[ppn] = new IPTEntry(); IPT[ppn].process = this; IPT[ppn].tE = t; boolean isCoffSection = false; for (int s = 0; s < coff.getNumSections(); s++) { if (isCoffSection) { break; } CoffSection section = coff.getSection(s); if (section.getFirstVPN() > t.vpn) { continue; } for (int i = 0; i < section.getLength(); i++) { int svpn = section.getFirstVPN() + i; if (svpn == t.vpn) { section.loadPage(i, pinVirtualPage(t.vpn, false)); // System.out.println("VPN \"" + t.vpn + "\" is a COFF section"); // System.out.println("COFF section loaded into VPN \"" + t.vpn + "\" PPN \"" + // t.ppn + "\""); isCoffSection = true; break; } } } if (!isCoffSection) { // System.out.println("VPN \"" + t.vpn + "\" is NOT a COFF section"); // System.out.println("PPN \"" + t.ppn + "\" Zero'd Out"); byte[] data = new byte[Processor.pageSize]; // writeVirtualMemory(t.vpn, data, 0, Processor.pageSize); byte[] memory = Machine.processor().getMemory(); System.arraycopy(data, 0, memory, t.ppn * Processor.pageSize, Processor.pageSize); } } else // Dirty { // System.out.println("VPN \"" + t.vpn + "\" has been swapped out, swaping into // PPN \"" + ppn + "\""); int spn = t.ppn; byte[] data = new byte[pageSize]; byte[] memory = Machine.processor().getMemory(); OpenFile swap = ThreadedKernel.fileSystem.open(".Nachos.swp", false); swap.read(spn * pageSize, memory, ppn * pageSize, pageSize); swap.close(); t.ppn = ppn; // System.out.println(spn); freeSwapPages.set(spn, true); IPT[ppn] = new IPTEntry(); IPT[ppn].process = this; IPT[ppn].tE = t; // System.out.println("SPN \"" + spn + "\" has been swapped in."); } } else { syncTLB(); // Clock Algorithm unpinnedPageLock.acquire(); int numPinnedPages = 0; while (IPT[victim] == null || IPT[victim].tE.used || IPT[victim].pinCount) { if (IPT[victim] != null) { IPT[victim].tE.used = false; // System.out.println("PPN " + victim + " is used."); } if (IPT[victim].pinCount) { numPinnedPages++; // System.out.println("PPN " + victim + " is pinned."); } if (numPinnedPages == IPT.length) unpinnedPage.sleep(); // System.out.println("This Process is " + this.processID + " and the IPT's // process is " + IPT[victim].processID); victim = (victim + 1) % Machine.processor().getNumPhysPages(); } // System.out.println("PPN " + victim + " will be evicted."); unpinnedPageLock.release(); int evict = IPT[victim].tE.vpn; VMProcess evictedOwner = IPT[victim].process; int evictedPPN = victim; victim = (victim + 1) % Machine.processor().getNumPhysPages(); // System.out.println("Not enough pysical memory, evicting VPN \"" + evict + "\" of process // " + evictedOwner.processID); // Swap Files if (evictedOwner.isDirty(evict)) { // System.out.println("VPN \"" + evict + "\" is dirty, swapping out."); OpenFile swap = ThreadedKernel.fileSystem.open(".Nachos.swp", false); int spn = 0; for (spn = 0; spn < freeSwapPages.size(); spn++) { if (freeSwapPages.get(spn)) { break; } } if (spn == freeSwapPages.size()) { freeSwapPages.add(false); } else { freeSwapPages.set(spn, false); } UserKernel.freePages.add(evictedPPN); byte[] memory = Machine.processor().getMemory(); swap.write(spn * pageSize, memory, evictedPPN * pageSize, pageSize); swap.close(); if (evictedOwner.processID != this.processID) { evictedOwner.evict(evict, spn); } else { pageTable[evict].ppn = spn; pageTable[evict].valid = false; } for (int i = 0; i < Machine.processor().getTLBSize(); i++) { TranslationEntry tE = Machine.processor().readTLBEntry(i); if (tE.vpn == evict && tE.ppn == evictedPPN) { // System.out.println("TLBEntry " + i + " invalid"); tE.valid = false; Machine.processor().writeTLBEntry(i, tE); } } lock.release(); // System.out.println("VPN \"" + evict + "\" of Process " + this.processID + " // swapped out to SPN \"" + spn + "\"."); // Machine.processor().readTLBEntry(evict).valid = false; allocatePage(vpn); return; } else { if (evictedOwner.processID != this.processID) { // System.out.println("Evicted VPN " + evict + " of Process " + this.processID); evictedOwner.evict(evict); } else { pageTable[evict].valid = false; } UserKernel.freePages.add(evictedPPN); for (int i = 0; i < Machine.processor().getTLBSize(); i++) { TranslationEntry tE = Machine.processor().readTLBEntry(i); if (tE.vpn == evict && tE.ppn == evictedPPN) { // System.out.println("TLBEntry " + i + " invalid"); tE.valid = false; Machine.processor().writeTLBEntry(i, tE); } } lock.release(); allocatePage(vpn); return; } } lock.release(); } for (int i = 0; i < Machine.processor().getTLBSize(); i++) { TranslationEntry tE = Machine.processor().readTLBEntry(i); if (!tE.valid) { // System.out.println("Evicted TLBEntry " + i); Machine.processor().writeTLBEntry(i, t); // System.out.println(t.valid); return; } } syncTLB(); int evictedEntry = (int) (Math.random() * Machine.processor().getTLBSize()); TranslationEntry tE = Machine.processor().readTLBEntry(evictedEntry); pageTable[tE.vpn] = tE; Machine.processor().writeTLBEntry(evictedEntry, t); // System.out.println("Evicted TLBEntry " + evictedEntry + " randomly"); // System.out.println("TE entered is VPN \"" + t.vpn + "\" PPN \"" + t.ppn + "\""); }