Algorithms/JavaAlgorithms
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Unify dynamic memory allocation algorithms (#2935)

Browse Source
This commit is contained in:
alexlemo20 2022-02-10 19:08:21 +02:00 committed by GitHub
parent 12c67bc501
commit adadb2f6d6
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
8 changed files with 616 additions and 276 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

106
src/main/java/com/thealgorithms/others/BestFit.java
View File

@ -1,106 +0,0 @@
package com.thealgorithms.others;
import java.util.ArrayList;
/**
* @author Dekas Dimitrios
*/
public class BestFit {
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 maximum valued element of an array filled with
* positive integers.
*
* @param array: an array filled with positive integers.
* @return the maximum valued element of the array.
*/
private static int findMaxElement(int[] array) {
int max = -1;
for (int value : array) {
if (value > max) {
max = value;
}
}
return max;
}
/**
* Method to find the index of the memory block that is going to fit the
* given process based on the best 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 findBestFit(int[] blockSizes, int processSize) {
// Initialize minDiff with an unreachable value by a difference between a blockSize and the
// processSize.
int minDiff = findMaxElement(blockSizes);
int index
= NO_ALLOCATION; // If there is no block that can fit the process, return NO_ALLOCATION as the
// result.
for (int i = 0;
i < blockSizes.length;
i++) { // Find the most fitting memory block for the given process.
if (blockSizes[i] - processSize < minDiff && blockSizes[i] - processSize >= 0) {
minDiff = blockSizes[i] - processSize;
index = i;
}
}
return index;
}
/**
* Method to allocate memory to blocks according to the best 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> bestFit(int[] sizeOfBlocks, int[] sizeOfProcesses) {
// The array list responsible for saving the memory allocations done by the best-fit algorithm
ArrayList<Integer> memAlloc = new ArrayList<>();
// Do this for every process
for (int processSize : sizeOfProcesses) {
int chosenBlockIdx
= findBestFit(
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 bestFit 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();
}
}
}

301
src/main/java/com/thealgorithms/others/CPUalgorithms.java Normal file
View File

@ -0,0 +1,301 @@
package com.thealgorithms.others;
/**
* @author Alexandros Lemonaris
*/
import java.util.ArrayList;
public abstract class CPUalgorithms {
/**
* Method to allocate memory to blocks according to CPU algorithms.
* Use of inheritance to avoid repeated code.
* Abstract method since it is implemented different for each 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.
*/
public abstract ArrayList<Integer> fitProcess(int[] sizeOfBlocks, int[] sizeOfProcesses);
}
/**
* @author Dekas Dimitrios
*/
class BestFitCPU extends CPUalgorithms{
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 maximum valued element of an array filled with
* positive integers.
*
* @param array: an array filled with positive integers.
* @return the maximum valued element of the array.
*/
private static int findMaxElement(int[] array) {
int max = -1;
for (int value : array) {
if (value > max) {
max = value;
}
}
return max;
}
/**
* Method to find the index of the memory block that is going to fit the
* given process based on the best 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 findBestFit(int[] blockSizes, int processSize) {
// Initialize minDiff with an unreachable value by a difference between a blockSize and the
// processSize.
int minDiff = findMaxElement(blockSizes);
int index
= NO_ALLOCATION; // If there is no block that can fit the process, return NO_ALLOCATION as the
// result.
for (int i = 0;
i < blockSizes.length;
i++) { // Find the most fitting memory block for the given process.
if (blockSizes[i] - processSize < minDiff && blockSizes[i] - processSize >= 0) {
minDiff = blockSizes[i] - processSize;
index = i;
}
}
return index;
}
/**
* Method to allocate memory to blocks according to the best 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.
*/
public ArrayList<Integer> fitProcess(int[] sizeOfBlocks, int[] sizeOfProcesses) {
// The array list responsible for saving the memory allocations done by the best-fit algorithm
ArrayList<Integer> memAlloc = new ArrayList<>();
// Do this for every process
for (int processSize : sizeOfProcesses) {
int chosenBlockIdx
= findBestFit(
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;
}
}
/**
* @author Dekas Dimitrios
*/
class WorstFitCPU extends CPUalgorithms{
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.
*/
public ArrayList<Integer> fitProcess(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;
}
}
/**
* @author Dekas Dimitrios
*/
class FirstFitCPU extends CPUalgorithms{
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 first 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 findFirstFit(int[] blockSizes, int processSize) {
for (int i = 0; i < blockSizes.length; i++) {
if (blockSizes[i] >= processSize) {
return i;
}
}
// If there is not a block that can fit the process, return -255 as the result
return NO_ALLOCATION;
}
/**
* Method to allocate memory to blocks according to the first 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.
*/
public ArrayList<Integer> fitProcess(int[] sizeOfBlocks, int[] sizeOfProcesses) {
// The array list responsible for saving the memory allocations done by the first-fit algorithm
ArrayList<Integer> memAlloc = new ArrayList<>();
// Do this for every process
for (int processSize : sizeOfProcesses) {
int chosenBlockIdx
= findFirstFit(
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;
}
}
/**
* @author Alexandros Lemonaris
*/
class NextFit extends CPUalgorithms{
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.
private int counter = 0; // variable that keeps the position of the last registration into the memory
/**
* Method to find the index of the memory block that is going to fit the
* given process based on the next fit algorithm. In the case of next fit,
* if the search is interrupted in between, the new search is carried out from the last location.
*
* @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 int findNextFit(int[] blockSizes, int processSize) {
for (int i = 0; i < blockSizes.length; i++) {
if (counter + i >= blockSizes.length){
counter = -i; // starts from the start of the array
}
if (blockSizes[i + counter] >= processSize) {
counter += i;
return counter;
}
}
// If there is not a block that can fit the process, return -255 as the result
counter += blockSizes.length; // counter keeps its last value
return NO_ALLOCATION;
}
/**
* Method to allocate memory to blocks according to the first 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.
*/
public ArrayList<Integer> fitProcess(int[] sizeOfBlocks, int[] sizeOfProcesses) {
// The array list responsible for saving the memory allocations done by the first-fit algorithm
ArrayList<Integer> memAlloc = new ArrayList<>();
// Do this for every process
for (int processSize : sizeOfProcesses) {
int chosenBlockIdx
= findNextFit(
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;
}
}

81
src/main/java/com/thealgorithms/others/FirstFit.java
View File

@ -1,81 +0,0 @@
package com.thealgorithms.others;
import java.util.ArrayList;
/**
* @author Dekas Dimitrios
*/
public class FirstFit {
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 first 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 findFirstFit(int[] blockSizes, int processSize) {
for (int i = 0; i < blockSizes.length; i++) {
if (blockSizes[i] >= processSize) {
return i;
}
}
// If there is not a block that can fit the process, return -255 as the result
return NO_ALLOCATION;
}
/**
* Method to allocate memory to blocks according to the first 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> firstFit(int[] sizeOfBlocks, int[] sizeOfProcesses) {
// The array list responsible for saving the memory allocations done by the first-fit algorithm
ArrayList<Integer> memAlloc = new ArrayList<>();
// Do this for every process
for (int processSize : sizeOfProcesses) {
int chosenBlockIdx
= findFirstFit(
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 firstFit 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();
}
}
}

89
src/main/java/com/thealgorithms/others/WorstFit.java
View File

@ -1,89 +0,0 @@
package com.thealgorithms.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();
}
}
}

76
src/test/java/com/thealgorithms/others/BestFitCPUTest.java Normal file
View File

@ -0,0 +1,76 @@
package com.thealgorithms.others;
import org.junit.jupiter.api.Test;
import java.util.ArrayList;
import java.util.Arrays;
import static org.junit.jupiter.api.Assertions.*;
/**
* author Alexandros Lemonaris
*/
class BestFitCPUTest {
int [] sizeOfBlocks;
int [] sizeOfProcesses;
ArrayList<Integer> memAllocation = new ArrayList<>();
ArrayList<Integer> testMemAllocation ;
CPUalgorithms bestFit = new BestFitCPU();
@Test
void testFitForUseOfOneBlock() {
//test1 - 2 processes shall fit to one block instead of using a different block each
sizeOfBlocks = new int[]{5, 12, 17, 10};
sizeOfProcesses = new int[]{10, 5, 15, 2};
memAllocation = bestFit.fitProcess(sizeOfBlocks, sizeOfProcesses);
testMemAllocation = new ArrayList<>(
Arrays.asList(3, 0, 2, 2)
);
assertEquals(testMemAllocation, memAllocation);
}
@Test
void testFitForEqualProcecesses() {
//test2
sizeOfBlocks = new int[]{5, 12, 17, 10};
sizeOfProcesses = new int[]{10, 10, 10, 10};
memAllocation = bestFit.fitProcess(sizeOfBlocks, sizeOfProcesses);
testMemAllocation = new ArrayList<>(
Arrays.asList(3, 1, 2, -255)
);
assertEquals(testMemAllocation, memAllocation);
}
@Test
void testFitForNoEmptyBlockCell() {
//test3 for more processes than blocks - no empty space left to none of the blocks
sizeOfBlocks = new int[]{5, 12, 17};
sizeOfProcesses = new int[]{5, 12, 10, 7};
memAllocation = bestFit.fitProcess(sizeOfBlocks, sizeOfProcesses);
testMemAllocation = new ArrayList<>(
Arrays.asList(0, 1, 2, 2)
);
assertEquals(testMemAllocation, memAllocation);
}
@Test
void testFitForSameInputDifferentQuery() {
//test4 for more processes than blocks - one element does not fit due to input series
sizeOfBlocks = new int[]{5, 12, 17};
sizeOfProcesses = new int[]{5, 7, 10, 12};
memAllocation = bestFit.fitProcess(sizeOfBlocks, sizeOfProcesses);
testMemAllocation = new ArrayList<>(
Arrays.asList(0, 1, 2, -255)
);
assertEquals(testMemAllocation, memAllocation);
}
@Test
void testFitForMoreBlocksNoFit() {
//test5 for more blocks than processes
sizeOfBlocks = new int[] {5, 4, -1, 3, 6};
sizeOfProcesses = new int [] {10, 11};
memAllocation = bestFit.fitProcess(sizeOfBlocks, sizeOfProcesses);
testMemAllocation = new ArrayList<>(
Arrays.asList( -255, -255)
);
assertEquals(testMemAllocation, memAllocation);
}
}

76
src/test/java/com/thealgorithms/others/FirstFitCPUTest.java Normal file
View File

@ -0,0 +1,76 @@
package com.thealgorithms.others;
import org.junit.jupiter.api.Test;
import java.util.ArrayList;
import java.util.Arrays;
import static org.junit.jupiter.api.Assertions.*;
/**
* author Alexandros Lemonaris
*/
class FirstFitCPUTest {
int [] sizeOfBlocks;
int [] sizeOfProcesses;
ArrayList<Integer> memAllocation = new ArrayList<>();
ArrayList<Integer> testMemAllocation ;
CPUalgorithms firstFit = new FirstFitCPU();
@Test
void testFitForUseOfOneBlock() {
//test1 - no use of one block for two processes
sizeOfBlocks = new int[]{5, 12, 17, 10};
sizeOfProcesses = new int[]{10, 5, 15, 2};
memAllocation = firstFit.fitProcess(sizeOfBlocks, sizeOfProcesses);
testMemAllocation = new ArrayList<>(
Arrays.asList(1, 0, 2, 1)
);
assertEquals(testMemAllocation, memAllocation);
}
@Test
void testFitForEqualProcecesses() {
//test2
sizeOfBlocks = new int[]{5, 12, 17, 10};
sizeOfProcesses = new int[]{10, 10, 10, 10};
memAllocation = firstFit.fitProcess(sizeOfBlocks, sizeOfProcesses);
testMemAllocation = new ArrayList<>(
Arrays.asList(1, 2, 3, -255)
);
assertEquals(testMemAllocation, memAllocation);
}
@Test
void testFitForNoEmptyBlockCell() {
//test3 for more processes than blocks - no empty space left to none of the blocks
sizeOfBlocks = new int[]{5, 12, 17};
sizeOfProcesses = new int[]{5, 12, 10, 7};
memAllocation = firstFit.fitProcess(sizeOfBlocks, sizeOfProcesses);
testMemAllocation = new ArrayList<>(
Arrays.asList(0, 1, 2, 2)
);
assertEquals(testMemAllocation, memAllocation);
}
@Test
void testFitForSameInputDifferentQuery() {
//test4 for more processes than blocks - one element does not fit due to input series
sizeOfBlocks = new int[]{5, 12, 17};
sizeOfProcesses = new int[]{5, 7, 10, 12};
memAllocation = firstFit.fitProcess(sizeOfBlocks, sizeOfProcesses);
testMemAllocation = new ArrayList<>(
Arrays.asList(0, 1, 2, -255)
);
assertEquals(testMemAllocation, memAllocation);
}
@Test
void testFitForMoreBlocksNoFit() {
//test5 for more blocks than processes
sizeOfBlocks = new int[] {5, 4, -1, 3, 6};
sizeOfProcesses = new int [] {10, 11};
memAllocation = firstFit.fitProcess(sizeOfBlocks, sizeOfProcesses);
testMemAllocation = new ArrayList<>(
Arrays.asList( -255, -255)
);
assertEquals(testMemAllocation, memAllocation);
}
}

76
src/test/java/com/thealgorithms/others/NextFitTest.java Normal file
View File

@ -0,0 +1,76 @@
package com.thealgorithms.others;
import org.junit.jupiter.api.Test;
import java.util.ArrayList;
import java.util.Arrays;
import static org.junit.jupiter.api.Assertions.*;
/**
* author Alexandros Lemonaris
*/
class NextFitCPUTest {
int [] sizeOfBlocks;
int [] sizeOfProcesses;
ArrayList<Integer> memAllocation = new ArrayList<>();
ArrayList<Integer> testMemAllocation ;
CPUalgorithms nextFit = new NextFit();
@Test
void testFitForUseOfOneBlock() {
//test1 - third process does not fit because of algorithms procedure
sizeOfBlocks = new int[]{5, 12, 17, 10};
sizeOfProcesses = new int[]{10, 5, 15, 2};
memAllocation = nextFit.fitProcess(sizeOfBlocks, sizeOfProcesses);
testMemAllocation = new ArrayList<>(
Arrays.asList(1, 2, -255, 2)
);
assertEquals(testMemAllocation, memAllocation);
}
@Test
void testFitForEqualProcecesses() {
//test2
sizeOfBlocks = new int[]{5, 12, 17, 10};
sizeOfProcesses = new int[]{10, 10, 10, 10};
memAllocation = nextFit.fitProcess(sizeOfBlocks, sizeOfProcesses);
testMemAllocation = new ArrayList<>(
Arrays.asList(1, 2, 3, -255)
);
assertEquals(testMemAllocation, memAllocation);
}
@Test
void testFitForNoEmptyBlockCell() {
//test3 for more processes than blocks - no empty space left to none of the blocks
sizeOfBlocks = new int[]{5, 12, 17};
sizeOfProcesses = new int[]{5, 12, 10, 7};
memAllocation = nextFit.fitProcess(sizeOfBlocks, sizeOfProcesses);
testMemAllocation = new ArrayList<>(
Arrays.asList(0, 1, 2, 2)
);
assertEquals(testMemAllocation, memAllocation);
}
@Test
void testFitForSameInputDifferentQuery() {
//test4 for more processes than blocks - one element does not fit due to input series
sizeOfBlocks = new int[]{5, 12, 17};
sizeOfProcesses = new int[]{5, 7, 10, 12};
memAllocation = nextFit.fitProcess(sizeOfBlocks, sizeOfProcesses);
testMemAllocation = new ArrayList<>(
Arrays.asList(0, 1, 2, -255)
);
assertEquals(testMemAllocation, memAllocation);
}
@Test
void testFitForMoreBlocksNoFit() {
//test5 for more blocks than processes
sizeOfBlocks = new int[] {5, 4, -1, 3, 6};
sizeOfProcesses = new int [] {10, 11};
memAllocation = nextFit.fitProcess(sizeOfBlocks, sizeOfProcesses);
testMemAllocation = new ArrayList<>(
Arrays.asList( -255, -255)
);
assertEquals(testMemAllocation, memAllocation);
}
}

87
src/test/java/com/thealgorithms/others/WorstFitCPUTest.java Normal file
View File

@ -0,0 +1,87 @@
package com.thealgorithms.others;
import org.junit.jupiter.api.Test;
import java.util.ArrayList;
import java.util.Arrays;
import static org.junit.jupiter.api.Assertions.*;
/**
* author Alexandros Lemonaris
*/
class WorstFitCPUTest {
int [] sizeOfBlocks;
int [] sizeOfProcesses;
ArrayList<Integer> memAllocation = new ArrayList<>();
ArrayList<Integer> testMemAllocation ;
CPUalgorithms worstFit = new WorstFitCPU();
@Test
void testFitForUseOfOneBlock() {
//test1
sizeOfBlocks = new int[]{5, 12, 17, 10};
sizeOfProcesses = new int[]{10, 5, 15, 2};
memAllocation = worstFit.fitProcess(sizeOfBlocks, sizeOfProcesses);
testMemAllocation = new ArrayList<>(
Arrays.asList(2, 1, -255, 3)
);
assertEquals(testMemAllocation, memAllocation);
}
@Test
void testFitForEqualProcecesses() {
//test2
sizeOfBlocks = new int[]{5, 12, 17, 10};
sizeOfProcesses = new int[]{10, 10, 10, 10};
memAllocation = worstFit.fitProcess(sizeOfBlocks, sizeOfProcesses);
testMemAllocation = new ArrayList<>(
Arrays.asList(2, 1, 3, -255)
);
assertEquals(testMemAllocation, memAllocation);
}
@Test
void testFitForNoEmptyBlockCell() {
//test3 - could suits best, bad use of memory allocation due to worstFit algorithm
sizeOfBlocks = new int[]{5, 12, 17};
sizeOfProcesses = new int[]{5, 12, 10, 7};
memAllocation = worstFit.fitProcess(sizeOfBlocks, sizeOfProcesses);
testMemAllocation = new ArrayList<>(
Arrays.asList(2, 1, 2, -255)
);
assertEquals(testMemAllocation, memAllocation);
}
@Test
void testFitForSameInputDifferentQuery() {
//test4 same example different series - same results
sizeOfBlocks = new int[]{5, 12, 17};
sizeOfProcesses = new int[]{5, 7, 10, 12};
memAllocation = worstFit.fitProcess(sizeOfBlocks, sizeOfProcesses);
testMemAllocation = new ArrayList<>(
Arrays.asList(2, 1, 2, -255)
);
assertEquals(testMemAllocation, memAllocation);
}
@Test
void testFitForMoreBlocksNoFit() {
//test5 for more blocks than processes
sizeOfBlocks = new int[] {5, 4, -1, 3, 6};
sizeOfProcesses = new int [] {10, 11};
memAllocation = worstFit.fitProcess(sizeOfBlocks, sizeOfProcesses);
testMemAllocation = new ArrayList<>(
Arrays.asList( -255, -255)
);
assertEquals(testMemAllocation, memAllocation);
}
@Test
void testFitBadCase() {
//test6 for only two process fit
sizeOfBlocks = new int[] {7, 17, 7, 5, 6};
sizeOfProcesses = new int [] {8, 10, 10, 8, 8, 8};
memAllocation = worstFit.fitProcess(sizeOfBlocks, sizeOfProcesses);
testMemAllocation = new ArrayList<>(
Arrays.asList( 1, -255, -255, 1, -255, -255)
);
assertEquals(testMemAllocation, memAllocation);
}
}