A

Microproject Report
On
Implement a simple process scheduler using
Round Robin or FCFS algorithm
Under Course : - Operating System(22516)

Semester : - V

Maharashtra State Board of Technical Education, Mumbai

Department of Information Technology Engineering

Matoshri Aasarabai Polytechnic, Eklahare, Nashik

Academic Year: 2024-2025
 Maharashtra State Board of Technical Education, Mumbai
Matoshri Aasarabai Polytechnic, Eklahare, Nashik

CERTIFICATE

This is to certify that following students of Fifth Semester Diploma Engineering

Program in IT Department have successfully completed the Micro-
Project "Implement a simple process scheduler using Round Robin or FCFS
algorithm" under my supervision, in the partial fulfillment of Course Operating
System(22516) for Academic Year 2024- 2025 as per prescribed in the MSBTE “ I-
Scheme” curriculum.

Roll No Enrollment No. Exam Seat Number Name of Students

42 2211700319 Swara Yogesh Sakhare

44 2211700321 Mayuri Vijay Salve
50 2211700328 Snehal Somnath Shinde

Date:- Place:- Nashik.

Subject Teacher Head of Department Principal

(Prof.Ms.Kale) (Prof. M.P.Bhandakkar (Dr.A.S.Relakar)
 Department of Information Technology Engineering

Academic Year-2024-2025
Index of Micro Project Report

Program:- Information technology Semester:-5th

Course:-Operating System Course Code:-22516

Title of Micro Project :- Implement a simple process scheduler using Round Robin or
FCFS algorithm

Sr.
No. Details Page No.

1
1 Abstract

2
2 Project Work

4
3 Project Work (Main Details)

9
4 Code

13
5 Project Work (Conclusion)

14
6 Resources/ References

Signature of Student Signature of Faculty

 MATOSHRI AASARABAI POLYTECHNIC, EKLAHARE, NASHIK

ANNEXURE I

Rubric for Evaluation of Micro Project of AJP(22517)

Title of Micro Project:- Cafe Management

Group Members:-

Sr.No. Roll Enrollment Seat No. Name of Candidates

No. No
1 42 2211700319 Swara Yogesh Sakhare
2 44 2211700321 Mayuri Vijay Salve
3 50 2211700328 Snehal Somnath Shinde

Marks Indicators for different level of Performance (Evaluation Scale 1 to 10)

Sr Criteria Obtained
(Out of10) Poor (1-3) Average(4-7) Good(8- 10)
No

Relevance to Related to very few

1 Related to at least one CO Adressed at lease one CO
the course Los
Content of Not relevant and Relevant and sufficient for Relevant , sufficient for
2 project sufficient topic topic and well organized
Language of Grammatically Grammatically appropriate Grammatically appropriate
3
Project inappropriate but ineffective and effective
Completed and Completed within due date Completed and submitted
Completion of
4 submitted after but took slightly more time the complete project within
project
due date. to submit complete project. specified due date.
Prepared an improper Prepared appropriate
Report report with Prepared the report with
5 format of the report with
Preparation unsatisfactory content satisfactory content
sufficient content details
Not included key Presented with the help of
6 Presentation points, missed Included key points but power point, Highlighted
details and lacks considerable key points, accurate and
considerable information considerable information
information
Not referred more Referred at –least 5
7 Resources/ than two sources, very Referred at-least 3 relevant relevant sources, 3 most
References old reference sources, at least 2 latest latest

Total:
Average
(Out of 10)

Name and Signature of Guide

 MATOSHRI AASARABAI POLYTECHNIC, EKLAHARE, NASHIK

Department of Information Technology Engineering

Log Book for Micro- Project

Semester:- V Code:-IF5I
Course / Code :CSS(22519)
Class:- Third Year
Topic of the Micro:- Image Gallery : create an interactive image gallery with lightbox effect

Sr. Name of Group Sign. Sr. Name of Sign.

No. Members. No. Group
Members
1 Mayuri Vijay Salve 3 Snehal Somnath
Shinde
2 Swara Yogesh Sakhare

Teache
Week Members
Discussion & Details Teacher’s Comment r’s
No. Present
Sign.
Discussion on the concept of Micro project Discussed micro-
1 with teacher 42,44,50 project concept
Finalization of Group and Project topic with
2 42,44,50 Finalized the group
Project Proposal submission
Preliminary discussion with guide about
3 42,44,50 Discussed with guide
content of Micro project
Related Information Gathered by t3333eam
4 42,44,50 Gathered information
about project
Organized the
5 Organizing the information for project work 42,44,50 information
Discussing project related queries with teacher
6 42,44,50 Discussed the queries
if any
Prepared micro-
7 Preparation of Micro project model or content 42,44,50
project
8 Finalizing the project work by teacher 42,44,50 Finalize project work
Complete report
9 Report writing 42,44,50
writing
10 Presentation , Oral 42,44,50 Gave presentation

11 Submission of project and Project report 42,44,50 Submitted project

Sign Of Faculty
 ANNEXURE II
Evaluation Sheet for the Micro Project
Academic Year:-2024-2025 Name of Faculty:- Prof.Ms.Kale
Course :-Operating System Course Code :- 22516
Title of the Project :- Implement a simple Semester:- 5th
process scheduler using Round Robin or FCFS algorithm
COs addressed by the Micro Project : -
a) Quick Order Input
b) Automatic Cost Calculation

