Flesh out the threaded algorithm

Conflicts:

	memoryManagement.java
This commit is contained in:
Bradlee Speice 2012-11-12 20:04:32 -05:00
parent 3d022b276d
commit 7e80fda0c0
6 changed files with 150 additions and 24 deletions

View File

@ -38,5 +38,9 @@ public class Job {
} }
} }
public void setBeginningLocation(int newBeginning)
{
myThread.setBeginning(newBeginning);
}
} }

View File

@ -15,7 +15,7 @@ class NextFit implements baseAlgorithm
startLoc, startLoc,
endLoc, endLoc,
blkSize, blkSize,
memSize = memoryManagement.memory, memSize = memoryManagement.MEMORYSIZE,
active, active,
noJobs=0, noJobs=0,
s1=0, s1=0,

View File

@ -1,8 +1,7 @@
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method; import java.lang.reflect.Method;
public class jobThread extends Thread { public class jobThread extends Thread {
private final int sleepResolution = 200; //Milliseconds private final int sleepResolution = 20; //Milliseconds
private long jobTime; //Milliseconds private long jobTime; //Milliseconds
private long elapsedTime; private long elapsedTime;
private boolean isPaused, pauseStateChanged; private boolean isPaused, pauseStateChanged;
@ -28,6 +27,10 @@ public class jobThread extends Thread {
this.beginningLocation = beginningLocation; this.beginningLocation = beginningLocation;
} }
public void setBeginning(int newBeginning){
this.beginningLocation = newBeginning;
}
public void pause(){ public void pause(){
synchronized(this){ synchronized(this){
isPaused = true; isPaused = true;

View File

@ -9,11 +9,10 @@ import java.util.StringTokenizer;
public class memoryManagement{ public class memoryManagement{
public static int memory = 1024; static final int JOBAMOUNT = 1000;
static final int MEMORYSIZE = 10000;
public static void main(String args[])throws Exception{ public static void main(String args[])throws Exception{
final int JOBAMOUNT = 1000;
final int MEMORYSIZE = 10000;
File file = new File("null"); File file = new File("null");
Scanner keyboard = new Scanner(System.in); Scanner keyboard = new Scanner(System.in);

View File

@ -1,5 +1,9 @@
import java.lang.reflect.Method;
public class threadedAllocation implements baseAlgorithm{ public class threadedAllocation implements baseAlgorithm{
int[] memoryBlock; int[] memoryBlock;
threadedAllocationGarbage garbageThread;
Job[] jobArray;
threadedAllocation(int memorySize) { threadedAllocation(int memorySize) {
/* Constructor specific for this algorithm /* Constructor specific for this algorithm
@ -7,6 +11,12 @@ public class threadedAllocation implements baseAlgorithm{
* Start the threaded garbage collector, and then begin * Start the threaded garbage collector, and then begin
* our actual operations */ * our actual operations */
memoryBlock = new int[memorySize]; memoryBlock = new int[memorySize];
this.garbageThread = new threadedAllocationGarbage(this.memoryBlock, 20, this.jobArray);
this.garbageThread.run();
// Set up the array of job references
jobArray = new Job[memoryManagement.JOBAMOUNT];
} }
int locateBlock(int blockSize){ int locateBlock(int blockSize){
@ -40,6 +50,8 @@ public class threadedAllocation implements baseAlgorithm{
public void allocate(int jobID, int jobSize, int jobLength ){ public void allocate(int jobID, int jobSize, int jobLength ){
/* Over-rides allocate() of baseAlgorithm */ /* Over-rides allocate() of baseAlgorithm */
try{
Method deallocateMethod = this.getClass().getMethod("deallocate", new Class[]{int.class, int.class});
//Loop until we get a block big enough for our job //Loop until we get a block big enough for our job
// Note that this assumes we're not going to race against ourselves // Note that this assumes we're not going to race against ourselves
@ -54,6 +66,12 @@ public class threadedAllocation implements baseAlgorithm{
} }
//TODO: Code to start the job //TODO: Code to start the job
Job newJob = new Job(jobLength, jobID, jobSize, beginningLocation, deallocateMethod, this);
jobArray[jobID] = newJob;
newJob.start();
} catch (Exception e){
System.out.println("Could not allocate job with ID " + jobID);
}
} }
public void deallocate(int jobSize, int beginningLocation){ public void deallocate(int jobSize, int beginningLocation){

View File

@ -7,18 +7,120 @@ class threadedAllocationGarbage extends Thread
int[] memoryBlock; int[] memoryBlock;
int sleepTime; int sleepTime;
Job[] jobArray;
threadedAllocationGarbage( int[] memoryBlock, int sleepTime ){ threadedAllocationGarbage( int[] memoryBlock, int sleepTime, Job[] jobArray ){
/* Set up a reference to the algorithm's memory location */ /* Set up a reference to the algorithm's memory location */
this.memoryBlock = memoryBlock; this.memoryBlock = memoryBlock;
/* Set up the time quantum */ /* Set up the time quantum */
this.sleepTime = sleepTime; this.sleepTime = sleepTime;
/* Set up the array of jobs so that we can pause them as need be */
this.jobArray = jobArray;
}
public int[] largestBlock(){
//Find an open location
int memoryLoc = 0;
int maxFreeSize = 0, maxFreeIndex = 0;
while (memoryLoc < this.memoryBlock.length)
{
if (this.memoryBlock[memoryLoc] != 0)
//Block isn't free
continue;
//One location is free, find out total size free
//This loop breaks either when we've found the size we need, or
//we found the beginning of the next block.
int beginningLoc = memoryLoc;
int free = 0;
while (this.memoryBlock[memoryLoc] == 0)
{
memoryLoc += 1;
free += 1;
}
//We've found the end of that chunk, see if it's bigger than what we have on file
if (free > maxFreeSize){
maxFreeSize = free;
maxFreeIndex = beginningLoc;
}
}
//We've reached the end of memory, return what the largest block was (if we found a block)
if (maxFreeSize > 0)
return new int[]{maxFreeIndex, maxFreeSize};
else
return new int[]{-1, -1};
} }
public void run() { public void run() {
/* Code to run in the background */ /* Code to run in the background */
//Sleep for sleepTime, then scan for memory to compact while (true)
{
/* The way this algorithm works is to:
* Start at the beginning of the memory block
* Find the largest available block
* Shift the closest job down to fill up this space
* Repeat until deconstructed
*/
int[] largestBlockInfo = largestBlock();
int maxFreeBeginning = largestBlockInfo[0];
int maxFreeSize = largestBlockInfo[1];
if (maxFreeSize == -1)
//No open space found
continue;
//Find out what ID the job is, and how big it is
int jobID = this.memoryBlock[maxFreeBeginning + maxFreeSize + 1];
int jobSize = 0;
int counter = maxFreeBeginning + maxFreeSize;
while (this.memoryBlock[counter] == jobID){
counter++;
jobSize++;
}
//Pause the job, and then relocate it
//Note that we need to lock out the allocation to prevent a race
synchronized (this.memoryBlock) {
//Pause the job operation
jobArray[jobID].pause();
//Write the job into the free space
int memoryLoc = maxFreeBeginning;
counter = 0;
while (counter < jobSize){
memoryBlock[memoryLoc] = jobID;
counter++;
}
//Inform the job of its new beginning location
jobArray[jobID].setBeginningLocation(maxFreeBeginning);
//Restart the job
jobArray[jobID].resume();
//Write the remaining memory as free
counter = 0;
while (counter < maxFreeSize){
memoryBlock[memoryLoc] = 0;
}
}
//Sleep for sleepTime, then go back to the top to continue compaction
try {
sleep(sleepTime);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
System.out.println("Error in compaction thread! Algorithm is aborting.");
//Kill ourselves
this.interrupt();
}
}
} }
} }