Operating System CPU Scheduler: A

Comprehensive Project Report

Executive Summary
This comprehensive project report presents the development and implementation of a visual Operating System
CPU Scheduler that demonstrates four fundamental CPU scheduling algorithms through interactive visualization.
The project, developed by Roushan Kumar (Student ID: 2248410) under the supervision of Prof. Priyanka Gupta,
serves as an educational tool for understanding CPU scheduling concepts through practical implementation and
visual representation.
The system implements First Come First Serve (FCFS), Highest Priority First (HPF), Round Robin (RR), and
Shortest Remaining Time Next (SRTN) algorithms, providing users with an intuitive graphical interface to analyze
process scheduling behavior through Gantt charts and performance metrics.

1. Introduction

1.1 Background
CPU scheduling is a fundamental concept in operating systems that determines the order in which processes are
executed on the processor. When multiple processes compete for CPU resources simultaneously, the operating
system's scheduler must make intelligent decisions about which process to execute next. This decision-making
process directly impacts system performance, resource utilization, and user experience [1] [2] .
The complexity of CPU scheduling arises from the need to balance multiple objectives: maximizing CPU
utilization, ensuring fairness among processes, minimizing response time, and optimizing overall system
throughput. Different scheduling algorithms approach these objectives with varying strategies, each having
distinct advantages and limitations depending on the system's requirements and workload characteristics [2] [3] .

1.2 Project Motivation

Understanding CPU scheduling algorithms theoretically is often challenging for students and practitioners without
practical visualization. Traditional textbook explanations, while comprehensive, may not provide the intuitive
understanding necessary to grasp how these algorithms behave in real-world scenarios. The gap between
theoretical knowledge and practical implementation motivated the development of this visualization tool [4] [5] .
Educational research in computer science emphasizes the importance of visual learning tools in comprehending
complex system concepts. Interactive visualizations enable learners to experiment with different scenarios,
observe algorithm behavior patterns, and develop deeper insights into the trade-offs between different scheduling
approaches [4] [6] .

1.3 Project Objectives

The primary objectives of this project include:

1. Educational Enhancement: Provide an interactive platform for students to understand CPU

scheduling algorithms through visual representation
2. Algorithm Comparison: Enable side-by-side analysis of different scheduling algorithms using
identical process sets
 3. Performance Analysis: Calculate and display key performance metrics including waiting
time, turnaround time, and response time
4. Practical Implementation: Demonstrate real-world application of theoretical concepts
through working software
5. Accessibility: Create a user-friendly interface that accommodates users with varying
technical backgrounds

1.4 Project Scope

This project focuses on four fundamental CPU scheduling algorithms commonly studied in operating systems
courses. The scope includes implementation of non-preemptive and preemptive scheduling methods,
comprehensive performance metric calculations, and visual representation through Gantt charts. The system
accepts process specifications including arrival time, burst time, and priority levels through file input, making it
suitable for both educational demonstrations and algorithm analysis [1] [7] .

2. Literature Review

2.1 CPU Scheduling Fundamentals

CPU scheduling forms the cornerstone of multiprogramming operating systems, where the operating system must
efficiently manage processor time among competing processes. The scheduling mechanism involves several key
components: the scheduler, dispatcher, and various queues that organize processes based on their current state
[8] [9] .

The Process Control Block (PCB) serves as the fundamental data structure for process management, containing
essential information such as process state, program counter, CPU registers, memory management information,
and I/O status. During context switches, the PCB preserves the process's execution context, enabling seamless
process suspension and resumption [8] [9] [10] .

2.2 Scheduling Algorithm Classifications

CPU scheduling algorithms are broadly classified into two categories: non-preemptive and preemptive [2] [11] .
Non-preemptive algorithms allow processes to complete their CPU burst once they begin execution, while
preemptive algorithms can interrupt running processes to allocate the CPU to higher-priority or more suitable
processes.
Non-preemptive algorithms include First Come First Serve (FCFS) and non-preemptive versions of Shortest Job
First (SJF) and Priority Scheduling. These algorithms are simpler to implement and have lower overhead due to
reduced context switching [2] [3] [11] .
Preemptive algorithms such as Round Robin, preemptive SJF (Shortest Remaining Time First), and preemptive
Priority Scheduling offer better responsiveness and fairness but incur additional overhead from frequent context
switches [2] [3] [12] .

2.3 Performance Metrics

The effectiveness of CPU scheduling algorithms is evaluated using several performance metrics [13] [14] [15] :

Turnaround Time: Total time from process arrival to completion (Completion Time - Arrival
Time)
Waiting Time: Time spent in ready queue (Turnaround Time - Burst Time)
 Response Time: Time from arrival to first CPU allocation
CPU Utilization: Percentage of time CPU remains busy
Throughput: Number of processes completed per time unit

2.4 Context Switching Considerations

Context switching represents a significant overhead in CPU scheduling, particularly for algorithms with small time
quanta or frequent preemption [16] [17] [12] . Modern systems typically experience context switch times of 10
microseconds or less, while time quanta range from 10 to 100 milliseconds, ensuring context switch overhead
remains below 10% of CPU time [17] [12] .
The relationship between time quantum size and system performance is critical in Round Robin scheduling.
Extremely small quanta increase context switching overhead, while excessively large quanta reduce the
algorithm to FCFS behavior. Research suggests that 80% of CPU bursts should be shorter than the selected time
quantum for optimal performance [17] [12] .

3. System Design and Architecture

3.1 System Overview

The OS Scheduler visualization system adopts a modular architecture comprising four primary components: Input
Processing Module, Algorithm Implementation Engine, Visualization Generator, and Output Management System.
This design promotes maintainability, extensibility, and clear separation of concerns.
The system operates on a file-based input mechanism where users specify process characteristics through
structured text files. The first line indicates the number of processes, followed by process specifications
containing Process ID, Arrival Time, Burst Time, and Priority values. This standardized format ensures
consistency across different algorithm implementations and facilitates batch processing of multiple scenarios.

3.2 Input File Specification

The input file format follows a simple yet comprehensive structure:

Number_of_Processes
ProcessID ArrivalTime BurstTime Priority
ProcessID ArrivalTime BurstTime Priority
...

For example:

4
1 0 5 2
2 2 3 1
3 4 1 3
4 6 2 2

This format accommodates all implemented scheduling algorithms, with unused parameters (such as priority in
FCFS) being ignored during algorithm execution.
3.3 Graphical User Interface Design
The GUI incorporates several key elements designed for educational effectiveness and ease of use:

Algorithm Selection Panel: Radio buttons or dropdown menu for algorithm selection
Parameter Configuration: Input fields for context switch time and time quantum
File Management: File browser for input file selection and output file specification
Visualization Area: Large display region for Gantt chart rendering
Control Buttons: Execute, reset, and save functionality
Results Display: Tabular presentation of performance metrics

3.4 Gantt Chart Visualization

The Gantt chart implementation uses a time-based horizontal axis with process identifiers on the vertical axis.
Color coding distinguishes between different processes, while special indicators represent CPU idle time (0) and
context switching periods (-1). This visual representation enables users to quickly identify process execution
patterns, waiting periods, and algorithm-specific behaviors.

4. Algorithm Implementation

4.1 First Come First Serve (FCFS)

FCFS represents the simplest CPU scheduling algorithm, executing processes in their arrival order without
preemption. The algorithm maintains a single queue where processes are enqueued upon arrival and dequeued
for execution in FIFO order [1] [18] [11] .
Algorithm Characteristics:

Non-preemptive execution model

Simple FIFO queue implementation
No priority considerations
Potential for convoy effect with long processes
Implementation Details:
The FCFS implementation sorts processes by arrival time, then executes each process to completion before
advancing to the next. Context switching occurs only between process completions, minimizing overhead but
potentially causing poor response times for short processes arriving after long ones.
Performance Analysis:
FCFS provides predictable behavior but often results in high average waiting times, particularly when long
processes arrive early. The algorithm's simplicity makes it suitable for batch processing systems but inadequate
for interactive environments requiring responsive performance [3] [19] .

4.2 Highest Priority First (HPF) - Non-Preemptive

The HPF algorithm selects processes based on priority levels, with lower numerical values typically representing
higher priorities. Once a process begins execution, it runs to completion regardless of newly arriving higher-
priority processes.
Algorithm Characteristics:
 Priority-based selection mechanism
Non-preemptive execution model
Potential for priority inversion
Risk of process starvation for low-priority tasks
Implementation Strategy:
The implementation maintains a priority queue of ready processes, selecting the highest-priority process for
execution when the CPU becomes available. Tie-breaking typically employs FCFS ordering among processes
with identical priorities.
Advantages and Limitations:
HPF provides good response times for high-priority processes but may cause indefinite postponement of low-
priority tasks. The algorithm works well in environments with clear priority hierarchies but requires careful
priority assignment to prevent starvation scenarios [2] [3] .

4.3 Round Robin (RR)

Round Robin scheduling implements time-sharing by allocating fixed time slices (quanta) to each process in
circular order. Processes exceeding their time quantum are preempted and moved to the ready queue's rear,
ensuring fair CPU distribution among all processes.
Algorithm Characteristics:

Preemptive time-sharing mechanism

Fixed time quantum allocation
Circular ready queue management
Fair CPU distribution guarantee
Time Quantum Considerations:
The time quantum selection significantly impacts system performance. Small quanta provide better
responsiveness but increase context switching overhead, while large quanta may degrade to FCFS behavior.
Optimal quantum selection balances responsiveness with efficiency [17] [12] .
Implementation Details:
The RR implementation maintains a circular queue of ready processes and a timer mechanism for quantum
tracking. Upon quantum expiration or process completion, the scheduler performs context switching and selects
the next ready process.

4.4 Shortest Remaining Time Next (SRTN)

SRTN represents the preemptive version of Shortest Job First scheduling, continuously selecting the process with
the shortest remaining execution time. This algorithm provides optimal average waiting time but requires
accurate burst time predictions.
Algorithm Characteristics:

Preemptive shortest-job selection

Dynamic priority adjustment based on remaining time
Optimal average waiting time (theoretical)
Susceptible to starvation of long processes
Implementation Complexity:
SRTN implementation requires continuous monitoring of remaining execution times and frequent preemption
decisions. The algorithm maintains a priority queue ordered by remaining burst time, updating priorities after each
time unit.
Performance Implications:
While SRTN provides optimal theoretical performance for average waiting time, practical implementations face
challenges including burst time prediction accuracy and increased context switching overhead. The algorithm
performs well in environments with predictable process characteristics [1] [2] .

5. Implementation Details

5.1 Data Structures

The system employs several key data structures to manage process information and algorithm execution:
Process Structure:

struct Process {
int processID;
int arrivalTime;
int burstTime;
int remainingTime;
int priority;
int completionTime;
int turnaroundTime;
int waitingTime;
int responseTime;
bool firstRun;
}

Ready Queue Management:

Different algorithms utilize appropriate queue structures - simple queues for FCFS, priority queues for HPF and
SRTN, and circular queues for Round Robin. These data structures optimize algorithm-specific operations while
maintaining consistent interfaces.

5.2 Context Switching Implementation

Context switching simulation incorporates realistic timing considerations, allowing users to specify context switch
overhead. The implementation tracks context switch occurrences and includes their impact in performance
calculations, providing realistic system behavior modeling.

5.3 Performance Metric Calculations

The system calculates comprehensive performance metrics for each process and overall system performance:

Individual Process Metrics: Completion time, turnaround time, waiting time, and response
time
System-wide Metrics: Average values for all timing metrics, CPU utilization percentage, and
throughput calculations
Algorithm Comparison: Side-by-side metric comparison for educational analysis
6. Results and Analysis

6.1 Algorithm Comparison Study

To demonstrate the system's analytical capabilities, we present a comparative study using a standard process set:
Test Process Set:

5
1 0 8 3
2 1 4 1
3 2 2 4
4 3 1 2
5 4 3 5

6.2 FCFS Results Analysis

FCFS execution produces predictable results with processes executing in arrival order: P1→P2→P3→P4→P5. The
algorithm demonstrates the convoy effect, where short processes wait behind longer ones, resulting in suboptimal
average waiting times.
Key Observations:

Simple implementation with minimal overhead

Poor performance with mixed process lengths
Predictable execution order regardless of process characteristics
Suitable for batch processing environments

6.3 HPF Performance Evaluation

HPF prioritizes processes based on priority values, potentially improving response times for critical tasks.
However, the non-preemptive nature may delay high-priority processes arriving after low-priority execution
begins.
Performance Characteristics:

Better response times for high-priority processes

Risk of starvation for low-priority tasks
Dependent on priority assignment strategy
Effective in environments with clear priority hierarchies

6.4 Round Robin Analysis

RR provides fair CPU allocation through time-sharing, with performance heavily dependent on quantum size
selection. The algorithm ensures no process monopolizes the CPU, making it suitable for interactive systems.
Time Quantum Impact:

Small quanta: Better responsiveness, higher overhead

Large quanta: Reduced responsiveness, lower overhead
 Optimal quantum balances responsiveness and efficiency

6.5 SRTN Performance Study

SRTN provides optimal average waiting time but requires accurate burst time information. The preemptive nature
enables dynamic adjustment to changing process requirements.
Algorithm Benefits:

Optimal theoretical performance for average waiting time

Dynamic adaptation to process mix changes
Effective for predictable workloads
Challenges with burst time prediction accuracy

7. Educational Impact and Applications

7.1 Pedagogical Benefits

The visualization system addresses several educational challenges in operating systems instruction:
Conceptual Understanding: Visual representation transforms abstract algorithms into concrete, observable
behaviors, facilitating deeper comprehension of scheduling concepts.
Interactive Learning: Students can experiment with different process sets and parameters, developing intuitive
understanding through hands-on exploration.
Comparative Analysis: Side-by-side algorithm comparison enables students to understand trade-offs and
performance implications of different scheduling approaches.

7.2 Classroom Integration

The system serves multiple educational purposes:

Lecture Demonstrations: Instructors can illustrate algorithm concepts using real-time

visualizations
Laboratory Exercises: Students can analyze algorithm behavior through structured
experiments
Assignment Projects: The system supports various assignment types from basic analysis to
algorithm modification
Research Projects: Advanced students can extend the system with additional algorithms or
optimization techniques

7.3 Learning Outcomes

Students using this visualization system typically achieve improved learning outcomes:

Enhanced understanding of CPU scheduling concepts

Better appreciation of algorithm trade-offs and performance implications
Practical experience with system performance analysis
 Preparation for advanced operating systems topics

8. System Testing and Validation

8.1 Test Case Development

Comprehensive testing ensures system reliability and educational effectiveness. Test cases include:
Basic Functionality Tests: Verification of individual algorithm implementations against known results
Edge Case Handling: Testing with extreme scenarios such as zero-length processes, simultaneous arrivals, and
identical parameters
Performance Validation: Comparison of calculated metrics against manual calculations
User Interface Testing: Evaluation of GUI responsiveness and error handling

8.2 Algorithm Verification

Each algorithm implementation undergoes rigorous verification:

Mathematical Correctness: Metric calculations verified against textbook examples

Behavioral Accuracy: Algorithm behavior compared with theoretical descriptions
Edge Case Handling: Proper handling of special scenarios and boundary conditions

8.3 User Experience Evaluation

Educational effectiveness assessment includes:

Usability Testing: Interface evaluation with target user groups

Learning Impact Assessment: Measurement of comprehension improvement
Feedback Integration: Incorporation of user suggestions for system enhancement

9. Future Enhancements

9.1 Algorithm Extensions

The system architecture supports several potential enhancements:
Additional Algorithms: Implementation of Multilevel Queue Scheduling, Multilevel Feedback Queue, and Lottery
Scheduling algorithms would provide comprehensive coverage of scheduling techniques.
Dynamic Priority Adjustment: Integration of aging mechanisms to prevent starvation in priority-based algorithms
would demonstrate advanced scheduling concepts.
Real-time Scheduling: Addition of real-time scheduling algorithms would extend the system's applicability to
embedded and time-critical systems.
9.2 Visualization Improvements
Enhanced visualization capabilities could include:
3D Gantt Charts: Three-dimensional representations showing multiple system resources simultaneously
Animation Controls: Speed adjustment, pause/resume functionality, and step-by-step execution modes
Interactive Editing: Real-time process parameter modification during simulation
Statistical Analysis: Advanced performance metric visualization including histograms and trend analysis

9.3 System Architecture Enhancements

Technical improvements could include:
Web-based Interface: Browser-based implementation for improved accessibility and platform independence
Database Integration: Process library management and historical analysis capabilities
Network Support: Multi-user collaborative analysis and remote system access
Mobile Compatibility: Tablet and smartphone interfaces for portable learning

9.4 Advanced Features

Sophisticated extensions might incorporate:
Machine Learning Integration: Automatic optimal parameter selection based on workload characteristics
Performance Prediction: Forecasting system behavior under different scheduling policies
Resource Modeling: Extended simulation including memory, I/O, and network resources
Comparative Optimization: Automatic algorithm selection based on performance objectives

10. Conclusion

10.1 Project Achievements

The OS Scheduler visualization project successfully achieves its primary objectives of providing an educational
tool for understanding CPU scheduling algorithms. The system's implementation of four fundamental scheduling
algorithms with comprehensive performance analysis and visual representation addresses significant gaps in
traditional operating systems education.
Technical Accomplishments:

Successful implementation of FCFS, HPF, RR, and SRTN algorithms

Comprehensive performance metric calculations including context switching overhead
Intuitive graphical user interface with Gantt chart visualization
Robust input/output handling with standardized file formats
Educational Impact:

Enhanced student understanding of abstract scheduling concepts

Practical demonstration of algorithm trade-offs and performance implications
Interactive learning environment supporting experimentation and discovery
Valuable tool for both instruction and self-directed learning
10.2 System Contributions
The project makes several notable contributions to operating systems education:
Visualization Innovation: The Gantt chart representation with special indicators for CPU idle time and context
switching provides unprecedented clarity in algorithm behavior visualization.
Comprehensive Analysis: Integration of multiple performance metrics enables thorough algorithm comparison
and analysis, supporting both basic understanding and advanced research.
Educational Accessibility: The user-friendly interface makes complex scheduling concepts accessible to students
with varying technical backgrounds and experience levels.

10.3 Learning Insights

Development of this system provided valuable insights into both CPU scheduling algorithms and educational
software design:
Algorithm Understanding: Implementation deepened appreciation for the subtleties and complexities of
scheduling algorithm behavior, particularly regarding edge cases and performance optimization.
Educational Design: Creating effective educational software requires careful balance between simplicity and
comprehensiveness, ensuring accessibility without sacrificing educational value.
System Integration: Combining algorithm implementation, visualization, and user interface design highlighted the
importance of modular architecture and clear component interfaces.

10.4 Practical Applications

Beyond educational use, the system demonstrates practical value:
Algorithm Prototyping: The modular design facilitates rapid prototyping and testing of new scheduling algorithms
Performance Analysis: The comprehensive metric calculation supports detailed performance analysis for system
optimization
Research Platform: The extensible architecture provides a foundation for advanced scheduling research and
experimentation

10.5 Future Directions

The project establishes a solid foundation for continued development and enhancement. Future work could
explore advanced scheduling concepts, extend visualization capabilities, and integrate emerging technologies
such as machine learning for intelligent scheduling optimization.
The success of this visualization system demonstrates the value of practical, interactive tools in computer science
education. By bridging the gap between theoretical knowledge and practical understanding, such tools enhance
learning effectiveness and prepare students for real-world system design challenges.

10.6 Final Remarks

The OS Scheduler project represents a significant step forward in operating systems education, providing
students and instructors with a powerful tool for understanding and analyzing CPU scheduling algorithms.
Through comprehensive implementation, intuitive visualization, and robust performance analysis, the system
transforms abstract concepts into concrete, observable behaviors.
The project's success validates the importance of visual learning tools in computer science education and
demonstrates the feasibility of creating sophisticated educational software that maintains both technical accuracy
and pedagogical effectiveness. As operating systems continue to evolve with new hardware architectures and
application requirements, tools like this visualization system become increasingly valuable for understanding
fundamental concepts that underpin system performance and behavior.

References
[20] Operating System Handout, Unit IV – CPU Scheduling and Algorithm
[1] Scaler Topics - Process Control Block (PCB) in OS
[4] Project Report - Visual OS Scheduler, Scribd
[7] GeeksforGeeks - CPU Scheduling in Operating Systems
[2] GeeksforGeeks - CPU Scheduling Algorithms
[5] GitHub - CPU Scheduling Algorithm Visualizer by PrinceSinghhub
[21] GeeksforGeeks - Advantages and Disadvantages of CPU Scheduling Algorithms
[3] Redwood - Job Scheduling Algorithms: Which Is Best For Your System
[22] GitHub - Operating Systems Scheduling by AhmadYahya97
[18] GeeksforGeeks - FCFS CPU Scheduling Algorithm
[19] GitHub - CPU Scheduling Algorithms with GUI by RhuthuHegde
[6] TutorialsPoint - Operating System Scheduling Algorithms
[23] Portfolio - OS Scheduling Algorithms by Arpit Singh Gautam
[11] GeeksforGeeks - CPU Scheduling using Priority Queue with Gantt Chart
[24] University of Illinois Chicago - Operating Systems: CPU Scheduling
[25] CPU Scheduling Visualizer by Ribhav Jain
[26] CPU Scheduling Algorithm Visualizer by Mukul
[27] Testbook - Context Switching in CPU Scheduling
[28] AfterAcademy - CPU Scheduling Time Calculations
[29] TutorialsPoint - Process Control Block (PCB)
[30] University of Illinois Chicago - CPU Scheduling (Advanced)
[8] Scaler Topics - Process Control Block Structure and Management
[16] University lecture notes - CPU Scheduling and Context Switching
[13] Educative - CPU Scheduling Time Calculations
[9] GeeksforGeeks - Process Table and Process Control Block
[17] Baeldung - CPU Scheduling Metrics and Analysis
[14] GeeksforGeeks - Turn Around Time vs Waiting Time
[10] ScienceDirect - Process Control Block Overview
[12] GeeksforGeeks - CPU Scheduling Criteria
[15] BYJUS - Process Control Block in Operating Systems
[31] [32] [33] [34] [35] [36] [37] [38]