c) Easy Receipt Generation

d) Simple User Interface

e) Efficient Tax Calculation

Major Learning Outcomes achieved by students by doing the Projects:-

a) Practical Outcomes……………………………………………………………………………
…………………………………………………………………………………………………..
b) Unit Outcomes in Cognitive domain
……………………….……………………………………………………………………………
………….....................................................................................................................................
c) Outcomes in Affective Domain
……………………………………………………………………………………………………
…………………………………………………………………………………………………….
Comment /Suggestion about team work /Leadership/ Inter-personal communication (If any)
…………………………………………………………………………………………………………
………………………………………………………………………………………
Marks out of 6 Marks out of 4 for
Roll performance in oral Total out
Student Name for performance
No. in / presentation of 10
group activity activity
1 Mayuri Salve
2 Swara Sakhare
3 Snehal Shinde

Faculty sign
(Prof.Ms.Kale)
 ACKNOWLEDGEMENT

With deep sense of gratitude we would like to thanks all the people who have lit our path with
their kind guidance. We are very grateful to these intellectuals who did their best to help during
our project work.
It is our proud privilege to express deep sense of gratitude to, Dr. A.S.Relakar Principal of
Matoshri Aasarabai Polytechnic, Eklahare, Nashik, for his comments and kind
permission to complete this Micro Project.

We remain indebted to Prof. M.P.Bhandkakar, HOD guidance.

The special gratitude goes to our internal guide Prof.Ms.Kale, technical staff members, and
non-technical staff members, Humanities & Science Department for their expensive,
excellent and precious guidance in completion of this work.

Name of Students:
1.Mayuri Vijay Salve
2.Swara Yogesh Sakhare
3.Snehal Somnath Shinde
Abstract:-

A process scheduler is a critical component of an operating system that manages the execution order of processes
by allocating CPU resources efficiently. Among the various scheduling algorithms, Round Robin (RR) and First-
Come, First-Served (FCFS) are two fundamental techniques widely used in operating systems to determine the
sequence in which processes are executed. Both algorithms aim to optimize CPU utilization, minimize waiting
time, and improve overall system performance; however, they differ significantly in their approach and impact on
the system.

The First-Come, First-Served (FCFS) algorithm, as the name implies, schedules processes in the order they
arrive in the queue. This non-preemptive algorithm is straightforward and easy to implement, as it simply
processes requests on a "first-come, first-served" basis. In FCFS, the process at the front of the queue receives the
CPU first and runs to completion before the next process begins. FCFS scheduling is particularly suitable for batch
processing environments where turnaround time is more critical than response time. However, FCFS can lead to
issues like the "convoy effect," where shorter tasks are delayed by longer ones, leading to inefficient CPU
utilization and increased waiting time for shorter processes.

On the other hand, the Round Robin (RR) algorithm is a preemptive scheduling technique designed to improve
responsiveness in time-sharing systems. In RR, each process is assigned a fixed time slice or "quantum" during
which it can execute. If a process does not complete within its allocated quantum, it is placed at the back of the
queue, and the CPU is assigned to the next process in line. This rotation ensures that each process receives CPU
time in a cyclic manner, promoting fairness and reducing the maximum response time. RR is especially suitable
for interactive systems, where it helps prevent any single process from monopolizing the CPU. However, the
efficiency of RR depends on the choice of the time quantum: if too short, the system may incur high context-
switching overhead; if too long, it may behave similarly to FCFS, increasing response time.

