Round Robin Scheduling in C

Round Robin Scheduling in C

Round robin is a CPU (Central Processing Unit) scheduling algorithm designed to share the time systems. It is one of the simplest and easiest scheduling algorithms used in various operating systems to process networks and scheduling. It is more similar to FCFS (First Come First Serve) scheduling algorithm, but the only difference is that round-robin scheduling processes are bounded with a quantum time size. A small unit of time is called time quantum or time slice. Time slice or time quantum can range from 10 to 100 milliseconds. The chief idea is to allocate the CPU to all the processes running in the same order for the same amount of time.

It is a pre-emptive scheduling algorithm famous for CPU scheduling and used in numerous operating systems. Pre-emptive scheduling is a technique that divides the time slots of the CPU to a particular process. Preemptive scheduling is a better approach than other algorithms like shortest job first, considering that there will be a guarantee that all the processes will be completed at the cost of overall performance.

1. Completion time (CT): it is the time required by the process to complete the execution.
2. Turnaround time (TAT): it is the difference between the completion time (CT) and the arrival time (AT).

            Turnaround time (TAT) = completion time (CT) - Arrival Time (AT)

• Waiting time (WT): total time between requesting action and acquiring the resource.

            Waiting time (WT) = Turnaround time (TAT) - Burst Time (BT)

• Response time: it is the time at which the system response to a process

Algorithm:

• Processes are arranged in a first come, first serve order as we do in a queue.
• Each process that is in a queue is allocated a quantum value.
• The first process is executed until the end of the provided quantum value. After the quantum value is ended, an interrupt is generated, and the state is saved.
• The CPU moves to the following process present in the queue, and the same method repeatedly follows until all the processes are completed, first-come, and no more processes are left.

E.g.:

 #include <stdio.h>
 #include <conio.h>
 #include <math.h>
 int main()
 {
 int i, limit, total = 0, x, counter = 0, time_quantum;
 int wt = 0, tat = 0, a1[10], bt[10], temp[10];
 float average_wt, average_tat;
 printf("Enter the total number of processes: \n");
 scanf("%d", &limit);
 x = limit;
 for(i = 0; i < limit; i++)
 {
 printf("Enter details of the processes %d: \n", i + 1);
 printf("Arrival Time: \t");
 scanf("%d", &at[i]);
 printf("Burst Time:t");
 scanf("%d", &bt[i]);
 temp[i] = bt[i];
 }
 printf("Enter time quantum or time slice: \t");
 scanf("%d", &time_quantum);
 printf("\n Process ID\t\t  burst time\t turn around time\t waiting time\n”);
 for(total = 0, i = 0; x != 0;)
 {
 if(temp[i] <= time_quantum && temp[i] > 0)
 {
 total = total + temp[i];
 temp[i] = 0;
 counter = 1;
 }
 else if(temp[i] > 0)
 {
 temp[i] = temp[i] - time_quantum;
 total = total + time_quantum;
 }
 if(temp[i] == 0 && counter == 1)
 {
 x--;
 printf("\n Process: %d\t\t %d\t %d\t %d\n", i + 1, bt[i], total - at[i], total - at[i] - bt[i]);
 wt = wt + total - at[i] - bt[i];
 tat = tat + total - at[i];
 counter = 0;
 }
 if(i == limit - 1)
 {
 i = 0;
 }
 else if(at[i + 1] <= total)
 {
 i++;
 }
 else
 {
 i = 0;
 }
 }
 average_wt = wt * 1.0 / limit;
 average_tat = tat * 1.0 / limit;
 printf("\n\n Average Waiting Time:\t %f", average_wt);
 printf("\n Average Turnaround Time:\t %f \n", average_tat);
 return 0;
 } 

Output:

 Enter the total number of processes: 4
 Enter the details of process 1:
 Arrival time: 0
 Burst time: 4
 Enter the details of process 2:
 Arrival time: 1
 Burst time: 7
 Enter the details of process 3:
 Arrival time: 2
 Burst time: 5
 Enter the details of process 4:
 Arrival time: 3
 Burst time: 6
 Enter the time quantum: 3
 Process ID             burst time          turn around time           waiting time
 Process 1                      4                           13                                  9
 Process 2                      5                           16                                 11
 Process 3                      6                           18                                 12
 Process 4                      7                           21                                 14
 Average waiting time: 11.500000000
 Average turnaround time: 17.00000000 

Advantages of using Round Robin Scheduling:

• Each and every process attain the same priority as it has fixed quantum.
• No starvation or stagnation will be allowed, and hence no process will be left unattended.
• Average response time will be improved; that is, better execution will take place.
• CPU will be best utilized in this case, and extra resources will not be required.
• Threads having the same priority are scheduled perfectly in this method as CPU will be equally shared between all the processes.

Disadvantages of Round Robin Scheduling:

• Every process has to wait until its turn arrives. This leads to a higher average waiting time.
• It is overhead of context switching.
• Decreased rate of completion as processes will not wholly be executed leads to low throughput.
• Length of quantum time has a significant effect on waiting time.
• Lack of priority might be a problem as processes require immediate attention.