Round Robin Scheduling

// Round Robin Example with quantum = 2
// Process | Arrival | Burst
//    P1   |    0    |   5
//    P2   |    0    |   3
//    P3   |    0    |   1
//    P4   |    0    |   2
//
// Queue order at start: [P1, P2, P3, P4]
// t=0: P1 runs 2 → remaining=3, queue: [P2, P3, P4, P1]
// t=2: P2 runs 2 → remaining=1, queue: [P3, P4, P1, P2]
// t=4: P3 runs 1 → done!         queue: [P4, P1, P2]
// t=5: P4 runs 2 → done!         queue: [P1, P2]
// t=7: P1 runs 2 → remaining=1,  queue: [P2, P1]
// t=9: P2 runs 1 → done!         queue: [P1]
// t=10:P1 runs 1 → done!
//
// Gantt: |P1|P2|P3|P4|--|P1|P2|P1|
//         0  2  4  5  7  9 10  11
//
// Turnaround: P1=11, P2=10, P3=5, P4=7
// Waiting:    P1=6,  P2=7,  P3=4, P4=5
// Avg Waiting = (6+7+4+5)/4 = 5.5

int quantum = 2;
int[] burst = {5, 3, 1, 2};
int[] remaining = burst.clone();
int n = burst.length;
int[] finish = new int[n];
int time = 0;

Queue<Integer> queue = new LinkedList<>();
for (int i = 0; i < n; i++) queue.add(i);

while (!queue.isEmpty()) {
    int i = queue.poll();
    if (remaining[i] > 0) {
        int run = Math.min(remaining[i], quantum);
        System.out.printf("P%d runs t=%d to t=%d%n", i+1, time, time + run);
        time += run;
        remaining[i] -= run;
        if (remaining[i] > 0) queue.add(i);
        else finish[i] = time;
    }
}
// Print results
for (int i = 0; i < n; i++)
    System.out.printf("P%d finish=%d, turnaround=%d%n", i+1, finish[i], finish[i] - 0);

// Demonstrating quantum size impact on context switches
// Smaller quantum = better response time but more context switches

// Formula: if avg burst = B and quantum = q
// If q >= B: most processes finish in one quantum → behaves like FCFS
// If q << B: each process gets many tiny slices → high context switch overhead

// Simulating context switch count for different quantum sizes
int[] burstTimes = {12, 4, 8, 6, 10}; // ms
int[] quantums = {1, 2, 4, 8, 20};

for (int q : quantums) {
    int switches = 0;
    int[] rem = burstTimes.clone();
    boolean anyLeft = true;
    while (anyLeft) {
        anyLeft = false;
        for (int i = 0; i < rem.length; i++) {
            if (rem[i] > 0) {
                anyLeft = true;
                switches++;   // each time slice = 1 context switch
                rem[i] = Math.max(0, rem[i] - q);
            }
        }
    }
    System.out.printf("Quantum=%2d ms → Context switches: %d%n", q, switches);
}
// quantum=1:  many switches (expensive)
// quantum=20: few switches (but poor response time for short jobs)