sim.c

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

#define MAX_PROCESSES 100

typedef struct {
    int pid;
    int arrival_time;
    int burst_time;
    int priority;
    int remaining_time;
    int waiting_time;
    int turnaround_time;
    int completion_time;
    int current_queue;
} Process;


void reset_processes(Process p[], int n) {
    for (int i = 0; i < n; i++) {
        p[i].remaining_time = p[i].burst_time;
        p[i].waiting_time = 0;
        p[i].turnaround_time = 0;
        p[i].completion_time = 0;
        p[i].current_queue = 0;
    }
}

void print_table(Process p[], int n) {
    printf("\n----------------------------------------------------------------------------------\n");
    printf("| PID | Priority | Arrival | Burst | Completion | Turnaround | Waiting |\n");
    printf("----------------------------------------------------------------------------------\n");
    
    float total_wt = 0, total_tat = 0;
    int total_burst = 0;
    int max_completion = 0;

    for (int i = 0; i < n; i++) {
        printf("| %3d | %8d | %7d | %5d | %10d | %10d | %7d |\n",
               p[i].pid, p[i].priority, p[i].arrival_time, p[i].burst_time,
               p[i].completion_time, p[i].turnaround_time, p[i].waiting_time);
        
        total_wt += p[i].waiting_time;
        total_tat += p[i].turnaround_time;
        total_burst += p[i].burst_time;
        if (p[i].completion_time > max_completion) {
            max_completion = p[i].completion_time;
        }
    }

    float cpu_util = 0;
    if (max_completion > 0) {
        cpu_util = ((float)total_burst / max_completion) * 100.0;
    }

    printf("----------------------------------------------------------------------------------\n");
    printf("Average Waiting Time:    %.2f\n", total_wt / n);
    printf("Average Turnaround Time: %.2f\n", total_tat / n);
    printf("CPU Utilization:         %.2f%%\n", cpu_util);
    printf("----------------------------------------------------------------------------------\n");
}

void sort_by_arrival(Process p[], int n) {
    Process temp;
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (p[j].arrival_time > p[j + 1].arrival_time) {
                temp = p[j];
                p[j] = p[j + 1];
                p[j + 1] = temp;
            }
        }
    }
}


void simulate_fcfs(Process p[], int n) {
    printf("\n--- Simulating FCFS ---\n");
    reset_processes(p, n);
    sort_by_arrival(p, n);
    
    int current_time = 0;
    
    printf("Gantt Chart: ");
    for (int i = 0; i < n; i++) {
        if (current_time < p[i].arrival_time) {
            printf("| IDLE (%d-%d) ", current_time, p[i].arrival_time);
            current_time = p[i].arrival_time;
        }
        
        int start_time = current_time;
        p[i].completion_time = current_time + p[i].burst_time;
        p[i].turnaround_time = p[i].completion_time - p[i].arrival_time;
        p[i].waiting_time = p[i].turnaround_time - p[i].burst_time;
        current_time = p[i].completion_time;

        printf("| P%d (%d-%d) ", p[i].pid, start_time, current_time);
    }
    printf("|\n");
    print_table(p, n);
}

void simulate_round_robin(Process p[], int n, int quantum) {
    printf("\n--- Simulating Round Robin (Quantum: %d) ---\n", quantum);
    reset_processes(p, n);
    sort_by_arrival(p, n);

    int current_time = 0;
    int completed = 0;
    
    printf("Gantt Chart: ");

    while (completed < n) {
        bool idle = true;
        for (int i = 0; i < n; i++) {
            if (p[i].remaining_time > 0 && p[i].arrival_time <= current_time) {
                idle = false;
                int start_exec = current_time;

                if (p[i].remaining_time > quantum) {
                    current_time += quantum;
                    p[i].remaining_time -= quantum;
                } else {
                    current_time += p[i].remaining_time;
                    p[i].waiting_time = current_time - p[i].burst_time - p[i].arrival_time;
                    p[i].remaining_time = 0;
                    p[i].completion_time = current_time;
                    p[i].turnaround_time = p[i].completion_time - p[i].arrival_time;
                    completed++;
                }
                printf("| P%d (%d-%d) ", p[i].pid, start_exec, current_time);
            }
        }

        if (idle && completed < n) {
            int next_arrival_time = 999999;
            bool found_next = false;

            //daca suntem idle cautam care este urmatorul proces care va sosi
            for (int k = 0; k < n; k++) {
                if (p[k].remaining_time > 0 && p[k].arrival_time > current_time) {
                    if (p[k].arrival_time < next_arrival_time) {
                        next_arrival_time = p[k].arrival_time;
                        found_next = true;
                    }
                }
            }

            if (found_next) {
                printf("| IDLE (%d-%d) ", current_time, next_arrival_time);
                current_time = next_arrival_time;
            } else {
                // n-ar trebui sa ajunga aici
                current_time++;
            }
        }
    }
    printf("|\n");
    print_table(p, n);
}

