itcs3146-project/WorstFitAlgorithm.java

115 lines
3.5 KiB
Java
Raw Normal View History

2012-11-05 21:04:21 -05:00
/*
2012-11-14 23:54:24 -05:00
* Worst Fit Algorithm by David Weber
* ITCS 3146
* 11/9/2012
2012-11-05 21:04:21 -05:00
*/
2012-11-14 23:54:24 -05:00
import java.util.ArrayList;
public class WorstFitAlgorithm implements baseAlgorithm{
int memoryBlock[];
public WorstFitAlgorithm(int memorySize)
{
//Initialize memory block to whatever the size is
memoryBlock = new int[memorySize];
}
public int getWorstSizeIndex(int jobSize)
{
int worstSize = 0;
int worstSizeIndex = 0;
ArrayList<Integer> candidates = new ArrayList<Integer>(); //Dynamically resizable array list for allocation candidates (interleaved with index and memory size)
int counter = 0; //Counter for measuring unallocated memory
//Scan through memory block and get free blocks
for(int i = 0; i < memoryBlock.length; i++)
{
//If position in memory block here is 0, iterate from that index and count up sequential 0's
if(memoryBlock[i] == 0)
{
for(int j = i; j < memoryBlock.length - i; j++)
{
if(memoryBlock[j] == 0)
{
counter++;
}
}
if(counter >= jobSize)
{
candidates.add(i); //Store index
candidates.add(counter); //Store size of free memory chunk
}
counter = 0;
}
}
//Iterate through candidate sizes
worstSizeIndex = 0; //Initialize best index to first spot in array list
worstSize = candidates.get(1).intValue(); //Initialize bestSize to first space size in candidate
//Iterate through sizes and find the best fit
for(int i = 1; i < candidates.size(); i=i+2)
{
//If the current size is greater than the previous best size, make this the new best size
if(candidates.get(i).intValue() > worstSize)
{
worstSize = candidates.get(i+1).intValue();
worstSizeIndex = i - 1;
}
}
//If the best size is less than the job size, run this again
if(candidates.isEmpty())
{
return -1;
}
return worstSizeIndex;
}
@Override
public void allocate(int jobID, int jobSize, int jobTime)
{
int worstSizeIndex = getWorstSizeIndex(jobSize);
if(worstSizeIndex == -1) //No candidates found
{
//Try compacting, then attempt to get an index again
compact();
worstSizeIndex = getWorstSizeIndex(jobSize);
//Compacting still didn't produce an appropriate block
if(worstSizeIndex == -1)
{
//TODO .....
}
}
//Allocate the memory
for(int i = worstSizeIndex; i < jobSize; i++)
{
memoryBlock[i] = jobID;
}
}
public void compact()
{
//TODO: Compact memory if no suitable allocation candidates are found on the first pass
}
@Override
public void deallocate(int jobSize, int beginningLocation)
2012-11-05 21:08:12 -05:00
{
2012-11-14 23:54:24 -05:00
for(int i = beginningLocation; i < jobSize; i++)
{
memoryBlock[i] = 0;
}
2012-11-05 21:08:12 -05:00
}
2012-11-14 23:54:24 -05:00
2012-11-05 21:04:21 -05:00
}