#

include

#include

#include

#define Q0_TIME_QUANTUM 8

#define Q1_TIME_QUANTUM 16

struct PCB {

int process_id;

int arrival_time;

int burst_time;

int remaining_time;

int waiting_time;

int response_time;

int completion_time;

};

// Function to compare two processes based on arrival time

int compare_arrival_time(const void* a, const void* b) {

struct PCB *p1 = (struct PCB*)a;

struct PCB *p2 = (struct PCB*)b;

return (p1->arrival_time - p2->arrival_time);

}

int main() {

int num_processes, i;

printf("Enter the number of processes: ");

scanf("%d", &num_processes);

struct PCB processes[num_processes];

printf("Enter the arrival time and burst time for each process: ");

for (i = 0; i < num_processes; i++) {

printf("Process %d: ", i+1);

scanf("%d %d", &processes[i].arrival_time, &processes[i].burst_time);

processes[i].process_id = i+1;

processes[i].remaining_time = processes[i].burst_time;

}

// Sort the processes based on arrival time

qsort(processes, num_processes, sizeof(struct PCB), compare_arrival_time);

int current_time = 0, completed_processes = 0;

int q0_processes = 0, q1_processes = 0, q2_processes = 0;

// Initialize the queues

struct PCB q0[num_processes], q1[num_processes], q2[num_processes];

while (completed_processes < num_processes) {

// Move new processes to Q0

while (processes[q0_processes].arrival_time <= current_time && q0_processes < num_processes) {

q0[q0_processes] = processes[q0_processes];

q0_processes++;

}

// Check if Q0 is empty

if (q0_processes == 0) {

current_time = processes[q0_processes].arrival_time;

continue;

}

// Execute process in Q0

struct PCB current_process = q0[0];

int time_quantum;

if (current_process.remaining_time > Q0_TIME_QUANTUM) {

time_quantum = Q0_TIME_QUANTUM;

} else {

time_quantum = current_process.remaining_time;

}

current_time += time_quantum;

current_process.remaining_time -= time_quantum;

// Check if process is completed

if (current_process.remaining_time == 0) {

current_process.completion_time = current_time;

current_process.waiting_time = current_process.completion_time - current_process.burst_time - current_process.arrival_time;

current_process.response_time = current_process.waiting_time;

completed_processes++;

} else {

// Move process to next queue

if (current_process.remaining_time > Q1_TIME_QUANTUM) {

q1[q1_processes++] = current_process;

} else {

q2[q2_processes++] = current_process;

}

}

// Shift the remaining processes in Q0

for (i = 1; i < q0_processes; i++) {

q0[i-1] = q0[i];

}

q0_processes--;

// Move completed process from Q1 to Q2

for (i = 0; i < q1_processes; i++) {

if (q1[i].remaining_time == 0) {

q2[q2_processes++] = q1[i];

for (int j = i+1; j < q1_processes; j++) {

q1[j-1] = q1[j];

}

q1_processes--;

i--;

}

}

// Execute process in Q1

if (q1_processes > 0) {

current_process = q1[0];

time_quantum;

if (current_process.remaining_time > Q1_TIME_QUANTUM) {

time_quantum = Q1_TIME_QUANTUM;

} else {

time_quantum = current_process.remaining_time;

}

current_time += time_quantum;

current_process.remaining_time -= time_quantum;

// Check if process is completed

if (current_process.remaining_time == 0) {

current_process.completion_time = current_time;

current_process.waiting_time = current_process.completion_time - current_process.burst_time - current_process.arrival_time;

completed_processes++;

} else {

// Move process to next queue

q2[q2_processes++] = current_process;

}

// Shift the remaining processes in Q1

for (i = 1; i < q1_processes; i++) {

q1[i-1] = q1[i];

}

q1_processes--;

}

// Execute process in Q2

if (q2_processes > 0) {

current_process = q2[0];

current_time += current_process.remaining_time;

current_process.remaining_time = 0;

current_process.completion_time = current_time;

current_process.waiting_time = current_process.completion_time - current_process.burst_time;

current_process.arrival_time;

completed_processes++;

// Shift the remaining processes in Q2

for (i = 1; i < q2_processes; i++) {

q2[i-1] = q2[i];

}

q2_processes--;

}

}

// Calculate average waiting time and throughput

int total_waiting_time = 0;

for (i = 0; i < num_processes; i++) {

total_waiting_time += processes[i].waiting_time;

}

float average_waiting_time = (float)total_waiting_time / num_processes;

float throughput = (float)num_processes / current_time;

// Display results

printf("Response Time: %d ", processes[0].response_time);

printf("Throughput: %f ", throughput);

printf("Average Waiting Time: %f ", average_waiting_time);

return 0;

}

I have this code in c lanuage, the average got me 0.000 . I cant find the problem why i cant calculate the average