void simulate_priority(Process p[], int n) {
    printf("\n--- Simulating Priority (Non-Preemptive) ---\n");
    reset_processes(p, n);
    
    int current_time = 0;
    int completed = 0;
    
    printf("Gantt Chart: ");

    while (completed < n) {
        int idx = -1;
        int highest_priority = 9999;

        for (int i = 0; i < n; i++) {
            if (p[i].arrival_time <= current_time && p[i].remaining_time > 0) {
                if (p[i].priority < highest_priority) {
                    highest_priority = p[i].priority;
                    idx = i;
                }
            }
        }

        if (idx != -1) {
            int start_exec = current_time;
            current_time += p[idx].burst_time;
            p[idx].remaining_time = 0;
            p[idx].completion_time = current_time;
            p[idx].turnaround_time = p[idx].completion_time - p[idx].arrival_time;
            p[idx].waiting_time = p[idx].turnaround_time - p[idx].burst_time;
            completed++;
            printf("| P%d (%d-%d) ", p[idx].pid, start_exec, current_time);
        } else {
            int next_arrival_time = 999999;
            bool found_next = false;

            //daca suntem idle cautam care este urmatorul proces care va sosi
            for (int k = 0; k < n; k++) {
                if (p[k].remaining_time > 0 && p[k].arrival_time > current_time) {
                    if (p[k].arrival_time < next_arrival_time) {
                        next_arrival_time = p[k].arrival_time;
                        found_next = true;
                    }
                }
            }

            if (found_next) {
                printf("| IDLE (%d-%d) ", current_time, next_arrival_time);
                current_time = next_arrival_time;
            } else {
                // n-ar trebui sa ajunga aici
                current_time++;
            }
        }
    }
    printf("|\n");
    print_table(p, n);
}

void simulate_sjf(Process p[], int n) {
    printf("\n--- Simulating SJF (Non-Preemptive) ---\n");
    reset_processes(p, n);

    int current_time = 0;
    int completed = 0;
    
    printf("Gantt Chart: ");

    while (completed < n) {
        int idx = -1;
        int min_burst = 99999;

        for (int i = 0; i < n; i++) {
            if (p[i].arrival_time <= current_time && p[i].remaining_time > 0) {
                if (p[i].burst_time < min_burst) {
                    min_burst = p[i].burst_time;
                    idx = i;
                }
            }
        }

        if (idx != -1) {
            int start_exec = current_time;
            current_time += p[idx].burst_time;
            p[idx].remaining_time = 0;
            p[idx].completion_time = current_time;
            p[idx].turnaround_time = p[idx].completion_time - p[idx].arrival_time;
            p[idx].waiting_time = p[idx].turnaround_time - p[idx].burst_time;
            completed++;
            printf("| P%d (%d-%d) ", p[idx].pid, start_exec, current_time);
        } else {
            int next_arrival_time = 999999;
            bool found_next = false;

            //daca suntem idle cautam care este urmatorul proces care va sosi
            for (int k = 0; k < n; k++) {
                if (p[k].remaining_time > 0 && p[k].arrival_time > current_time) {
                    if (p[k].arrival_time < next_arrival_time) {
                        next_arrival_time = p[k].arrival_time;
                        found_next = true;
                    }
                }
            }

            if (found_next) {
                printf("| IDLE (%d-%d) ", current_time, next_arrival_time);
                current_time = next_arrival_time;
            } else {
                // n-ar trebui sa ajunga aici
                current_time++;
            }
        }
    }
    printf("|\n");
    print_table(p, n);
}

