I need to create a demand paging simulator in java, and I am having trouble gett
ID: 3803708 • Letter: I
Question
I need to create a demand paging simulator in java, and I am having trouble getting the LRU part of the code to work properly. Here is what I have so far, I just need the LRU algorithm to be added before the LFU method.
import java.util.ArrayList;
import java.util.LinkedList;
public class Algorithms {
private int pframes = 4; //[0-3]
private String referenceString; //Sequence of pages to be read
private int pageMethod; //0=fifo, 1=opt, 2=lru, 3=lfu;
private int numOfAvaiableFrames = 4;
private int numberOfPageFaults = 0;
//constructor
// set the reference string and algorthm type
public Algorithms(String referenceString, int pageMethod) {
this.referenceString = referenceString;
this.pageMethod = pageMethod;
}
//executes the solution
public void run() {
switch (this.pageMethod) {
case 0: // fifo
fifo(this.referenceString);
break;
case 1: // opt
opt(this.referenceString);
break;
case 2: // lru
lru(this.referenceString);
break;
case 3: //lfu
lfu(this.referenceString);
break;
default:
}
System.out.println("**************** RESULTS ********************************************");
System.out.println(" " + "Simulation complete: " + this.referenceString.length() + " pages processed.");
System.out.println(" " + "Total faults: " + this.numberOfPageFaults);
System.out.println("*********************************************************************");
}
// FIFO algorithm using the stored reference
@SuppressWarnings("empty-statement")
void fifo(String rs) {
// Set up array for physical frames
ArrayList physicalFrames = new ArrayList();
physicalFrames.add(-1);
physicalFrames.add(-1);
physicalFrames.add(-1);
physicalFrames.add(-1);
int loopFault;
int victimFrame;
//for each vframe (character in string) referenced to process
for (int i = 0; i
loopFault = 0;
victimFrame = -1;
//covnvert current ref to int
int currentPage = Integer.parseInt(Character.toString(this.referenceString.charAt(i)));
Integer integerCurrentPage = new Integer(currentPage);
System.out.println("Processing frame " + currentPage + " (frame " + i + " of " + this.referenceString.length() + ")"); //info
//If there are null pframes add to that (also make sure it isn't already in there)
if (this.numOfAvaiableFrames > 0 && (!physicalFrames.contains(integerCurrentPage))) {
//System.out.println( "ADD ITEM TO OPEN PHY FRAME ");
//push simulate
physicalFrames.set(3, physicalFrames.get(2));
physicalFrames.set(2, physicalFrames.get(1));
physicalFrames.set(1, physicalFrames.get(0));
physicalFrames.set(0, currentPage);
loopFault = 1; //for display processing
this.numberOfPageFaults++; //track these
this.numOfAvaiableFrames--;
} else {
// either do nothing if there is a match
if (physicalFrames.indexOf(currentPage) // or No Match, time to make a victim and pagefault
victimFrame = Integer.parseInt(physicalFrames.get(3).toString());
physicalFrames.set(3, physicalFrames.get(2));
physicalFrames.set(2, physicalFrames.get(1));
physicalFrames.set(1, physicalFrames.get(0));
physicalFrames.set(0, currentPage);
loopFault = 1; //for display processing
this.numberOfPageFaults++;
}
}
//do a printout
System.out.print("Ref String pg: " + currentPage + " |" + physicalFrames.toString().replaceAll("-1", "-"));
if (loopFault == 1) {
System.out.print(" PAGE FAULT ");
}
if (victimFrame != -1) {
System.out.print(" VICTIM " + victimFrame);
}
System.out.print(" ---------------------------------- (press enter to continue) ");
//System.out.print("PHYSICAL FRAMES:"+ physicalFrames.get(0).toString()+physicalFrames.get(1).toString());
try {
System.in.read();
} catch (Exception e) {
};
} //end for each ref
}//--------------------------------------------------------
// OPT algorithm using the stored reference string
@SuppressWarnings("empty-statement")
void opt(String rs) {
// Set up array for physical frames
ArrayList physicalFrames = new ArrayList();
int[] futureUseBit = new int[4];
futureUseBit[0] = 0;
futureUseBit[1] = 0;
futureUseBit[2] = 0;
futureUseBit[3] = 0;
int loopFault;
int victimFrame;
//for each vframe (character in string) referenced to process
for (int i = 0; i
loopFault = 0;
victimFrame = -1;
//covnvert current ref to int
int currentPage = Integer.parseInt(Character.toString(this.referenceString.charAt(i)));
Integer integerCurrentPage = new Integer(currentPage);
System.out.println("Processing frame " + currentPage + " (frame " + i + " of " + this.referenceString.length() + ")"); //info
//If there are null pframes add to that (also make sure it isn't already in there)
if (this.numOfAvaiableFrames > 0 && (!physicalFrames.contains(integerCurrentPage))) {
for (Object physicalFrame : physicalFrames) {
if (Integer.parseInt(physicalFrame.toString()) >= 0) {
}
}
physicalFrames.add(currentPage);
int addedat = physicalFrames.indexOf(currentPage);
loopFault = 1; //for display processing
this.numberOfPageFaults++; //track these
this.numOfAvaiableFrames--;
} else {
// either do nothing if there is a match
// determine number of future uses for each item in "physical frame" - pf
for (int pf = 0; pf
int numOfFutureUses = 0;
for (int rin = i; rin
if (Integer.parseInt(physicalFrames.get(pf).toString())
== Integer.parseInt(Character.toString(this.referenceString.charAt(rin)))) {
numOfFutureUses += 1;
}
}
futureUseBit[pf] = numOfFutureUses;
}
if (physicalFrames.indexOf(currentPage) // or No Match, time to make a victim and pagefault
int leastUsefulElement = 0;
int smallest = 7;
for (int c = 0; c
if (futureUseBit[c] leastUsefulElement = c;
smallest = futureUseBit[c];
}
}
victimFrame = Integer.parseInt(physicalFrames.get(leastUsefulElement).toString());
physicalFrames.set(leastUsefulElement, currentPage);
loopFault = 1; //for display processing
this.numberOfPageFaults++;
}
}
//System.out.println("futureUseBit " + futureUseBit[0] + futureUseBit[1] + futureUseBit[2] + futureUseBit[3]);
//do a printout
System.out.print("Ref String pg: " + currentPage + " |" + physicalFrames.toString().replaceAll("-1", "-"));
if (loopFault == 1) {
System.out.print(" PAGE FAULT ");
}
if (victimFrame != -1) {
System.out.print(" VICTIM " + victimFrame);
}
System.out.print(" ---------------------------------- (press ENTER to continue) ");
//System.out.print("PHYSICAL FRAMES:"+ physicalFrames.get(0).toString()+physicalFrames.get(1).toString());
try {
System.in.read();
} catch (Exception e) {
};
} //end for each ref
}//--------------------------------------------------------
//LFU algorithm using the stored reference string
@SuppressWarnings("empty-statement")
void lfu(String rs) {
// Set up array for physical frames
ArrayList physicalFrames = new ArrayList();
int[] sinceUseBit = new int[4];
sinceUseBit[0] = 0;
sinceUseBit[1] = 0;
sinceUseBit[2] = 0;
sinceUseBit[3] = 0;
int loopFault;
int victimFrame;
//for each vframe (character in string) referenced to process
for (int i = 0; i
loopFault = 0;
victimFrame = -1;
//covnvert current ref to int
int currentPage = Integer.parseInt(Character.toString(this.referenceString.charAt(i)));
Integer integerCurrentPage = new Integer(currentPage);
System.out.println("Processing frame " + currentPage + " (frame " + i + " of " + this.referenceString.length() + ")"); //info
//If there are null pframes add to that (also make sure it isn't already in there)
if (this.numOfAvaiableFrames > 0 && (!physicalFrames.contains(integerCurrentPage))) {
physicalFrames.add(currentPage);
int addedat = physicalFrames.indexOf(currentPage);
sinceUseBit[addedat] += 1;
loopFault = 1; //for display processing
this.numberOfPageFaults++; //track these
this.numOfAvaiableFrames--;
} else {
// either do nothing if there is a match
int addedat = physicalFrames.indexOf(currentPage);
try {
sinceUseBit[addedat] += 1;
} catch (Exception e) {
}
if (physicalFrames.indexOf(currentPage) // or No Match, time to make a victim and pagefault
int leastFrequentElement = 0;
int smallest = 7;
for (int c = 0; c
if (sinceUseBit[c] leastFrequentElement = c - 1;
}
}
victimFrame = Integer.parseInt(physicalFrames.get(leastFrequentElement).toString());
physicalFrames.set(leastFrequentElement, currentPage);
sinceUseBit[leastFrequentElement] = 0;
loopFault = 1; //for display processing
this.numberOfPageFaults++;
}
}
//do a printout
System.out.print("Ref String pg: " + currentPage + " |" + physicalFrames.toString().replaceAll("-1", "-"));
if (loopFault == 1) {
System.out.print(" PAGE FAULT ");
}
if (victimFrame != -1) {
System.out.print(" VICTIM " + victimFrame);
}
//Press Enter
System.out.print(" ---------------------------------- (press ENTER to continue) ");
try {
System.in.read();
} catch (Exception e) {
};
} //end for each ref
}
}
Explanation / Answer
Package com;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class FWorks implements Iterable<Integer> {
private List<Integer> FWorks;
public FWorks(int numberOfFWorks) {
this.FWorks = new ArrayList<>(numberOfFWorks);
for (int i = 0; i < numberOfFWorks; i++) {
FWorks.add(-1);
}
}
public void deallocateFWorks() {
int len = FWorks.size();
for (int i = 0; i < len; i++) {
FWorks.set(i, -1);
}
}
public boolean contains(int RefWork) {
return indexOf(RefWork) > -1;
}
public int indexOf(int RefWork) {
return FWorks.indexOf(RefWork);
}
public int set(int index, int RefWork) {
return FWorks.set(index, RefWork);
}
public void swap(int victim, int RefWork) {
set(indexOf(victim), RefWork);
}
public int get(int index) {
return FWorks.get(index);
}
public boolean thereIsAnEmptyFWork() {
return contains(-1);
}
public void copyAll(FWorks f) {
FWorks.clear();
FWorks = new ArrayList<>(f.FWorks);
}
public int getEmptyFWork() {
return indexOf(-1);
}
@Override
public Iterator<Integer> iterator() {
return FWorks.iterator();
}
}
package com
public class RefWork {
private int RefWork;
private FWorks FWorks;
public RefWork(int RefWork, int numberOfFWorks) {
this(RefWork, new FWorks(numberOfFWorks));
}
private RefWork(int RefWork, FWorks FWorks) {
this.RefWork = RefWork;
this.FWorks = FWorks;
}
public int getRefWork() {
return RefWork;
}
public FWorks getFWorks() {
return FWorks;
}
}
import java.util.LinkedList;
import com.model.FWorks;
import com.model.RefWork;
public class LRUPageReplacement extends AbstractPageReplacement {
@Override
protected void allocate() {
LinkedList<Integer> queue = new LinkedList<>();
FWorks past = new FWorks(FWorks);
for(RefWork r: RefWorks){
int ref = r.getRefWork();
FWorks f = r.getFWorks();
f.copyAll(past);
queue.remove(new Integer(ref));
queue.addLast(ref);
System.out.println("FIFOAlloc.allocate( )" + ref + " " + f.contains(ref));
if(!f.contains(ref)){
faults++;
if(f.thereIsAnEmptyFWork()){
f.set(f.getEmptyFWork(), ref);
}else{
int victim = queue.removeFirst();
f.swap(victim, ref);
}
}
past.copyAll(f);
}
}
package com
public interface SimInter {
public boolean hasMoreSteps();
public void step();
}
Package com;
import java.awt.Point;
import java.awt.Rectangle;
import java.util.ArrayList;
import java.util.List;
import javax.swing.JTable;
import javax.swing.JViewport;
import javax.swing.table.DefaultTableModel;
import com.github.pageallocation.algorithms.model.Reference;
public class DemandPageSimr implements SimInter {
private JTable table;
private DefaultTableModel model;
private static Reference EMPTY = new Reference(-1,0);
private int i, k;
private int frames;
private int numberOfSteps;
private List<Reference> references;
public DemandPageSimr(JTable table, DefaultTableModel model){
this.table = table;
this.model = model;
}
@Override
public boolean hasMoreSteps() {
return numberOfSteps > 0;
}
@Override
public void step() {
if (hasMoreSteps()) {
scrollToVisible(table, k, i);
int val = getValue(i,k);
if ( val == -1)
table.getModel().setValueAt("X", k, i);
else
table.getModel().setValueAt("" + val, k, i);
if (k == frames - 1) {
k = 0;
i++;
} else {
k++;
}
numberOfSteps--;
model.fireTableDataChanged();
}
}
public void setParams(List<Reference> references, int frames, int columns) {
this.references = new ArrayList<>(references.size() + 1);//defensive
this.references.add(0,EMPTY);
this.references.addAll(references);
i = 1;
k = 0;
numberOfSteps = (columns - 1) * frames;
this.frames = frames;
}
public void clearParams() {
this.references = null;
numberOfSteps= i = k= -1;
frames = 0;
}
private int getValue(int i, int k){
return references.get(i).getFrames().get(k);
}
private static void scrollToVisible(JTable table, int row, int col) {
if (!(table.getParent() instanceof JViewport))
return;
JViewport viewport = (JViewport) table.getParent();
Rectangle rect = table.getCellRect(row, col, true);
Point p = viewport.getViewPosition();
rect.setLocation(rect.x - p.x, rect.y - p.y);
viewport.scrollRectToVisible(rect);
}
}
}
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class FWorks implements Iterable<Integer> {
private List<Integer> FWorks;
public FWorks(int numberOfFWorks) {
this.FWorks = new ArrayList<>(numberOfFWorks);
for (int i = 0; i < numberOfFWorks; i++) {
FWorks.add(-1);
}
}
public void deallocateFWorks() {
int len = FWorks.size();
for (int i = 0; i < len; i++) {
FWorks.set(i, -1);
}
}
public boolean contains(int RefWork) {
return indexOf(RefWork) > -1;
}
public int indexOf(int RefWork) {
return FWorks.indexOf(RefWork);
}
public int set(int index, int RefWork) {
return FWorks.set(index, RefWork);
}
public void swap(int victim, int RefWork) {
set(indexOf(victim), RefWork);
}
public int get(int index) {
return FWorks.get(index);
}
public boolean thereIsAnEmptyFWork() {
return contains(-1);
}
public void copyAll(FWorks f) {
FWorks.clear();
FWorks = new ArrayList<>(f.FWorks);
}
public int getEmptyFWork() {
return indexOf(-1);
}
@Override
public Iterator<Integer> iterator() {
return FWorks.iterator();
}
}
Related Questions
drjack9650@gmail.com
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.