Round Robin in OS

#include <stdio.h>
#include <stdlib.h>

#define MAX 100

struct Process {
    int pid;
    int arrival;
    int burst;
    int remaining;
    int completion;
    int turnaround;
    int waiting;
    int started;
};

void enqueue(int queue[], int *rear, int value) {
    queue[++(*rear)] = value;
}

int dequeue(int queue[], int *front, int *rear) {
    if (*front > *rear) return -1;
    return queue[(*front)++];
}

int isInQueue(int queue[], int front, int rear, int pid) {
    for (int i = front; i <= rear; i++) {
        if (queue[i] == pid) return 1;
    }
    return 0;
}

int main() {
    int n, timeQuantum;
    printf("Enter number of processes: ");
    scanf("%d", &n);

    struct Process p[n];
    for (int i = 0; i < n; i++) {
        p[i].pid = i + 1;
        printf("Enter Arrival Time and Burst Time for P%d: ", p[i].pid);
        scanf("%d %d", &p[i].arrival, &p[i].burst);
        p[i].remaining = p[i].burst;
        p[i].started = 0;
    }

    printf("Enter Time Quantum: ");
    scanf("%d", &timeQuantum);

    int queue[MAX], front = 0, rear = -1;
    int time = 0, completed = 0;
    int gantt[100], ganttCount = 0;

    // Enqueue initially available processes
    for (int i = 0; i < n; i++) {
        if (p[i].arrival == time) {
            enqueue(queue, &rear, i);
            p[i].started = 1;
        }
    }

    while (completed < n) {
        if (front > rear) {
            time++;
            // Check for new arrivals
            for (int i = 0; i < n; i++) {
                if (p[i].arrival <= time && !p[i].started) {
                    enqueue(queue, &rear, i);
                    p[i].started = 1;
                }
            }
            continue;
        }

        int i = dequeue(queue, &front, &rear);

        int runTime = (p[i].remaining < timeQuantum) ? p[i].remaining : timeQuantum;
        printf("\n🟢 Time %d-%d: P%d running", time, time + runTime, p[i].pid);
        gantt[ganttCount++] = p[i].pid;

        time += runTime;
        p[i].remaining -= runTime;

        // Check for new arrivals during this time slice
        for (int j = 0; j < n; j++) {
            if (p[j].arrival > (time - runTime) && p[j].arrival <= time && !p[j].started) {
                enqueue(queue, &rear, j);
                p[j].started = 1;
            }
        }

        if (p[i].remaining == 0) {
            p[i].completion = time;
            p[i].turnaround = p[i].completion - p[i].arrival;
            p[i].waiting = p[i].turnaround - p[i].burst;
            completed++;
            printf(" (Completed ✅)");
        } else {
            enqueue(queue, &rear, i);  // not done, requeue
            printf(" (Requeued 🔁)");
        }

        // Print Ready Queue state
        printf("\n📥 Ready Queue: [");
        for (int k = front; k <= rear; k++) {
            printf("P%d", p[queue[k]].pid);
            if (k != rear) printf(" ");
        }
        printf("]");
    }

    // Final process table
    float totalTAT = 0, totalWT = 0;
    printf("\n\n📊 Final Table:\n");
    printf("PID  Arrival  Burst  Completion  Turnaround  Waiting\n");
    for (int i = 0; i < n; i++) {
        printf("P%-4d%-9d%-7d%-12d%-11d%-7d\n", p[i].pid, p[i].arrival, p[i].burst,
               p[i].completion, p[i].turnaround, p[i].waiting);
        totalTAT += p[i].turnaround;
        totalWT += p[i].waiting;
    }

    printf("\n🔁 Gantt Chart (Timeline):\n| ");
    for (int i = 0; i < ganttCount; i++) {
        printf("P%d | ", gantt[i]);
    }
    printf("\n");

    printf("\n📈 Average Turnaround Time: %.2f", totalTAT / n);
    printf("\n📉 Average Waiting Time   : %.2f\n", totalWT / n);

    return 0;
}