Worst Fit Algorithm
The Worst Fit Algorithm is a memory allocation and management strategy used in computer systems, primarily dealing with the allocation of memory blocks in a dynamic partitioning system. The main idea behind this algorithm is to allocate memory to a process by finding the largest available memory block that can accommodate the process's memory requirement. This approach aims to reduce external fragmentation and ensure efficient use of memory resources. In the context of operating systems, the Worst Fit Algorithm is often employed to allocate memory for processes during their execution.
The algorithm operates by maintaining a list of free memory blocks, sorted in either ascending or descending order based on their size. When a process requests memory, the algorithm scans through the list to find the largest available memory block that can hold the process's size requirement. Once identified, the memory block is allocated to the process, and the remaining memory (if any) is split into a new free block. If no suitable block is found, the algorithm may either wait for memory to be freed up or terminate the process. While the Worst Fit Algorithm can be efficient in certain cases, it can also lead to higher fragmentation and inefficient memory usage over time, as the largest memory blocks are continually split into smaller blocks, potentially leading to a larger number of unusable memory gaps.
package Others;
import java.util.ArrayList;
/**
* @author Dekas Dimitrios
*/
public class WorstFit {
private static final int NO_ALLOCATION = -255; // if a process has been allocated in position -255,
// it means that it has not been actually allocated.
/**
* Method to find the index of the memory block that is going to fit the given process based on the worst fit algorithm.
*
* @param blocks: the array with the available memory blocks.
* @param process: the size of the process.
* @return the index of the block that fits, or -255 if no such block exists.
*/
private static int findWorstFit(int[] blockSizes, int processSize) {
int max = -1;
int index = -1;
for(int i=0 ; i < blockSizes.length ; i++) { // Find the index of the biggest memory block available.
if(blockSizes[i] > max) {
max = blockSizes[i];
index = i;
}
}
// If the biggest memory block cannot fit the process, return -255 as the result
if(processSize > blockSizes[index]) {
return NO_ALLOCATION;
}
return index;
}
/**
* Method to allocate memory to blocks according to the worst fit
* algorithm. It should return an ArrayList of Integers, where the
* index is the process ID (zero-indexed) and the value is the block
* number (also zero-indexed).
*
* @param sizeOfBlocks: an int array that contains the sizes of the memory blocks available.
* @param sizeOfProcesses: an int array that contains the sizes of the processes we need memory blocks for.
* @return the ArrayList filled with Integers repressenting the memory allocation that took place.
*/
static ArrayList<Integer> worstFit(int[] sizeOfBlocks, int[] sizeOfProcesses) {
// The array list responsible for saving the memory allocations done by the worst-fit algorithm
ArrayList<Integer> memAlloc = new ArrayList<>();
// Do this for every process
for(int processSize : sizeOfProcesses) {
int chosenBlockIdx = findWorstFit(sizeOfBlocks, processSize); // Find the index of the memory block going to be used
memAlloc.add(chosenBlockIdx); // Store the chosen block index in the memAlloc array list
if(chosenBlockIdx != NO_ALLOCATION) { // Only if a block was chosen to store the process in it,
sizeOfBlocks[chosenBlockIdx] -= processSize; // resize the block based on the process size
}
}
return memAlloc;
}
/**
* Method to print the memory allocated.
*
* @param memAllocation: an ArrayList of Integer representing the memory allocation done by the worstFit method.
*/
public static void printMemoryAllocation(ArrayList<Integer> memAllocation) {
System.out.println("Process No.\tBlock No.");
System.out.println("===========\t=========");
for (int i = 0; i < memAllocation.size(); i++) {
System.out.print(" " + i + "\t\t");
if (memAllocation.get(i) != NO_ALLOCATION)
System.out.print(memAllocation.get(i));
else
System.out.print("Not Allocated");
System.out.println();
}
}
}
