Skip to content

Commit 79467b3

Browse files
DekasDimitriosDekasDimitrios
committed
Added Best/First/Worst Fit algorithm implementation
1 parent 726aab9 commit 79467b3

File tree

3 files changed

+235
-0
lines changed

3 files changed

+235
-0
lines changed

‎Others/BestFit.java

+89
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,89 @@
1+
package Others;
2+
3+
import java.util.Array-List;
4+
5+
/**
6+
* @author Dekas Dimitrios
7+
*/
8+
public class BestFit {
9+
private static final int NO_ALLOCATION = -255; // if a process has been allocated in position -255,
10+
// it means that it has not been actually allocated.
11+
12+
/**
13+
* Method to find the maximum valued element of an array filled with positive integers.
14+
*
15+
* @param array: an array filled with positive integers.
16+
* @return the maximum valued element of the array.
17+
*/
18+
private static int findMaxElement(int[] array) {
19+
int max = -1;
20+
for (int value : array) {
21+
if (value > max) {
22+
max = value;
23+
}
24+
}
25+
return max;
26+
}
27+
28+
/**
29+
* Method to find the index of the memory block that is going to fit the given process based on the best fit algorithm.
30+
*
31+
* @param blocks: the array with the available memory blocks.
32+
* @param process: the size of the process.
33+
* @return the index of the block that fits, or -255 if no such block exists.
34+
*/
35+
private static int findBestFit(int[] blockSizes, int processSize) {
36+
// Initialize minDiff with an unreachable value by a difference between a blockSize and the processSize.
37+
int minDiff = findMaxElement(blockSizes);
38+
int index = NO_ALLOCATION; // If there is no block that can fit the process, return NO_ALLOCATION as the result.
39+
for(int i=0 ; i < blockSizes.length ; i++) { // Find the most fitting memory block for the given process.
40+
if(blockSizes[i] - processSize < minDiff && blockSizes[i] - processSize >= 0) {
41+
minDiff = blockSizes[i] - processSize;
42+
index = i;
43+
}
44+
}
45+
return index;
46+
}
47+
48+
/**
49+
* Method to allocate memory to blocks according to the best fit
50+
* algorithm. It should return an ArrayList of Integers, where the
51+
* index is the process ID (zero-indexed) and the value is the block
52+
* number (also zero-indexed).
53+
*
54+
* @param sizeOfBlocks: an int array that contains the sizes of the memory blocks available.
55+
* @param sizeOfProcesses: an int array that contains the sizes of the processes we need memory blocks for.
56+
* @return the ArrayList filled with Integers repressenting the memory allocation that took place.
57+
*/
58+
static ArrayList<Integer> bestFit(int[] sizeOfBlocks, int[] sizeOfProcesses) {
59+
// The array list responsible for saving the memory allocations done by the best-fit algorithm
60+
ArrayList<Integer> memAlloc = new ArrayList<>();
61+
// Do this for every process
62+
for(int processSize : sizeOfProcesses) {
63+
int chosenBlockIdx = findBestFit(sizeOfBlocks, processSize); // Find the index of the memory block going to be used
64+
memAlloc.add(chosenBlockIdx); // Store the chosen block index in the memAlloc array list
65+
if(chosenBlockIdx != NO_ALLOCATION) { // Only if a block was chosen to store the process in it,
66+
sizeOfBlocks[chosenBlockIdx] -= processSize; // resize the block based on the process size
67+
}
68+
}
69+
return memAlloc;
70+
}
71+
72+
/**
73+
* Method to print the memory allocated.
74+
*
75+
* @param memAllocation: an ArrayList of Integer representing the memory allocation done by the bestFit method.
76+
*/
77+
public static void printMemoryAllocation(ArrayList<Integer> memAllocation) {
78+
System.out.println("Process No.\tBlock No.");
79+
System.out.println("===========\t=========");
80+
for (int i = 0; i < memAllocation.size(); i++) {
81+
System.out.print(" " + i + "\t\t");
82+
if (memAllocation.get(i) != NO_ALLOCATION)
83+
System.out.print(memAllocation.get(i));
84+
else
85+
System.out.print("Not Allocated");
86+
System.out.println();
87+
}
88+
}
89+
}

‎Others/FirstFit.java