void simulate_srtf(Process p[], int n) {
    printf("\n--- Simulating SRTF (Preemptive SJF) ---\n");
    reset_processes(p, n);

    int current_time = 0;
    int completed = 0;
    int shortest = -1;
    int min_rem_time = 99999;
    bool check = false;
    
    int last_pid = -1;
    int start_block = 0;

    printf("Gantt Chart: ");

    while (completed < n) {
        shortest = -1;
        min_rem_time = 99999;
        check = false;

        for (int i = 0; i < n; i++) {
            if ((p[i].arrival_time <= current_time) && (p[i].remaining_time > 0)) {
                if (p[i].remaining_time < min_rem_time) {
                    min_rem_time = p[i].remaining_time;
                    shortest = i;
                    check = true;
                }
            }
        }

        if (!check) { // IDLE
            if (last_pid != -1) {
                printf("| P%d (%d-%d) ", last_pid, start_block, current_time);
                last_pid = -1;
            }
            int next_arrival = 999999;
            bool found_next = false;
            for(int k=0; k<n; k++) {
                if(p[k].remaining_time > 0 && p[k].arrival_time > current_time) {
                    if(p[k].arrival_time < next_arrival) {
                        next_arrival = p[k].arrival_time;
                        found_next = true;
                    }
                }
            }

            if (found_next) {
                printf("| IDLE (%d-%d) ", current_time, next_arrival);
                current_time = next_arrival;
                start_block = current_time; 
            } else {
                current_time++;
                start_block = current_time;
            }
            continue;
        }

        if (last_pid != -1 && p[shortest].pid != last_pid) {
             printf("| P%d (%d-%d) ", last_pid, start_block, current_time);
             start_block = current_time;
        } else if (last_pid == -1) {
             start_block = current_time;
        }
        
        last_pid = p[shortest].pid;

        p[shortest].remaining_time--;
        current_time++;

        if (p[shortest].remaining_time == 0) {
            completed++;
            p[shortest].completion_time = current_time;
            p[shortest].turnaround_time = p[shortest].completion_time - p[shortest].arrival_time;
            p[shortest].waiting_time = p[shortest].turnaround_time - p[shortest].burst_time;
            if (p[shortest].waiting_time < 0) p[shortest].waiting_time = 0;
            
            printf("| P%d (%d-%d) ", last_pid, start_block, current_time);
            last_pid = -1; // reset
            start_block = current_time;
        }
    }
    printf("|\n");
    print_table(p, n);
}

void simulate_mlq(Process p[], int n, int quantum_high) {
    printf("\n--- Simulating Multilevel Queue (System=RR, User=FCFS) ---\n");
    reset_processes(p, n);
    sort_by_arrival(p, n);

    int current_time = 0;
    int completed = 0;
    
    printf("Gantt Chart: ");

    while (completed < n) {
        int idx = -1;
        int selected_queue = -1;
        bool found = false;

        for (int i = 0; i < n; i++) {
            if (p[i].arrival_time <= current_time && p[i].remaining_time > 0 && p[i].priority <= 5) {
                idx = i; 
                selected_queue = 1; 
                found = true; 
                break;
            }
        }

        if (!found) {
            for (int i = 0; i < n; i++) {
                if (p[i].arrival_time <= current_time && p[i].remaining_time > 0 && p[i].priority > 5) {
                    idx = i; 
                    selected_queue = 2; 
                    found = true; 
                    break;
                }
            }
        }

        if (found) {
            int start_exec = current_time;
            if (selected_queue == 1) { 
                if (p[idx].remaining_time > quantum_high) {
                    current_time += quantum_high;
                    p[idx].remaining_time -= quantum_high;
                    
                    Process temp = p[idx];
                    int insert_pos = idx;
                    while(insert_pos < n-1 && p[insert_pos+1].arrival_time <= current_time) {
                        p[insert_pos] = p[insert_pos+1];
                        insert_pos++;
                    }
                    p[insert_pos] = temp;
                    idx = insert_pos;

                } else {
                    current_time += p[idx].remaining_time;
                    p[idx].remaining_time = 0;
                    p[idx].completion_time = current_time;
                    p[idx].turnaround_time = p[idx].completion_time - p[idx].arrival_time;
                    p[idx].waiting_time = p[idx].turnaround_time - p[idx].burst_time;
                    completed++;
                }
            } else { 
                current_time += p[idx].remaining_time;
                p[idx].remaining_time = 0;
                p[idx].completion_time = current_time;
                p[idx].turnaround_time = p[idx].completion_time - p[idx].arrival_time;
                p[idx].waiting_time = p[idx].turnaround_time - p[idx].burst_time;
                completed++;
            }
            printf("| Q%d:P%d (%d-%d) ", selected_queue, p[idx].pid, start_exec, current_time);
        } else {
             int next_arrival = 999999;
             bool found_next = false;

             for(int k=0; k<n; k++) {
                 if(p[k].remaining_time > 0 && p[k].arrival_time > current_time) {
                     if(p[k].arrival_time < next_arrival) {
                         next_arrival = p[k].arrival_time;
                         found_next = true;
                     }
                 }
             }

             if(found_next) {
                 printf("| IDLE (%d-%d) ", current_time, next_arrival);
                 current_time = next_arrival;
             } else {
                 current_time++;
             }
        }
    }
    printf("|\n");
    print_table(p, n);
}

void simulate_mlfq(Process p[], int n) {
    printf("\n--- Simulating MLFQ (Q0=RR4, Q1=RR8, Q2=FCFS) ---\n");
    reset_processes(p, n);
    sort_by_arrival(p, n);
    
    for(int i=0; i<n; i++) p[i].current_queue = 0;

    int current_time = 0;
    int completed = 0;
    int q0_quantum = 4;
    int q1_quantum = 8;
    
    printf("Gantt Chart: ");

    while (completed < n) {
        int idx = -1;
        int queue_level = -1;
        bool found = false;

        for (int i = 0; i < n; i++) {
             if (p[i].arrival_time <= current_time && p[i].remaining_time > 0 && p[i].current_queue == 0) {
                 idx = i; 
                 queue_level = 0; 
                 found = true; 
                 break;
             }
        }

        if (!found) {
            for (int i = 0; i < n; i++) {
                if (p[i].arrival_time <= current_time && p[i].remaining_time > 0 && p[i].current_queue == 1) {
                    idx = i; 
                    queue_level = 1; 
                    found = true; 
                    break;
                }
            }
        }

        if (!found) {
            for (int i = 0; i < n; i++) {
                if (p[i].arrival_time <= current_time && p[i].remaining_time > 0 && p[i].current_queue == 2) {
                    idx = i; 
                    queue_level = 2; 
                    found = true; 
                    break;
                }
            }
        }

        if (found) {
            int start_exec = current_time;
            
            if (queue_level == 0) {
                if (p[idx].remaining_time > q0_quantum) {
                    current_time += q0_quantum;
                    p[idx].remaining_time -= q0_quantum;
                    p[idx].current_queue = 1;
                    
                    Process temp = p[idx];
                    int insert_pos = idx;
                    while(insert_pos < n-1 && p[insert_pos+1].arrival_time <= current_time) {
                        p[insert_pos] = p[insert_pos+1];
                        insert_pos++;
                    }
                    p[insert_pos] = temp;
                    idx = insert_pos;
                    
                } else {
                    current_time += p[idx].remaining_time;
                    p[idx].remaining_time = 0;
                    p[idx].completion_time = current_time;
                    p[idx].turnaround_time = p[idx].completion_time - p[idx].arrival_time;
                    p[idx].waiting_time = p[idx].turnaround_time - p[idx].burst_time;
                    completed++;
                }
            } 
            else if (queue_level == 1) {
                if (p[idx].remaining_time > q1_quantum) {
                    current_time += q1_quantum;
                    p[idx].remaining_time -= q1_quantum;
                    p[idx].current_queue = 2;
                    
                    Process temp = p[idx];
                    int insert_pos = idx;
                    while(insert_pos < n-1 && p[insert_pos+1].arrival_time <= current_time) {
                        p[insert_pos] = p[insert_pos+1];
                        insert_pos++;
                    }
                    p[insert_pos] = temp;
                    idx = insert_pos;

                } else {
                    current_time += p[idx].remaining_time;
                    p[idx].remaining_time = 0;
                    p[idx].completion_time = current_time;
                    p[idx].turnaround_time = p[idx].completion_time - p[idx].arrival_time;
                    p[idx].waiting_time = p[idx].turnaround_time - p[idx].burst_time;
                    completed++;
                }
            } 
            else {
                 current_time += p[idx].remaining_time;
                 p[idx].remaining_time = 0;
                 p[idx].completion_time = current_time;
                 p[idx].turnaround_time = p[idx].completion_time - p[idx].arrival_time;
                 p[idx].waiting_time = p[idx].turnaround_time - p[idx].burst_time;
                 completed++;
            }
            printf("| Q%d:P%d (%d-%d) ", queue_level, p[idx].pid, start_exec, current_time);
        } else {
             int next_arrival = 999999;
             bool future_process = false;
             for(int k=0; k<n; k++) {
                 if(p[k].remaining_time > 0 && p[k].arrival_time > current_time) {
                     if(p[k].arrival_time < next_arrival) {
                         next_arrival = p[k].arrival_time;
                         future_process = true;
                     }
                 }
             }
             if(future_process) {
                 printf("| IDLE (%d-%d) ", current_time, next_arrival);
                 current_time = next_arrival;
             } else {
                 current_time++;
             }
        }
    }
    printf("|\n");
    print_table(p, n);
}

