RoundRobinScheduling.java

package algorithms;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.Queue;

public class RoundRobinScheduling {

	public void schedule(Process[] processes, int quantum) {
		// Create a copy of the processes to avoid modifying the original array
		Process[] processesCopy = new Process[processes.length];
		for (int i = 0; i < processes.length; i++) {
			processesCopy[i] = new Process(processes[i].id,
					processes[i].burstTime, processes[i].priority,
					processes[i].arrivalTime);
		}

		// Sort processes by arrival time
		Arrays.sort(processesCopy, (a, b) -> a.arrivalTime - b.arrivalTime);

		// Initialize variables
		int currentTime = 0;
		int[] remainingBurstTime = new int[processesCopy.length];
		boolean[] completed = new boolean[processesCopy.length];
		int completedCount = 0;

		// Initialize remaining burst time
		for (int i = 0; i < processesCopy.length; i++) {
			remainingBurstTime[i] = processesCopy[i].burstTime;
		}

		// Initialize data structures for Gantt chart
		ArrayList<Integer> executionOrder = new ArrayList<>();
		ArrayList<Integer> executionTimes = new ArrayList<>();
		executionTimes.add(0); // Start time

		// Initialize queue for ready processes
		Queue<Integer> readyQueue = new LinkedList<>();

		// Add initially arrived processes to ready queue
		for (int i = 0; i < processesCopy.length; i++) {
			if (processesCopy[i].arrivalTime == 0) {
				readyQueue.add(i);
			}
		}

		while (completedCount < processesCopy.length) {
			// If ready queue is empty, find the next arriving process
			if (readyQueue.isEmpty()) {
				int nextArrival = Integer.MAX_VALUE;
				int nextProcess = -1;

				for (int i = 0; i < processesCopy.length; i++) {
					if (!completed[i]
							&& processesCopy[i].arrivalTime > currentTime
							&& processesCopy[i].arrivalTime < nextArrival) {
						nextArrival = processesCopy[i].arrivalTime;
						nextProcess = i;
					}
				}

				if (nextProcess != -1) {
					currentTime = nextArrival;
					readyQueue.add(nextProcess);
				} else {
					// This should not happen with valid input
					break;
				}
			}

			// Get the next process from ready queue
			int currentProcess = readyQueue.poll();

			// If this is the first time the process executes, set its start
			// time
			if (remainingBurstTime[currentProcess] == processesCopy[currentProcess].burstTime) {
				processesCopy[currentProcess].startTime = currentTime;
			}

			// Calculate execution time for this quantum
			int executeTime = Math.min(remainingBurstTime[currentProcess],
					quantum);

			// Update Gantt chart data
			executionOrder.add(processesCopy[currentProcess].id);
			currentTime += executeTime;
			executionTimes.add(currentTime);

			// Reduce remaining burst time
			remainingBurstTime[currentProcess] -= executeTime;

			// Check for new arrivals during this time quantum
			for (int i = 0; i < processesCopy.length; i++) {
				if (!completed[i] && !readyQueue.contains(i)
						&& i != currentProcess
						&& processesCopy[i].arrivalTime <= currentTime
						&& processesCopy[i].arrivalTime > currentTime
								- executeTime) {
					readyQueue.add(i);
				}
			}

			// Check if process is completed
			if (remainingBurstTime[currentProcess] == 0) {
				completed[currentProcess] = true;
				completedCount++;

				// Update process metrics
				processesCopy[currentProcess].completionTime = currentTime;
				processesCopy[currentProcess].turnAroundTime = processesCopy[currentProcess].completionTime
						- processesCopy[currentProcess].arrivalTime;
				processesCopy[currentProcess].waitingTime = processesCopy[currentProcess].turnAroundTime
						- processesCopy[currentProcess].burstTime;
			} else {
				// Process still has remaining time, add back to ready queue
				readyQueue.add(currentProcess);
			}
		}

		// Store Gantt chart data in the first process for access
		if (processes.length > 0) {
			processes[0].ganttData = executionOrder;
			processes[0].ganttTimes = executionTimes;
		}

		// Update the original process array with computed values
		for (Process process : processesCopy) {
			for (Process originalProcess : processes) {
				if (originalProcess.id == process.id) {
					originalProcess.startTime = process.startTime;
					originalProcess.completionTime = process.completionTime;
					originalProcess.turnAroundTime = process.turnAroundTime;
					originalProcess.waitingTime = process.waitingTime;
					break;
				}
			}
		}
	}

	public double getAverageWaitingTime(Process[] processes) {
		double totalWaitingTime = 0;
		for (Process process : processes) {
			totalWaitingTime += process.waitingTime;
		}
		return totalWaitingTime / processes.length;
	}

	public double getAverageTurnaroundTime(Process[] processes) {
		double totalTurnaroundTime = 0;
		for (Process process : processes) {
			totalTurnaroundTime += process.turnAroundTime;
		}
		return totalTurnaroundTime / processes.length;
	}
}