Project Name : Round Robin Algorithm Academic Year : 2020-2021
Subject Name: Operating System Semester : Fifth
A STYDY ON
" Round Robin Algorithm "
MICRO PROJECT REPORT
Submitted in February 2021 by the group of……7….students
Sr. Enrollment
Name of Student
No No
1 Devendra Thawari 1901380449
2 Omkar Uttarvar 1901380473
3 Minal Zade 1901380482
4 Deepika Uike 1901380478
5 Achal Waghmare 1901380480
6 Achal Wadhai 1901380490
7 Maheshwari zade 1901380481
Under the Guidance of
[ PROF. S.S.SARKATE ]
Three Years Diploma Program in Engineering & Technology of Maharashtra State Board of
Technical Education, Mumbai (Autonomous)
ISO 9001:2008 (ISO/IEC-27001:2013)
at
[ SHRI SAI POLYTECHNIC, CHANDRAPUR ]
1
MAHARASHTRA STATE BOARD OF TECHNICAL EDUCATION, MUMBAI
Certificate
This is to certify that Mr. /Mrs :
1) Devendra Thawari. 2) Omkar Uttarvar.
3) Minal Zade. 4) Deepika Uike.
5) Achal Waghmare. 6) Achal Wadhai
7) Maheshwari Zade
Fifth Semester of Computer Engineering Diploma in Engineering & Technology at [ SHRI SAI
POLYTECHNIC, CHANDRAPUR ] , has completed the Micro Project satisfactorily in Subject
OPERATING SYSTEM in the academic year2020-2021 as per the MSBTE prescribed curriculum of I
Scheme.
Place: Chandrapur
Project Guide Head of the Department Principal
Head of
Institute 2
INDEX
Sr. Title Page No
Abstract 4
1. Introduction 5-8
2. Code 9-11
3. Output 12
4. Use Case Diagram 13
5. Data flow diagram 14
6. Class Diagram 15
7. Algorithm 16-17
8. Conclusion & Reference 18
3
Abstract
Round Robin (RR) scheduling algorithm is the widely used scheduling algorithm in
multitasking. It ensures fairness and starvation free execution of processes. Choosing the time
quantum in RR algorithm is very crucial as small time slice results in large number of context
switches and large time quantum increases the response time. To overcome these problems of
RR scheduling, instead of static time slice dynamic time slice can be used to get optimal
performance. The objective of this paper is to modify RR algorithm by adjusting time slices of
different rounds depending on the remaining CPU bursts of currently running processes and
considering their waiting times until that round in respect of the other processes waiting times.
Experimental analysis reveals that the proposed algorithm produces better average turnaround
time, average waiting time and fewer number of context switches than existing algorithms.
4
Introduction
Round Robin is a CPU scheduling algorithm where each process is assigned a fixed time slot in a
cyclic way. It is simple, easy to implement, and starvation-free as all processes get fair share of
CPU. One of the most commonly used technique in CPU scheduling as a core. It is preemptive
as processes are assigned CPU only for a fixed slice of time at most. The disadvantage of it is
more overhead of context switching.
FIFO simply queues processes in the order that they arrive in the ready queue. This is commonly
used for a task queue, for example as illustrated in this section.
5
First Come, First Served (FCFS)
First Come First Serve is the simplest and easiest scheduling algorithm. In this algorithm, the
CPU is allocated to the processes in the order they request it. The implementation of FCFS is
easily done with a queue (a FIFO structure). When the first process enters the system it starts its
execution immediately and runs till it completes its execution. As other processes enter the
system, they are put at the end of the queue and wait to get the CPU. When a process finishes
executing, it releases the CPU, is removed from the queue and the CPU is allocated to next
process at the head of the queue.
First come, first served (FCFS) is an operating system process scheduling algorithm and a
network routing management mechanism that automatically executes queued requests
and processes by the order of their arrival.
With first come, first served, what comes first is handled first; the next request in line will
be executed once the one before it is complete.
FCFS is also known as first-in, first-out (FIFO) and first come, first choice (FCFC).
Example:
process Burst time
P1 25
P2 4
6
P3 3
The processes arrive in the order P1, P2, P3 and are served as per the FCFS algorithm. The
Gantt chart is as shown:
P1 P2 P3
0 25 29 32
The waiting time for P1 is 0 milliseconds, for P2 it is 25 milliseconds and 29
milliseconds for P3. Thus, average waiting time is (0+25+29)/3 = 18 milliseconds.\
Advantage:
o It is easy to understand and implement.
o Simple
o Easy
o First come, First serve
Disadvantage:
It is a Non-Pre-emptive scheduling algorithm: Once a process has been allocated the
CPU, it will not release the CPU until it finishes executing. Thus, it is not suitable for
modern systems which work on the principle of time sharing.
The Average Waiting Time is high.
It results in convay effect i.e., many processes which require CPU for short duration have
to wait for a bigger process to finish thus resulting in low resource utilization.
7
Implementation:
1) Input the processes along with their burst time (bt).
2) Find waiting time (wt) for all processes.
3-) As first process that comes need not to wait so
waiting time for process 1 will be 0 i.e. wt[0] = 0.
4- Find waiting time for all other processes i.e. for
process i ->
wt[i] = bt[i-1] + wt[i-1] .
5- Find turnaround time = waiting_time + burst_time
for all processes.
6- Find average waiting time =
total_waiting_time / no_of_processes.
7- Similarly, find average turnaround time =
total_turn_around_time / no_of_processes.
8
Code
// C++ program for implementation of FCFS
// 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[])
{
// waiting time for first process is 0
wt[0] = 0;
// calculating waiting time
for (int i = 1; i < n ; i++ )
wt[i] = bt[i-1] + wt[i-1] ;
}
// Function to calculate turn around time
void findTurnAroundTime( int processes[], int n,
int bt[], int wt[], int tat[])
{
9
// 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 wt[n], tat[n], total_wt = 0, total_tat = 0;
//Function to find waiting time of all processes
findWaitingTime(processes, n, bt, wt);
//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 = "
10
<< (float)total_wt / (float)n;
cout << "\nAverage turn around time = "
<< (float)total_tat / (float)n;
}
// Driver code
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};
findavgTime(processes, n, burst_time);
return 0; }
}
11
OUTPUT
Manual Output:
Processes Burst Waiting Turn around
time time
time
1 10 0 10
2 5 10 15
3 8 15 23
Average waiting time = 8.33333
Average turn around time = 16
System Output:
12
Use case Diagram of FCFS
Fig. UseCase Diagram for FCFS algorithm
13
Data Flow Diagram for FCFS
14
Class Diagram for FCFS
15
Round Robin scheduling algorithm
Round Robin is a CPU scheduling algorithm where each process is assigned a fixed time slot in a
cyclic way.
It is simple, easy to implement, and starvation-free as all processes get fair share of CPU.
One of the most commonly used technique in CPU scheduling as a core.
It is preemptive as processes are assigned CPU only for a fixed slice of time at most.
The disadvantage of it is more overhead of context switching
To schedule processes fairly, a round-robin scheduler generally employs time-sharing, giving
each job a time slot or (its allowance of CPU time), and interrupting the job if it is not
completed by then. The job is resumed next time a time slot is assigned to that process. If the
process terminates or changes its state to waiting during its attributed time quantum, the
scheduler selects the first process in the ready queue to execute. In the absence of time-sharing,
or if the quanta were large relative to the sizes of the jobs, a process that produced large jobs
would be favoured over other processes.
Round-robin algorithm is a pre-emptive algorithm as the scheduler forces the process out
of the CPU once the time quota expires.
For example, if the time slot is 100 milliseconds, and job1 takes a total time of 250 ms to
complete, the round-robin scheduler will suspend the job after 100 ms and give other jobs
their time on the CPU. Once the other jobs have had their equal share (100 ms
each), job1 will get another allocation of CPU time and the cycle will repeat. This
process continues until the job finishes and needs no more time on the CPU.
16
1)Completion Time: Time at which process completes its execution.
2)Turn Around Time: Time Difference between completion time and arrival time.
3)Turn Around Time = Completion Time – Arrival Time
4)Waiting Time(W.T): Time Difference between turn around time and burst time.
5)Waiting Time = Turn Around Time – Burst Time
Steps to find waiting times of all processes:
1)Create an array rem_bt[] to keep track of remaining
burst time of processes. This array is initially a
copy of bt[] (burst times array)
2) Create another array wt[] to store waiting times
of processes. Initialize this array as 0.
3) Initialize time : t = 0
4)Keep traversing the all processes while all processes
are not done. Do following for it’s process if it is
not done yet.
a- If rem_bt[i] > quantum
(i) t = t + quantum
(ii) bt_rem[i] -= quantum;
c- Else // Last cycle for this process
(i) t = t + bt_rem[i];
(ii) wt[i] = t - bt[i]
(ii) bt_rem[i] = 0; // This process is over
17
Conclusion
Thus we have performed various scheduling algorithms such as FCFS(First Come First Serve)
and Round Robin Algorithm. We have developed a C plus program to execute these algorithms.
We have calculated waiting time, turnaround time, burst time. We have created Use case and
Data Flow Diagram for both algorithms.
References
www.aapliuniversity.com
www.codewithc.com
Techknowledge publication book: Operating System
18