int main() {
    Process processes[MAX_PROCESSES];
    int n, quantum, choice;

    printf("Enter number of processes: ");
    if (scanf("%d", &n) != 1) return 1;

    for (int i = 0; i < n; i++) {
        processes[i].pid = i + 1;
        printf("Process %d [Arrival, Burst, Priority]: ", i + 1);
        fflush(stdout); 
        if (scanf("%d %d %d", &processes[i].arrival_time, &processes[i].burst_time, &processes[i].priority) != 3) return 1;
        processes[i].remaining_time = processes[i].burst_time;
    }

    while (1) {
        printf("\nSCHEDULER SIMULATOR\n");
        printf("1. FCFS\n");
        printf("2. Round Robin\n");
        printf("3. Priority (Non-Preemptive)\n");
        printf("4. SJF (Shortest Job First - Non-Preemptive)\n");
        printf("5. SRTF (Shortest Remaining Time First - Preemptive)\n");
        printf("6. Multilevel Queue (System=RR, User=FCFS)\n");
        printf("7. Multilevel Feedback Queue (Q0-Q2)\n");
        printf("8. Exit\n");
        printf("Choice: ");
        if (scanf("%d", &choice) != 1) break;

        switch (choice) {
            case 1:
                simulate_fcfs(processes, n);
                break;
            case 2:
                printf("Enter Time Quantum: ");
                scanf("%d", &quantum);
                simulate_round_robin(processes, n, quantum);
                break;
            case 3:
                simulate_priority(processes, n);
                break;
            case 4:
                simulate_sjf(processes, n);
                break;
            case 5:
                simulate_srtf(processes, n);
                break;
            case 6:
                printf("Enter Time Quantum for System Queue: ");
                scanf("%d", &quantum);
                simulate_mlq(processes, n, quantum);
                break;
            case 7:
                simulate_mlfq(processes, n);
                break;
            case 8:
                exit(0);
            default:
                printf("Invalid choice.\n");
        }
    }
    return 0;
}