Today we will learn the Round Robin Scheduling Program in C++ and we will also learn Round Robin Algorithm. So before Start learning, we will make you know about Round Robin Program in C++.

What is Round Robin?

The Round-robin (RR) scheduling algorithm is designed especially for timesharing systems.

It is similar to FCFS scheduling except that is a purely preemptive algorithm.

A small unit of time, called a time quantum or time slice, is defined. A time quantum is generally from 10 to 100 milliseconds

The ready queue is treated as a circular queue. The ready queue is treated like a FIFO queue of processes. New processes are added to the tail of the ready queue. The CPU picks the first process from the ready queue, sets a timer to interrupt after 1-time quantum, and dispatches the process.

Round Robin Algorithm:

The CPU scheduler travels the ready queue, allocates the CPU to each process for a time interval of up to 1-time quantum, the process is preempted and the next process in the queue is allocated the CPU.

If the process has a CPU burst of less than 1-time quantum then the process releases the CPU and the scheduler selects the next process in the ready queue.

If the CPU burst of the currently running process is longer than 1-time quantum, the timer will go off and will cause an interrupt to the operating system. A context switch will be executed, and the process will be put at the tail of the ready queue. The CPU scheduler will then select the next process in the ready queue.

Advantages:

Algorithm logic is simple.

System supports multiprogramming effectively.

Gives a better response than SJF.

Disadvantages:

The average waiting time under RR is often long.

If the duration of time quantum is very large, the system acts as FIFO.

Average turnaround time is higher than SJF.

If the duration of time quantum is very small, then Every time a dispatcher is called. More context switching and a large amount of time is wasted in transferring PCB contents to internal registers to PCB.

For Example:

consider the following set of processes and their burst time. Let the time is 20 units.

ProcessBurst Time
P153
P217
P368
P424

Working of Round Robin:

The Process P1 will be allocated for 20-time units and then pre-empted, process P2 is allocated time units.

The Process continues till all processes terminates.

The Gantt chart Shows the details:

round robin program in c

To calculate waiting time of the processes

Waiting time for a process = (Start time – arrival time) + (New start time – Old finish time)

1. Waiting time for P1 = (0-0)+(77-20)+(121-97) = 81.

2. Waiting time for P2 = (20-0) = 20.

3. Waiting time for P3 = (37-0)+(97-57)+(134-117) = 94.

4. Waiting time for P4 = (57-0)+(1177-77) = 57+40 = 97.

5. Average Waiting time = (292)/4 = 73.

Waiting Time: Waiting time is the sum of periods spent waiting in ready queue as the CPU scheduling algorithm does not affect the amount of time that a process spends waiting in the ready queue.

Turn-Around Time: One major factor from the process’s point of view is how long it takes to execute that process. Turnaround time is the interval from the time of submission of a process to the time of completion. i.e

Turn around time=(time spent in waiting to get into memory)+(time spent waiting in ready queue)+(time spent executing in CPU)+(time spent in doing I/O).

1. Round Robin Scheduling Program in C++

//Learnprogramo - programming made Simple
// C++ program for implementation of RR scheduling 
#include<iostream> 
using namespace std; 

// Function to find the waiting time for all 
// processes 
void findWaitingTime(int processes[], int n, 
			int bt[], int wt[], int quantum) 
{ 
	// Make a copy of burst times bt[] to store remaining 
	// burst times. 
	int rem_bt[n]; 
	for (int i = 0 ; i < n ; i++) 
		rem_bt[i] = bt[i]; 

	int t = 0; // Current time 

	// Keep traversing processes in round robin manner 
	// until all of them are not done. 
	while (1) 
	{ 
		bool done = true; 

		// Traverse all processes one by one repeatedly 
		for (int i = 0 ; i < n; i++) 
		{ 
			// If burst time of a process is greater than 0 
			// then only need to process further 
			if (rem_bt[i] > 0) 
			{ 
				done = false; // There is a pending process 

				if (rem_bt[i] > quantum) 
				{ 
					// Increase the value of t i.e. shows 
					// how much time a process has been processed 
					t += quantum; 

					// Decrease the burst_time of current process 
					// by quantum 
					rem_bt[i] -= quantum; 
				} 

				// If burst time is smaller than or equal to 
				// quantum. Last cycle for this process 
				else
				{ 
					// Increase the value of t i.e. shows 
					// how much time a process has been processed 
					t = t + rem_bt[i]; 

					// Waiting time is current time minus time 
					// used by this process 
					wt[i] = t - bt[i]; 

					// As the process gets fully executed 
					// make its remaining burst time = 0 
					rem_bt[i] = 0; 
				} 
			} 
		} 

		// If all processes are done 
		if (done == true) 
		break; 
	} 
} 

// Function to calculate turn around time 
void findTurnAroundTime(int processes[], int n, 
						int bt[], int wt[], int tat[]) 
{ 
	// calculating turnaround time by adding 
	// bt[i] + wt[i] 
	for (int i = 0; i < n ; i++) 
		tat[i] = bt[i] + wt[i]; 
} 

// Function to calculate average time 
void findavgTime(int processes[], int n, int bt[], 
									int quantum) 
{ 
	int wt[n], tat[n], total_wt = 0, total_tat = 0; 

	// Function to find waiting time of all processes 
	findWaitingTime(processes, n, bt, wt, quantum); 

	// Function to find turn around time for all processes 
	findTurnAroundTime(processes, n, bt, wt, tat); 

	// Display processes along with all details 
	cout << "Processes "<< " Burst time "
		<< " Waiting time " << " Turn around time\n"; 

	// Calculate total waiting time and total turn 
	// around time 
	for (int i=0; i<n; i++) 
	{ 
		total_wt = total_wt + wt[i]; 
		total_tat = total_tat + tat[i]; 
		cout << " " << i+1 << "\t\t" << bt[i] <<"\t "
			<< wt[i] <<"\t\t " << tat[i] <<endl; 
	} 
	cout << "Average waiting time = "
		<< (float)total_wt / (float)n; 
	cout << "\nAverage turn around time = "
		<< (float)total_tat / (float)n; 
} 
int main() 
{ 
	// process id's 
	int processes[] = { 1, 2, 3}; 
	int n = sizeof processes / sizeof processes[0]; 
	// Burst time of all processes 
	int burst_time[] = {10, 5, 8}; 

	// Time quantum 
	int quantum = 2; 
	findavgTime(processes, n, burst_time, quantum); 
	return 0; 
} 

Output:

round robin scheduling program in c++

Also Read: