This article contains the implementation of the Round Robin Scheduling in C Programming with the explanation, an example, it’s advantages and disadvantages.
If we consider large management or organization with multi-users and with a time-sharing system, in such cases response time plays a vital role in the achievements of various objectives. So, Process Scheduling is a key component for such management.
There are many algorithms for process management such as:
Let us understand the Round Robin Scheduling program in C
What is Round Robin Scheduling?
The Round robin algorithm is a pre-emptive process scheduling algorithm used by the machine for scheduling the CPU utilization. Here, each process is allotted to a fixed time called time slice or time quantum in a cyclic way. A process enables the job scheduler that saves the current progress of the job moves to the next job present in the queue. Each process must complete the job within the given time-quantum else an interrupt may occur. The context-switching saves the current state of the process.
What is Round Robin Scheduling Algorithm?
- Here, every job is arranged in a FIFO(First Come First Server) order.
- When the first process arrives, it is sent for the execution. But if it couldn’t complete the execution in a given amount of time quantum that is allotted to it, then an automated timer generates an interrupt.
- After that, the process is stopped and then send back to the end of the queue. Although the state is saved and stored so that it can be resumed where it was interrupted.
- The process is resumed and the schedulers select the next process from the queue sent it to the processor for execution.
- Each process is executed in a similar way and checked for the time quantum.
- The steps are repeated for every process until the processes are over.
- It is simple, easy to use and the overhead in decision-making is low.
- Due to the fair share of CPU starvation does not occur.
- Due to the queue system, equal priority is given to all the job which cannot be seen in other algorithms
- Due to its dependency on quantum value, the efficiency of the system is decreased.
- An increase in the quantum value might make the system unresponsive.
Example: Round Robin Scheduling in C Programming
int i, total = 0, x, limit, counter = 0, t_quantum;
int wait_time = 0, turnaround_time = 0, arrival_time, burst_time, temp;
float average_wait_time, average_turnaround_time;
printf("\nEnter Total Number of Processes: ");
x = limit;
for(i = 0; i < limit; i++)
printf("\nProvide the details for Process[%d]\n", i + 1);
temp[i] = burst_time[i];
printf("\nEnter Time Quantum:\t");
printf("\nProcess ID\t\tBurst Time\t Turnaround Time\t Waiting Time\n");
for(total = 0, i = 0; x != 0;)
if(temp[i] <= t_quantum && temp[i] > 0)
total = total + temp[i];
temp[i] = 0;
counter = 1;
else if(temp[i] > 0)
temp[i] = temp[i] - t_quantum;
total = total + t_quantum;
if(temp[i] == 0 && counter == 1)
printf("\nProcess[%d]\t\t%d\t\t %d\t\t\t %d", i + 1, burst_time[i], total - arrival_time[i], total - arrival_time[i] - burst_time[i]);
wait_time = wait_time + total - arrival_time[i] - burst_time[i];
turnaround_time = turnaround_time + total - arrival_time[i];
counter = 0;
if(i == limit - 1)
i = 0;
else if(arrival_time[i + 1] <= total)
i = 0;
average_wait_time = wait_time * 1.0 / limit;
average_turnaround_time = turnaround_time * 1.0 / limit;
printf("\n\nAverage Waiting Time:\t%f", average_wait_time);
printf("\nAvg Turnaround Time:\t%f\n", average_turnaround_time);
Output of above Round Robin Algorithm: