From 2001a097e2ab9fd2f63d444ace41cf3c59e2e251 Mon Sep 17 00:00:00 2001 From: Hardik Pawar <97388607+Hardvan@users.noreply.github.com> Date: Mon, 7 Oct 2024 16:55:08 +0530 Subject: [PATCH] Add `HighestResponseRatioNextScheduling.java` new algorithm with tests (#5607) * Add `HighestResponseRatioNextScheduling.java` new algorithm with tests * Update directory * Improve class documentation * Update directory * Fix * Fix * Fix * Add suggested changes * Fix clang errors --------- Co-authored-by: Hardvan Co-authored-by: Alex Klymenko --- DIRECTORY.md | 2 + .../HighestResponseRatioNextScheduling.java | 158 ++++++++++++++++++ ...ighestResponseRatioNextSchedulingTest.java | 112 +++++++++++++ 3 files changed, 272 insertions(+) create mode 100644 src/main/java/com/thealgorithms/scheduling/HighestResponseRatioNextScheduling.java create mode 100644 src/test/java/com/thealgorithms/scheduling/HighestResponseRatioNextSchedulingTest.java diff --git a/DIRECTORY.md b/DIRECTORY.md index d93dde3df..7e9f5357a 100644 --- a/DIRECTORY.md +++ b/DIRECTORY.md @@ -459,6 +459,7 @@ * [GenerateSubsets](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/Recursion/GenerateSubsets.java) * scheduling * [FCFSScheduling](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/scheduling/FCFSScheduling.java) + * [HighestResponseRatioNextScheduling](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/scheduling/HighestResponseRatioNextScheduling.java) * [MLFQScheduler](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/scheduling/MLFQScheduler.java) * [PreemptivePriorityScheduling](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/scheduling/PreemptivePriorityScheduling.java) * [RRScheduling](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/scheduling/RRScheduling.java) @@ -916,6 +917,7 @@ * [GenerateSubsetsTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/Recursion/GenerateSubsetsTest.java) * scheduling * [FCFSSchedulingTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/scheduling/FCFSSchedulingTest.java) + * [HighestResponseRatioNextSchedulingTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/scheduling/HighestResponseRatioNextSchedulingTest.java) * [MLFQSchedulerTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/scheduling/MLFQSchedulerTest.java) * [PreemptivePrioritySchedulingTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/scheduling/PreemptivePrioritySchedulingTest.java) * [RRSchedulingTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/scheduling/RRSchedulingTest.java) diff --git a/src/main/java/com/thealgorithms/scheduling/HighestResponseRatioNextScheduling.java b/src/main/java/com/thealgorithms/scheduling/HighestResponseRatioNextScheduling.java new file mode 100644 index 000000000..8ed689698 --- /dev/null +++ b/src/main/java/com/thealgorithms/scheduling/HighestResponseRatioNextScheduling.java @@ -0,0 +1,158 @@ +package com.thealgorithms.scheduling; + +import java.util.Arrays; +import java.util.Comparator; + +/** + * The {@code HighestResponseRatioNextScheduling} class implements the + * Highest Response Ratio Next (HRRN) scheduling algorithm. + * HRRN is a non-preemptive scheduling algorithm that selects the process with + * the highest response ratio for execution. + * The response ratio is calculated as: + * + * 
+ *     Response Ratio = (waiting time + burst time) / burst time
+ *
+ * + * HRRN is designed to reduce the average waiting time and improve overall + * system performance by balancing between short and long processes, + * minimizing process starvation. + */ +public final class HighestResponseRatioNextScheduling { + + private static final int PROCESS_NOT_FOUND = -1; + private static final double INITIAL_MAX_RESPONSE_RATIO = -1.0; + + private HighestResponseRatioNextScheduling() { + } + + /** + * Represents a process in the scheduling algorithm. + */ + private static class Process { + String name; + int arrivalTime; + int burstTime; + int turnAroundTime; + boolean finished; + + Process(String name, int arrivalTime, int burstTime) { + this.name = name; + this.arrivalTime = arrivalTime; + this.burstTime = burstTime; + this.turnAroundTime = 0; + this.finished = false; + } + + /** + * Calculates the response ratio for this process. + * + * @param currentTime The current time in the scheduling process. + * @return The response ratio for this process. + */ + double calculateResponseRatio(int currentTime) { + return (double) (burstTime + currentTime - arrivalTime) / burstTime; + } + } + + /** + * Calculates the Turn Around Time (TAT) for each process. + * + *

Turn Around Time is calculated as the total time a process spends + * in the system from arrival to completion. It is the sum of the burst time + * and the waiting time.

+ * + * @param processNames Array of process names. + * @param arrivalTimes Array of arrival times corresponding to each process. + * @param burstTimes Array of burst times for each process. + * @param noOfProcesses The number of processes. + * @return An array of Turn Around Times for each process. + */ + public static int[] calculateTurnAroundTime(final String[] processNames, final int[] arrivalTimes, final int[] burstTimes, final int noOfProcesses) { + int currentTime = 0; + int[] turnAroundTime = new int[noOfProcesses]; + Process[] processes = new Process[noOfProcesses]; + + for (int i = 0; i < noOfProcesses; i++) { + processes[i] = new Process(processNames[i], arrivalTimes[i], burstTimes[i]); + } + + Arrays.sort(processes, Comparator.comparingInt(p -> p.arrivalTime)); + + int finishedProcessCount = 0; + while (finishedProcessCount < noOfProcesses) { + int nextProcessIndex = findNextProcess(processes, currentTime); + if (nextProcessIndex == PROCESS_NOT_FOUND) { + currentTime++; + continue; + } + + Process currentProcess = processes[nextProcessIndex]; + currentTime = Math.max(currentTime, currentProcess.arrivalTime); + currentProcess.turnAroundTime = currentTime + currentProcess.burstTime - currentProcess.arrivalTime; + currentTime += currentProcess.burstTime; + currentProcess.finished = true; + finishedProcessCount++; + } + + for (int i = 0; i < noOfProcesses; i++) { + turnAroundTime[i] = processes[i].turnAroundTime; + } + + return turnAroundTime; + } + + /** + * Calculates the Waiting Time (WT) for each process. + * + * @param turnAroundTime The Turn Around Times for each process. + * @param burstTimes The burst times for each process. + * @return An array of Waiting Times for each process. + */ + public static int[] calculateWaitingTime(int[] turnAroundTime, int[] burstTimes) { + int[] waitingTime = new int[turnAroundTime.length]; + for (int i = 0; i < turnAroundTime.length; i++) { + waitingTime[i] = turnAroundTime[i] - burstTimes[i]; + } + return waitingTime; + } + + /** + * Finds the next process to be scheduled based on arrival times and the current time. + * + * @param processes Array of Process objects. + * @param currentTime The current time in the scheduling process. + * @return The index of the next process to be scheduled, or PROCESS_NOT_FOUND if no process is ready. + */ + private static int findNextProcess(Process[] processes, int currentTime) { + return findHighestResponseRatio(processes, currentTime); + } + + /** + * Finds the process with the highest response ratio. + * + *

The response ratio is calculated as: + * (waiting time + burst time) / burst time + * where waiting time = current time - arrival time

+ * + * @param processes Array of Process objects. + * @param currentTime The current time in the scheduling process. + * @return The index of the process with the highest response ratio, or PROCESS_NOT_FOUND if no process is ready. + */ + private static int findHighestResponseRatio(Process[] processes, int currentTime) { + double maxResponseRatio = INITIAL_MAX_RESPONSE_RATIO; + int maxIndex = PROCESS_NOT_FOUND; + + for (int i = 0; i < processes.length; i++) { + Process process = processes[i]; + if (!process.finished && process.arrivalTime <= currentTime) { + double responseRatio = process.calculateResponseRatio(currentTime); + if (responseRatio > maxResponseRatio) { + maxResponseRatio = responseRatio; + maxIndex = i; + } + } + } + return maxIndex; + } +} diff --git a/src/test/java/com/thealgorithms/scheduling/HighestResponseRatioNextSchedulingTest.java b/src/test/java/com/thealgorithms/scheduling/HighestResponseRatioNextSchedulingTest.java new file mode 100644 index 000000000..d225d76b8 --- /dev/null +++ b/src/test/java/com/thealgorithms/scheduling/HighestResponseRatioNextSchedulingTest.java @@ -0,0 +1,112 @@ +package com.thealgorithms.scheduling; + +import static org.junit.jupiter.api.Assertions.assertArrayEquals; + +import org.junit.jupiter.api.Test; + +public class HighestResponseRatioNextSchedulingTest { + + @Test + public void testCalculateTurnAroundTime() { + String[] processNames = {"A", "B", "C"}; + int[] arrivalTimes = {0, 2, 4}; + int[] burstTimes = {3, 1, 2}; + int noOfProcesses = 3; + + int[] expectedTurnAroundTimes = {3, 2, 2}; + int[] actualTurnAroundTimes = HighestResponseRatioNextScheduling.calculateTurnAroundTime(processNames, arrivalTimes, burstTimes, noOfProcesses); + + assertArrayEquals(expectedTurnAroundTimes, actualTurnAroundTimes, "Turn Around Times do not match"); + } + + @Test + public void testCalculateWaitingTime() { + int[] turnAroundTimes = {3, 1, 5}; + int[] burstTimes = {3, 1, 2}; + + int[] expectedWaitingTimes = {0, 0, 3}; + int[] actualWaitingTimes = HighestResponseRatioNextScheduling.calculateWaitingTime(turnAroundTimes, burstTimes); + + assertArrayEquals(expectedWaitingTimes, actualWaitingTimes, "Waiting Times do not match"); + } + + @Test + public void testCompleteSchedulingScenario() { + String[] processNames = {"A", "B", "C"}; + int[] arrivalTimes = {0, 1, 2}; + int[] burstTimes = {5, 2, 1}; + + int[] expectedTurnAroundTimes = {5, 7, 4}; + int[] turnAroundTimes = HighestResponseRatioNextScheduling.calculateTurnAroundTime(processNames, arrivalTimes, burstTimes, processNames.length); + assertArrayEquals(expectedTurnAroundTimes, turnAroundTimes, "Turn Around Times do not match"); + + int[] expectedWaitingTimes = {0, 5, 3}; + int[] waitingTimes = HighestResponseRatioNextScheduling.calculateWaitingTime(turnAroundTimes, burstTimes); + assertArrayEquals(expectedWaitingTimes, waitingTimes, "Waiting Times do not match"); + } + + @Test + public void testZeroProcesses() { + String[] processNames = {}; + int[] arrivalTimes = {}; + int[] burstTimes = {}; + int noOfProcesses = 0; + + int[] expectedTurnAroundTimes = {}; + int[] actualTurnAroundTimes = HighestResponseRatioNextScheduling.calculateTurnAroundTime(processNames, arrivalTimes, burstTimes, noOfProcesses); + + assertArrayEquals(expectedTurnAroundTimes, actualTurnAroundTimes, "Turn Around Times for zero processes should be an empty array"); + } + + @Test + public void testAllProcessesArriveAtSameTime() { + String[] processNames = {"A", "B", "C", "D"}; + int[] arrivalTimes = {0, 0, 0, 0}; + int[] burstTimes = {4, 3, 1, 2}; + int noOfProcesses = 4; + + int[] expectedTurnAroundTimes = {4, 10, 5, 7}; + int[] actualTurnAroundTimes = HighestResponseRatioNextScheduling.calculateTurnAroundTime(processNames, arrivalTimes, burstTimes, noOfProcesses); + + assertArrayEquals(expectedTurnAroundTimes, actualTurnAroundTimes, "Turn Around Times for processes arriving at the same time do not match"); + } + + @Test + public void testProcessesWithZeroBurstTime() { + String[] processNames = {"A", "B", "C"}; + int[] arrivalTimes = {0, 1, 2}; + int[] burstTimes = {3, 0, 2}; + int noOfProcesses = 3; + + int[] expectedTurnAroundTimes = {3, 2, 3}; + int[] actualTurnAroundTimes = HighestResponseRatioNextScheduling.calculateTurnAroundTime(processNames, arrivalTimes, burstTimes, noOfProcesses); + + assertArrayEquals(expectedTurnAroundTimes, actualTurnAroundTimes, "Turn Around Times for processes with zero burst time do not match"); + } + + @Test + public void testProcessesWithLargeGapsBetweenArrivals() { + String[] processNames = {"A", "B", "C"}; + int[] arrivalTimes = {0, 100, 200}; + int[] burstTimes = {10, 10, 10}; + int noOfProcesses = 3; + + int[] expectedTurnAroundTimes = {10, 10, 10}; + int[] actualTurnAroundTimes = HighestResponseRatioNextScheduling.calculateTurnAroundTime(processNames, arrivalTimes, burstTimes, noOfProcesses); + + assertArrayEquals(expectedTurnAroundTimes, actualTurnAroundTimes, "Turn Around Times for processes with large gaps between arrivals do not match"); + } + + @Test + public void testProcessesWithVeryLargeBurstTimes() { + String[] processNames = {"A", "B"}; + int[] arrivalTimes = {0, 1}; + int[] burstTimes = {Integer.MAX_VALUE / 2, Integer.MAX_VALUE / 2}; + int noOfProcesses = 2; + + int[] expectedTurnAroundTimes = {Integer.MAX_VALUE / 2, Integer.MAX_VALUE - 2}; + int[] actualTurnAroundTimes = HighestResponseRatioNextScheduling.calculateTurnAroundTime(processNames, arrivalTimes, burstTimes, noOfProcesses); + + assertArrayEquals(expectedTurnAroundTimes, actualTurnAroundTimes, "Turn Around Times for processes with very large burst times do not match"); + } +}