From 646bff819648b8ad85eacb3548edf90c4f117c85 Mon Sep 17 00:00:00 2001 From: alexlemo20 Date: Sat, 5 Feb 2022 16:19:43 +0200 Subject: [PATCH 1/2] Compressed CPU algorithms(FirstFit, BestFit, WorstFit) to one "mother"-runnable class --- .../thealgorithms/others/CPUalgorithms.java | 307 ++++++++++++++++++ 1 file changed, 307 insertions(+) create mode 100644 src/main/java/com/thealgorithms/others/CPUalgorithms.java diff --git a/src/main/java/com/thealgorithms/others/CPUalgorithms.java b/src/main/java/com/thealgorithms/others/CPUalgorithms.java new file mode 100644 index 000000000000..869cc3f16e29 --- /dev/null +++ b/src/main/java/com/thealgorithms/others/CPUalgorithms.java @@ -0,0 +1,307 @@ +package com.thealgorithms.others; +/** + * @author Alexandros Lemonaris + */ + +import java.util.ArrayList; + +public abstract class CPUalgorithms { + public static void main (String [] args){ + CPUalgorithms algorithm = new FirstFitCPU(); + int [] sizeOfBlocks = {15, 40, 10, 20}; + int [] sizesOfProcesses = {10, 40, 25, 30}; + ArrayList memoryAllocation = algorithm.fitProcess(sizeOfBlocks, sizesOfProcesses); + algorithm.printMemoryAllocation(memoryAllocation); + } + + /** + * 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 fitProcess(int[] sizeOfBlocks, int[] sizeOfProcesses); + + /** + * Method to print the memory allocated. + * + * @param memAllocation: an ArrayList of Integer representing the memory + * allocation done by the worstFit method. + */ + public abstract void printMemoryAllocation(ArrayList memAllocation); +} +/** + * @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 fitProcess(int[] sizeOfBlocks, int[] sizeOfProcesses) { + // The array list responsible for saving the memory allocations done by the best-fit algorithm + ArrayList 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 void printMemoryAllocation(ArrayList 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\t"); + if (memAllocation.get(i) != NO_ALLOCATION) { + System.out.print(memAllocation.get(i)); + } else { + System.out.print("Not Allocated"); + } + System.out.println(); + } + } +} + +/** + * @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 fitProcess(int[] sizeOfBlocks, int[] sizeOfProcesses) { + // The array list responsible for saving the memory allocations done by the worst-fit algorithm + ArrayList 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 void printMemoryAllocation(ArrayList 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\t"); + if (memAllocation.get(i) != NO_ALLOCATION) { + System.out.print(memAllocation.get(i)); + } else { + System.out.print("Not Allocated"); + } + System.out.println(); + } + } +} + +/** + * @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 fitProcess(int[] sizeOfBlocks, int[] sizeOfProcesses) { + // The array list responsible for saving the memory allocations done by the first-fit algorithm + ArrayList 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 void printMemoryAllocation(ArrayList 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\t"); + if (memAllocation.get(i) != NO_ALLOCATION) { + System.out.print(memAllocation.get(i)); + } else { + System.out.print("Not Allocated"); + } + System.out.println(); + } + } +} + + From cf6c020fffb4e22ade586ceb1541b86279c52dd7 Mon Sep 17 00:00:00 2001 From: alexlemo20 Date: Thu, 10 Feb 2022 09:22:58 +0200 Subject: [PATCH 2/2] Removed main, printing methods, added nextfit and testing methods for CPU algorithms. --- .../com/thealgorithms/others/BestFit.java | 106 --------------- .../thealgorithms/others/CPUalgorithms.java | 126 +++++++++--------- .../com/thealgorithms/others/FirstFit.java | 81 ----------- .../com/thealgorithms/others/WorstFit.java | 89 ------------- .../thealgorithms/others/BestFitCPUTest.java | 76 +++++++++++ .../thealgorithms/others/FirstFitCPUTest.java | 76 +++++++++++ .../com/thealgorithms/others/NextFitTest.java | 76 +++++++++++ .../thealgorithms/others/WorstFitCPUTest.java | 87 ++++++++++++ 8 files changed, 375 insertions(+), 342 deletions(-) delete mode 100644 src/main/java/com/thealgorithms/others/BestFit.java delete mode 100644 src/main/java/com/thealgorithms/others/FirstFit.java delete mode 100644 src/main/java/com/thealgorithms/others/WorstFit.java create mode 100644 src/test/java/com/thealgorithms/others/BestFitCPUTest.java create mode 100644 src/test/java/com/thealgorithms/others/FirstFitCPUTest.java create mode 100644 src/test/java/com/thealgorithms/others/NextFitTest.java create mode 100644 src/test/java/com/thealgorithms/others/WorstFitCPUTest.java diff --git a/src/main/java/com/thealgorithms/others/BestFit.java b/src/main/java/com/thealgorithms/others/BestFit.java deleted file mode 100644 index f5ee41a761fd..000000000000 --- a/src/main/java/com/thealgorithms/others/BestFit.java +++ /dev/null @@ -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 bestFit(int[] sizeOfBlocks, int[] sizeOfProcesses) { - // The array list responsible for saving the memory allocations done by the best-fit algorithm - ArrayList 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 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(); - } - } -} diff --git a/src/main/java/com/thealgorithms/others/CPUalgorithms.java b/src/main/java/com/thealgorithms/others/CPUalgorithms.java index 869cc3f16e29..89205f98169f 100644 --- a/src/main/java/com/thealgorithms/others/CPUalgorithms.java +++ b/src/main/java/com/thealgorithms/others/CPUalgorithms.java @@ -6,13 +6,6 @@ import java.util.ArrayList; public abstract class CPUalgorithms { - public static void main (String [] args){ - CPUalgorithms algorithm = new FirstFitCPU(); - int [] sizeOfBlocks = {15, 40, 10, 20}; - int [] sizesOfProcesses = {10, 40, 25, 30}; - ArrayList memoryAllocation = algorithm.fitProcess(sizeOfBlocks, sizesOfProcesses); - algorithm.printMemoryAllocation(memoryAllocation); - } /** * Method to allocate memory to blocks according to CPU algorithms. @@ -29,13 +22,6 @@ public static void main (String [] args){ */ public abstract ArrayList fitProcess(int[] sizeOfBlocks, int[] sizeOfProcesses); - /** - * Method to print the memory allocated. - * - * @param memAllocation: an ArrayList of Integer representing the memory - * allocation done by the worstFit method. - */ - public abstract void printMemoryAllocation(ArrayList memAllocation); } /** * @author Dekas Dimitrios @@ -119,25 +105,6 @@ public ArrayList fitProcess(int[] sizeOfBlocks, int[] sizeOfProcesses) return memAlloc; } - /** - * Method to print the memory allocated. - * - * @param memAllocation: an ArrayList of Integer representing the memory - * allocation done by the bestFit method. - */ - public void printMemoryAllocation(ArrayList 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\t"); - if (memAllocation.get(i) != NO_ALLOCATION) { - System.out.print(memAllocation.get(i)); - } else { - System.out.print("Not Allocated"); - } - System.out.println(); - } - } } /** @@ -205,25 +172,6 @@ public ArrayList fitProcess(int[] sizeOfBlocks, int[] sizeOfProcesses) return memAlloc; } - /** - * Method to print the memory allocated. - * - * @param memAllocation: an ArrayList of Integer representing the memory - * allocation done by the worstFit method. - */ - public void printMemoryAllocation(ArrayList 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\t"); - if (memAllocation.get(i) != NO_ALLOCATION) { - System.out.print(memAllocation.get(i)); - } else { - System.out.print("Not Allocated"); - } - System.out.println(); - } - } } /** @@ -283,25 +231,71 @@ public ArrayList fitProcess(int[] sizeOfBlocks, int[] sizeOfProcesses) 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 print the memory allocated. + * 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 memAllocation: an ArrayList of Integer representing the memory - * allocation done by the firstFit method. + * @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. */ - public void printMemoryAllocation(ArrayList 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\t"); - if (memAllocation.get(i) != NO_ALLOCATION) { - System.out.print(memAllocation.get(i)); - } else { - System.out.print("Not Allocated"); + 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; } - System.out.println(); } + // 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 fitProcess(int[] sizeOfBlocks, int[] sizeOfProcesses) { + // The array list responsible for saving the memory allocations done by the first-fit algorithm + ArrayList 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; } -} +} diff --git a/src/main/java/com/thealgorithms/others/FirstFit.java b/src/main/java/com/thealgorithms/others/FirstFit.java deleted file mode 100644 index c7035d66a9a0..000000000000 --- a/src/main/java/com/thealgorithms/others/FirstFit.java +++ /dev/null @@ -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 firstFit(int[] sizeOfBlocks, int[] sizeOfProcesses) { - // The array list responsible for saving the memory allocations done by the first-fit algorithm - ArrayList 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 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(); - } - } -} diff --git a/src/main/java/com/thealgorithms/others/WorstFit.java b/src/main/java/com/thealgorithms/others/WorstFit.java deleted file mode 100644 index 69aedc1e9fc4..000000000000 --- a/src/main/java/com/thealgorithms/others/WorstFit.java +++ /dev/null @@ -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 worstFit(int[] sizeOfBlocks, int[] sizeOfProcesses) { - // The array list responsible for saving the memory allocations done by the worst-fit algorithm - ArrayList 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 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(); - } - } -} diff --git a/src/test/java/com/thealgorithms/others/BestFitCPUTest.java b/src/test/java/com/thealgorithms/others/BestFitCPUTest.java new file mode 100644 index 000000000000..d1ab591655d3 --- /dev/null +++ b/src/test/java/com/thealgorithms/others/BestFitCPUTest.java @@ -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 memAllocation = new ArrayList<>(); + ArrayList 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); + } +} \ No newline at end of file diff --git a/src/test/java/com/thealgorithms/others/FirstFitCPUTest.java b/src/test/java/com/thealgorithms/others/FirstFitCPUTest.java new file mode 100644 index 000000000000..45a501c268b0 --- /dev/null +++ b/src/test/java/com/thealgorithms/others/FirstFitCPUTest.java @@ -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 memAllocation = new ArrayList<>(); + ArrayList 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); + } +} \ No newline at end of file diff --git a/src/test/java/com/thealgorithms/others/NextFitTest.java b/src/test/java/com/thealgorithms/others/NextFitTest.java new file mode 100644 index 000000000000..27c17eaf0369 --- /dev/null +++ b/src/test/java/com/thealgorithms/others/NextFitTest.java @@ -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 memAllocation = new ArrayList<>(); + ArrayList 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); + } +} \ No newline at end of file diff --git a/src/test/java/com/thealgorithms/others/WorstFitCPUTest.java b/src/test/java/com/thealgorithms/others/WorstFitCPUTest.java new file mode 100644 index 000000000000..cb3f58a4c49a --- /dev/null +++ b/src/test/java/com/thealgorithms/others/WorstFitCPUTest.java @@ -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 memAllocation = new ArrayList<>(); + ArrayList 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); + } +} \ No newline at end of file