+70
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,70 @@
1+
package Others;
2+
3+
import java.util.ArrayList;
4+
5+
/**
6+
* @author Dekas Dimitrios
7+
*/
8+
public class FirstFit {
9+
private static final int NO_ALLOCATION = -255; // if a process has been allocated in position -255,
10+
// it means that it has not been actually allocated.
11+
12+
/**
13+
* Method to find the index of the memory block that is going to fit the given process based on the first fit algorithm.
14+
*
15+
* @param blocks: the array with the available memory blocks.
16+
* @param process: the size of the process.
17+
* @return the index of the block that fits, or -255 if no such block exists.
18+
*/
19+
private static int findFirstFit(int[] blockSizes, int processSize) {
20+
for(int i=0 ; i < blockSizes.length ; i++) {
21+
if(blockSizes[i] >= processSize) {
22+
return i;
23+
}
24+
}
25+
// If there is not a block that can fit the process, return -255 as the result
26+
return NO_ALLOCATION;
27+
}
28+
29+
/**
30+
* Method to allocate memory to blocks according to the first fit
31+
* algorithm. It should return an ArrayList of Integers, where the
32+
* index is the process ID (zero-indexed) and the value is the block
33+
* number (also zero-indexed).
34+
*
35+
* @param sizeOfBlocks: an int array that contains the sizes of the memory blocks available.
36+
* @param sizeOfProcesses: an int array that contains the sizes of the processes we need memory blocks for.
37+
* @return the ArrayList filled with Integers repressenting the memory allocation that took place.
38+
*/
39+
static ArrayList<Integer> firstFit(int[] sizeOfBlocks, int[] sizeOfProcesses) {
40+
// The array list responsible for saving the memory allocations done by the first-fit algorithm
41+
ArrayList<Integer> memAlloc = new ArrayList<>();
42+
// Do this for every process
43+
for(int processSize : sizeOfProcesses) {
44+
int chosenBlockIdx = findFirstFit(sizeOfBlocks, processSize); // Find the index of the memory block going to be used
45+
memAlloc.add(chosenBlockIdx); // Store the chosen block index in the memAlloc array list
46+
if(chosenBlockIdx != NO_ALLOCATION) { // Only if a block was chosen to store the process in it,
47+
sizeOfBlocks[chosenBlockIdx] -= processSize; // resize the block based on the process size
48+
}
49+
}
50+
return memAlloc;
51+
}
52+
53+
/**
54+
* Method to print the memory allocated.
55+
*
56+
* @param memAllocation: an ArrayList of Integer representing the memory allocation done by the firstFit method.
57+
*/
58+
public static void printMemoryAllocation(ArrayList<Integer> memAllocation) {
59+
System.out.println("Process No.\tBlock No.");
60+
System.out.println("===========\t=========");
61+
for (int i = 0; i < memAllocation.size(); i++) {
62+
System.out.print(" " + i + "\t\t");
63+
if (memAllocation.get(i) != NO_ALLOCATION)
64+
System.out.print(memAllocation.get(i));
65+
else
66+
System.out.print("Not Allocated");
67+
System.out.println();
68+
}
69+
}
70+
}

‎Others/WorstFit.java

+76
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,76 @@
1+
package Others;
2+
3+
import java.util.ArrayList;
4+
5+
/**
6+
* @author Dekas Dimitrios
7+
*/
8+
public class WorstFit {
9+
private static final int NO_ALLOCATION = -255; // if a process has been allocated in position -255,
10+
// it means that it has not been actually allocated.
11+
12+
/**
13+
* Method to find the index of the memory block that is going to fit the given process based on the worst fit algorithm.
14+
*
15+
* @param blocks: the array with the available memory blocks.
16+
* @param process: the size of the process.
17+
* @return the index of the block that fits, or -255 if no such block exists.
18+
*/
19+
private static int findWorstFit(int[] blockSizes, int processSize) {
20+
int max = -1;
21+
int index = -1;
22+
for(int i=0 ; i < blockSizes.length ; i++) { // Find the index of the biggest memory block available.
23+
if(blockSizes[i] > max) {
24+
max = blockSizes[i];
25+
index = i;
26+
}
27+
}
28+
// If the biggest memory block cannot fit the process, return -255 as the result
29+
if(processSize > blockSizes[index]) {
30+
return NO_ALLOCATION;
31+
}
32+
return index;
33+
}
34+
35+
/**
36+
* Method to allocate memory to blocks according to the worst fit
37+
* algorithm. It should return an ArrayList of Integers, where the
38+
* index is the process ID (zero-indexed) and the value is the block
39+
* number (also zero-indexed).
40+
*
41+
* @param sizeOfBlocks: an int array that contains the sizes of the memory blocks available.
42+
* @param sizeOfProcesses: an int array that contains the sizes of the processes we need memory blocks for.
43+
* @return the ArrayList filled with Integers repressenting the memory allocation that took place.
44+
*/
45+
static ArrayList<Integer> worstFit(int[] sizeOfBlocks, int[] sizeOfProcesses) {
46+
// The array list responsible for saving the memory allocations done by the worst-fit algorithm
47+
ArrayList<Integer> memAlloc = new ArrayList<>();
48+
// Do this for every process
49+
for(int processSize : sizeOfProcesses) {
50+
int chosenBlockIdx = findWorstFit(sizeOfBlocks, processSize); // Find the index of the memory block going to be used
51+
memAlloc.add(chosenBlockIdx); // Store the chosen block index in the memAlloc array list
52+
if(chosenBlockIdx != NO_ALLOCATION) { // Only if a block was chosen to store the process in it,
53+
sizeOfBlocks[chosenBlockIdx] -= processSize; // resize the block based on the process size
54+
}
55+
}
56+
return memAlloc;
57+
}
58+
59+
/**
60+
* Method to print the memory allocated.
61+
*
62+
* @param memAllocation: an ArrayList of Integer representing the memory allocation done by the worstFit method.
63+
*/
64+
public static void printMemoryAllocation(ArrayList<Integer> memAllocation) {
65+
System.out.println("Process No.\tBlock No.");
66+
System.out.println("===========\t=========");
67+
for (int i = 0; i < memAllocation.size(); i++) {
68+
System.out.print(" " + i + "\t\t");
69+
if (memAllocation.get(i) != NO_ALLOCATION)
70+
System.out.print(memAllocation.get(i));
71+
else
72+
System.out.print("Not Allocated");
73+
System.out.println();
74+
}
75+
}
76+
}

0 commit comments

Comments
 (0)