1. https://www.scribd.com/document/705020262/Project-Report-Visual-OS-Scheduler
2. https://github.com/PrinceSinghhub/CPU-SCHEDULING-ALGORITHM-VISUALISER
3. https://cpu-scheduling-algorithm-visualiser.netlify.app
4. https://www.gchamirpur.org/pdf/lectures6/Unit-II-Lecture-10-Scheduling-Part-II.pdf
5. https://www.youtube.com/watch?v=-Izsh82Ykmg
6. https://github.com/RhuthuHegde/CPU-Scheduling-Algorithms-with-GUI
7. https://www.geeksforgeeks.org/operating-systems/cpu-scheduling-in-operating-systems/
8. https://testbook.com/question-answer/in-which-of-the-following-scheduling-criteria-con--5ea42fddf60
d5d53736fc0c6
9. https://uomustansiriyah.edu.iq/media/lectures/6/6_2022_01_10!08_08_03_AM.pdf
10. https://www.cs.uic.edu/~jbell/CourseNotes/OperatingSystems/6_CPU_Scheduling.html
11. https://arpitsinghgautam.me/portfolio/Operating-System-Scheduling-Algorithms.html
12. https://www.geeksforgeeks.org/operating-systems/difference-between-turn-around-time-tat-and-waitin
g-time-wt-in-cpu-scheduling/
13. https://www.geeksforgeeks.org/operating-systems/process-table-and-process-control-block-pcb/
14. https://www.tutorialspoint.com/what-is-process-control-block-pcb
15. https://www.sciencedirect.com/topics/computer-science/process-control-block
16. https://afteracademy.com/blog/what-is-burst-arrival-exit-response-waiting-turnaround-time-and-throug
hput
17. https://www.educative.io/answers/arrival-burst-completion-turnaround-waiting-response-time
18. https://www.redwood.com/article/job-scheduling-algorithms/
19. https://github.com/AhmadYahya97/OperatingSystemScheduling
20. https://aissmspoly.org.in/wp-content/uploads/2020/01/CPU-Scheduling-and-Algorithm-.pdf
21. https://www.geeksforgeeks.org/operating-systems/advantages-and-disadvantages-of-various-cpu-sche
duling-algorithms/
22. https://www.geeksforgeeks.org/dsa/first-come-first-serve-cpu-scheduling-non-preemptive/
23. https://www.tutorialspoint.com/operating_system/os_process_scheduling_algorithms.htm
24. https://www.geeksforgeeks.org/operating-systems/cpu-scheduling-in-operating-systems-using-priority-
queue-with-gantt-chart/
25. https://techzzers.wordpress.com/process-scheduling-algorithms-fcfssjfpriority-round-robin/
26. https://cpu-scheduling-visualizer-ribhav.vercel.app
27. https://www.cs.uic.edu/~jbell/CourseNotes/OperatingSystems/5_CPU_Scheduling.html
28. https://www.vbspu.ac.in/e-content/Scheduling-Algorithm.pdf
29. https://mukul2310.github.io/cpu-scheduler-visualiser/
30. https://www.scaler.com/topics/operating-system/process-control-block-in-os/
31. https://www.geeksforgeeks.org/operating-systems/cpu-scheduling-criteria/
32. https://www.geeksforgeeks.org/operating-systems/process-control-block-in-os/
33. https://www.baeldung.com/cs/cpu-scheduling
34. https://en.wikipedia.org/wiki/Process_control_block
35. https://www.rroij.com/open-access/pdfdownload.php?aid=37799
36. https://www.youtube.com/watch?v=n7Owxwfr6Ko
37. https://byjus.com/gate/process-control-block-notes/
38. https://www.youtube.com/watch?v=NO_pShK5EB4