This project explores the implementation of a process scheduler using both the Round Robin and FCFS
algorithms. By simulating these scheduling techniques, we can analyze the impact of each on key performance
metrics such as CPU utilization, turnaround time, waiting time, and response time. Through experimentation, we
can determine the ideal scenarios for each algorithm, highlighting the trade-offs and strengths of Round Robin and
FCFS in different operational contexts. Additionally, we investigate how factors like process arrival time, burst
time, and time quantum affect overall system efficiency and responsiveness. This study aims to provide insight
into the design and selection of scheduling algorithms for optimal CPU scheduling in modern operating systems.

1
Project work(Introduction):-

Introduction:-
In modern computing, effective resource management is essential for maximizing system performance and
ensuring fair allocation of CPU resources among multiple processes. The process scheduler is a core part of the
operating system, responsible for managing the order and timing of process execution on the CPU. By carefully
selecting which processes receive CPU time, the scheduler can influence overall system performance,
responsiveness, and user satisfaction. Scheduling is particularly critical in systems that support multitasking, as it
ensures that all processes have access to CPU resources, either in a controlled, ordered sequence or by sharing
resources to maximize efficiency.

The primary purpose of a process scheduler is to optimize CPU utilization and improve the system’s key
performance metrics, such as waiting time, turnaround time, and response time. These metrics reflect the
efficiency and responsiveness of the system in handling tasks. The way processes are scheduled impacts each
metric differently, making the choice of scheduling algorithm highly significant. Different scheduling algorithms
are used to achieve specific goals, depending on the needs of the system. For instance, time-sharing systems aim to
maximize fairness and interactivity, while batch processing systems might prioritize throughput and completion
time.

Two common scheduling algorithms are First-Come, First-Served (FCFS) and Round Robin (RR). These
algorithms differ in their approaches to process scheduling, with each having its strengths and drawbacks:

1. First-Come, First-Served (FCFS):

FCFS is one of the simplest and oldest scheduling algorithms, operating on a non-preemptive basis.
Processes are executed in the order of their arrival in the queue, similar to a line at a bank or ticket counter.
Each process continues execution until it finishes, at which point the next process in line begins. FCFS is
straightforward and easy to implement, making it ideal for batch systems where processes have long,
continuous CPU bursts. However, FCFS can lead to inefficiencies, particularly the "convoy effect," where
shorter tasks are delayed by longer processes. This effect can significantly increase waiting times for
shorter processes and lower overall CPU efficiency, especially in systems with a mix of short and long
tasks.
2. Round Robin (RR):
The Round Robin scheduling algorithm, on the other hand, introduces preemption and operates in a cyclic
manner. Each process is assigned a fixed time slice, or "quantum," during which it can execute. If a process
does not complete within this quantum, it is paused and moved to the back of the queue, allowing the next
process to use the CPU. This process rotation ensures that all active processes get a chance to run,
enhancing fairness and responsiveness. RR is particularly suited to time-sharing systems, where it
minimizes the maximum response time and improves interactivity. However, the effectiveness of RR
heavily depends on the size of the time quantum. If the quantum is too small, the system may face
excessive context-switching overhead, reducing overall CPU efficiency. Conversely, if the quantum is too
large, RR may behave similarly to FCFS, causing longer response times.

These algorithms represent different philosophies in CPU scheduling. FCFS provides predictability and simplicity
but may result in long waiting times for certain processes, while RR promotes fairness and responsiveness but
requires careful management of time quantum to avoid excessive overhead. This project explores both algorithms
2
through simulation, providing an opportunity to analyze their effects on CPU utilization, throughput, waiting
time, turnaround time, and response time. The goal is to provide a comparative understanding of how FCFS and
RR impact overall system performance and identify the circumstances under which each algorithm is most
effective.

In today's dynamic computing environments, where interactive applications and time-sensitive processes coexist,
understanding the strengths and limitations of these scheduling algorithms is essential. This project aims to
highlight the importance of process scheduling in optimizing CPU usage and improving user experience. By
simulating both FCFS and RR algorithms, we can gain insights into the mechanisms of CPU scheduling and make
informed decisions about which scheduling strategy best suits specific application needs.

3
Project Work(Main Details):-

First come – First served (FCFS), is the simplest scheduling algorithm. FIFO simply queues processes
according to the order they arrive in the ready queue. In this algorithm, the process that comes first will be
executed first and next process starts only after the previous gets fully executed.
Terminologies Used in CPU Scheduling
 Arrival Time: The time at which the process arrives in the ready queue.
 Completion Time: The time at which the process completes its execution.
 Turn Around Time: Time Difference between completion time and arrival time. Turn Around Time =
(Completion Time – Arrival Time)
 Waiting Time (W. T): Time Difference between turnaround time and burst time Ie.
 Waiting Time = (Turn Around Time – Burst Time).
In this example, we have assumed the arrival time of all processes is 0, so turnaround and completion times
are the same.

4
First-Come, First-Served (FCFS) Flowchart

The FCFS scheduling algorithm follows a straightforward approach where each process is executed in the order it
arrives. Here’s a breakdown of the flow:

1. Process Arrival: When a process arrives, it is added to the end of the ready queue.
2. CPU Assignment: The CPU picks the first process in the queue and assigns it the full CPU time.
3. Execution Completion: The process runs to completion without interruption.
4. Next Process: Once the process finishes, the CPU moves to the next process in the queue.
5. Loop Until Queue is Empty: The process continues until there are no more processes in the queue.

FCFS Flowchart:
sql
Copy code
+---------------+
| Start |
+---------------+
|
v
+---------------+
| Process |
| Arrival |
+---------------+
|
v
+---------------+
| Add to |
| Queue |
+---------------+
|
v
+---------------+
| CPU |
| Assignment |
+---------------+
|
v
+---------------+
| Execute |
| Process |
+---------------+
|
v
+---------------+
| Complete? |
+---------------+
| \
v |
+---------------+ |
| Next Process |<--
+---------------+
|
v
+---------------+
| Queue Empty? |
+---------------+
5
 |
v
+---------------+

| End |
+---------------+

Round Robin (RR) Flowchart

In RR scheduling, processes are given a fixed time quantum, and if a process does not complete within this
quantum, it is preempted and moved to the back of the queue. Here’s the step-by-step flow:

1. Process Arrival: A process arrives and is added to the end of the ready queue.
2. Assign CPU Time Quantum: The CPU assigns the time quantum to the first process in the queue.
3. Process Execution: The process begins execution.
4. Check Quantum Expiry: If the process completes within its quantum, it releases the CPU and the next process in
the queue begins.
5. Preemption: If the process does not complete within its time quantum, it is preempted and moved to the end of the
queue.
6. Repeat Until Queue is Empty: This cycle continues until there are no more processes in the queue.

Round Robin Flowchart:

sql
Copy code
+---------------+
| Start |
+---------------+
|
v
+---------------+
| Process |
| Arrival |
+---------------+
|
v
+---------------+
| Add to |
| Queue |
+---------------+
|
v
+---------------+
| Assign Time |
| Quantum |
+---------------+
|
v
+---------------+
| Execute |
| Process |
+---------------+
|
v
+---------------+

6
 | Quantum |
| Expired? |
+---------------+
/ \
v |
+---------------+
| Process |
| Complete? |
+---------------+
| \
v |
+---------------+
| Move to End |<--
| of Queue |
+---------------+
|
v
+---------------+
| Queue Empty? |
+---------------+
|
v
+---------------+
| End |
+---------------+

Explanation of Key Points in the Flowcharts

 Process Arrival: Both FCFS and RR scheduling start by adding processes to the ready queue as they arrive.
 CPU Assignment: FCFS assigns the CPU to each process based on the order of arrival without preemption, while
RR assigns a time quantum for each process.
 Execution & Completion: In FCFS, each process runs to completion. In RR, each process runs for a time quantum;
if incomplete, it returns to the back of the queue.
 Queue Management: FCFS is simpler as processes exit the queue permanently after completion. In RR, processes
may re-enter the queue until completion, ensuring fair CPU access in cyclic order.

These flowcharts help in visualizing the sequential and cyclical nature of FCFS and RR, emphasizing how RR’s
preemptive scheduling leads to improved responsiveness in interactive systems while FCFS is best suited for
simpler, batch processing scenarios.

Important Points to remember

 It is non-preemptive.
 Average Waiting Time is not optimal
 Cannot utilize resources in parallel: Results in Convoy effect (Consider a situation when many IO
bound processes are there and one CPU bound process. The IO bound processes have to wait for
CPU bound process when CPU bound process acquires CPU. The IO bound process could have
better taken CPU for some time, then used IO devices).

Characteristics of FCFS
 Processes are executed according to the order of their arrival.
 This algorithm has high waiting time.
7
 The performance of this algorithm is poor due to high waiting time.
 Implementing FCFS is much easy.

Advantage of FCFS
 It is the simplest scheduling algorithm for process execution.
 The implementation part is very easy.
 Processes are executed according to the order of arrival.

Disadvantage of FCFS
 FCFS is a non-preemptive type of algorithm. In simple terms, the CPU executes the complete
process in once.
 Due to the sequential ordering of execution the waiting time is generally high.
 Easy implementation makes its performance poor.
 If a big process comes first and then small ones, the small ones have to wait more.

8
Source code of Micro-project:-

Code to Implement the Algorithm

9
10
Implementation Using OOPS

11
12
Conclusion
The study of process scheduling algorithms such as First-Come, First-Served (FCFS) and Round Robin (RR)
is integral to understanding how operating systems manage the allocation of CPU resources. Each algorithm has its
own unique strengths and limitations, and the choice of scheduling technique can significantly impact the overall
performance, responsiveness, and user experience of the system. In this exploration, we’ve analyzed and compared
FCFS and RR in terms of their impact on critical performance metrics such as CPU utilization, waiting time,
turnaround time, and response time.

First-Come, First-Served (FCFS) scheduling is one of the oldest and simplest algorithms. It operates on a non-
preemptive basis, executing each process in the exact order it arrives in the queue until completion. While easy to
implement and predictable in behavior, FCFS can lead to inefficiencies, especially in environments with a mix of
long and short processes. The convoy effect, where shorter tasks are delayed by longer ones, can lead to increased
waiting times, low CPU utilization, and a decrease in system throughput. Thus, while FCFS may be suitable for
batch processing systems where simplicity and predictability are prioritized, it lacks the flexibility needed for
modern, interactive, and real-time systems.

On the other hand, Round Robin (RR) scheduling was developed to address the limitations of non-preemptive
algorithms like FCFS. RR introduces a fixed time quantum, allowing the system to cycle through processes in
regular intervals. By sharing CPU time more equitably, RR improves system responsiveness and ensures that no
single process monopolizes resources. This preemptive scheduling nature makes RR particularly suitable for
time-sharing and interactive environments where user satisfaction depends on predictable, timely responses from
the system. However, the effectiveness of RR heavily depends on the choice of time quantum: a very short
quantum leads to excessive context-switching, consuming valuable CPU cycles, while a long quantum can lead to
higher response times and reduce the fairness benefits of RR.

When comparing FCFS and RR, we observe that FCFS is best suited for simpler, non-interactive tasks, where
predictable order and minimal complexity are advantageous. FCFS’s non-preemptive nature allows processes to
complete without interruption, benefiting batch-oriented systems. In contrast, RR is more adaptable for
dynamic, interactive environments, where responsiveness and fair CPU distribution are critical. RR’s time
quantum rotation effectively balances multiple processes, making it ideal for systems that prioritize user
interaction.

Through simulations and performance analysis, we observe that each algorithm performs differently based on the
types of processes in the system. RR generally achieves better response time and fairness but at the cost of
increased context-switching overhead. FCFS provides simplicity and minimal overhead but struggles with fairness
and efficiency, particularly when process lengths vary significantly. For real-world applications, the choice of
scheduling algorithm should align with the specific objectives of the system. For instance, batch processing
applications may prefer FCFS for its straightforward approach, while time-sensitive, interactive applications
would benefit from the responsiveness and fairness of RR.

In conclusion, there is no one-size-fits-all scheduling algorithm; instead, each has its optimal use cases
depending on the system's requirements. FCFS is beneficial where simplicity and low overhead are priorities, and
RR is advantageous in interactive systems where responsiveness and equitable CPU access are critical.
Understanding these scheduling algorithms and their impacts helps inform system designers and developers in
creating more efficient, fair, and responsive operating systems. The continued exploration of these and other
scheduling techniques is crucial as operating systems evolve to support more complex, multitasking environments
with diverse requirements
13
Resources/ References
For a deeper understanding of process scheduling algorithms like First-Come, First-Served (FCFS) and Round
Robin (RR), you may find these resources valuable. They provide detailed information, simulations, and real-
world applications of these algorithms in operating systems.

1. "Operating System Concepts" by Abraham Silberschatz, Peter B. Galvin, and Greg Gagne

 Description: This textbook is a comprehensive resource on operating systems, covering fundamental topics such as
process management, memory management, file systems, and scheduling algorithms. It provides a detailed
discussion on FCFS, Round Robin, and other scheduling algorithms, complete with diagrams, examples, and
exercises to reinforce understanding. The book explains the impact of each scheduling algorithm on system
performance and is widely regarded as a staple in computer science education.
 Link: Operating System Concepts

2. "Modern Operating Systems" by Andrew S. Tanenbaum and Herbert Bos

 Description: This book is another authoritative resource that covers key concepts in operating system design and
implementation. Tanenbaum’s approach emphasizes real-world applications and includes practical examples of
scheduling algorithms in use. The chapters on CPU scheduling offer in-depth explanations of FCFS, RR, and other
algorithms with performance comparisons and scenarios for various operating system environments.
 Link: Modern Operating Systems

3. "CPU Scheduling in Operating Systems" on GeeksforGeeks

 Description: GeeksforGeeks provides a detailed, step-by-step explanation of CPU scheduling algorithms, including
FCFS and Round Robin, with examples and code snippets. It breaks down the algorithms into manageable sections,
discussing their advantages, disadvantages, and performance metrics in a way that’s easy to understand. The site also
includes visual aids and sample problems that allow readers to test their understanding and explore variations of each
algorithm.
 Link: CPU Scheduling in Operating Systems (GeeksforGeeks)

4. "Operating System - Process Scheduling" on TutorialsPoint

 Description: This resource provides a concise overview of scheduling algorithms, including FCFS and Round
Robin, with simple diagrams and code examples. TutorialsPoint is known for its beginner-friendly approach, making
it a great resource if you’re looking for a clear, straightforward introduction to scheduling algorithms. The platform
also offers interactive examples and quizzes to reinforce learning.
 Link: Process Scheduling on TutorialsPoint

14
5. "CPU Scheduling Algorithms Explained with Examples" by StudyTonight

 Description: StudyTonight offers explanations of CPU scheduling algorithms with a focus on practical examples
and simple language. The tutorials cover FCFS, RR, and other scheduling methods, emphasizing their real-world
applications and performance impacts. This resource also provides pseudo-code and flowcharts that illustrate the
process of each scheduling algorithm, making it ideal for visual learners.
 Link: CPU Scheduling Algorithms Explained (StudyTonight)

6. "Process Scheduling in Operating Systems" by Javatpoint

 Description: Javatpoint is a widely used resource that breaks down complex concepts into easy-to-understand
tutorials. The CPU scheduling section includes FCFS, RR, and other scheduling algorithms, complete with diagrams,
flowcharts, and examples. The site explains the pros and cons of each algorithm and includes example scenarios that
help to clarify how each scheduling method functions under different conditions.
 Link: Process Scheduling (Javatpoint)

7. "Comparative Analysis of CPU Scheduling Algorithms" by ResearchGate

 Description: This research paper on ResearchGate presents an in-depth comparative study of various CPU
scheduling algorithms, including FCFS and Round Robin. The paper analyzes the performance metrics of each
algorithm in different scenarios, providing insight into their efficiency, fairness, and suitability for various
applications. It also includes charts and graphs that visually represent the impact of each algorithm on system
performance.
 Link: Comparative Analysis of CPU Scheduling Algorithms

8. "Understanding Round Robin Scheduling" by Techie Delight

 Description: Techie Delight provides a focused article on Round Robin scheduling, discussing its key features,
advantages, and limitations. The tutorial includes code examples and sample problems, allowing readers to see how
Round Robin operates and the considerations involved in setting the time quantum. This resource is especially useful
for those who want a deeper understanding of Round Robin scheduling in particular.
 Link: Understanding Round Robin Scheduling (Techie Delight)

9. "Performance Analysis of First Come First Served and Round Robin Scheduling" by Academia.edu

 Description: This research document explores the performance of FCFS and Round Robin scheduling algorithms in
different test cases. It discusses the computational impact of each method and includes comparative data on metrics
such as waiting time, turnaround time, and CPU utilization. The paper provides a thorough technical analysis,
making it a useful reference for anyone interested in a deeper, data-driven exploration of scheduling algorithms.
 Link: Performance Analysis on Academia.edu

15