A SYNOPSIS ON

PROCESS SCHEDULING SIMULATOR

Submitted in partial fulfilment of the requirement for the award of the degree of

BACHELOR OF COMPUTER APPLICATION

Submitted by:
Abhishek Mehra 2371019
Komal Mangchwari 2371187
Tanuj Upadhyay 2371398
Vishal 2371425

Under the Guidance of

Dr. Naveen Tewari
Associate Professor

Project Team ID: 89

School of Computing
Graphic Era Hill University, Bhimtal, Uttarakhand
March-2025

Page | 1
 CANDIDATE’S DECLARATION

I/We hereby certify that the work which is being presented in the Synopsis entitled “Process
Scheduling Simulator” in partial fulfilment of the requirements for the award of the Degree of
Bachelor Computer Application of the Graphic Era Hill University, Bhimtal shall be carried out by the
undersigned under the supervision of Dr. Naveen Tewari, Associate Professor, School of Computing,
Graphic Era Hill University, Bhimtal.

Abhishek Mehra 2371019 ______________

Komal Mangchwari 2371187 ______________
Tanuj Upadhyay 2371398 ______________
Vishal 2371425 ______________

The above mentioned students shall be working under the supervision of the undersigned on the
“Process Scheduling Simulator”

____________ _____________
Supervisor Head of the Department

Internal Evaluation (By DPRC Committee)

Status of the Synopsis: Accepted / Rejected

Any Comments:

Name of the Committee Members: Signature with Date

1.
2.

Page | 2
Table of Contents

Chapter No. Description Page No.

Introduction and Problem

Chapter 1
Statement

Background/ Literature
Chapter 2
Survey

Chapter 3 Objectives

Hardware and Software

Chapter 4
Requirements

Possible Approach/
Chapter 5
Algorithms

References

Page | 3
 Chapter 1
Introduction and Problem Statement

In the following sections, a brief introduction and the problem statement for the work has
been included.
1. Introduction

In modern computing systems, process scheduling plays a crucial role in ensuring efficient CPU
utilization and fair execution of tasks. The CPU scheduler determines the order in which processes
execute, optimizing system performance and responsiveness. Scheduling is necessary because CPU
time is a limited resource, and multiple processes compete for it. Efficient scheduling algorithms
ensure that processes execute efficiently while maintaining fairness and minimizing delays.

Process scheduling is a fundamental topic in operating systems and is widely studied in computer
science courses. However, many students find it difficult to grasp the working of scheduling
algorithms due to their theoretical nature. Traditional learning methods involve numerical problem-
solving, which does not fully capture the dynamic behavior of process execution.

To address this challenge, our Process Scheduling Simulator provides an interactive, visual
representation of various scheduling algorithms. The simulator allows users to enter process details
and see how different scheduling techniques impact execution order, turnaround time, and waiting
time. By graphically illustrating the process execution, our simulator enhances understanding and
helps users compare the efficiency of different scheduling techniques.

Figure 1.1

Page | 4
 2. Problem Statement
The problem statement for the present work can be stated as follows:

Process scheduling is a crucial component of operating system design, ensuring efficient CPU
utilization and fair process execution. However, understanding how different scheduling algorithms
work can be challenging for students and professionals due to their abstract nature. Traditional
learning methods rely on theoretical explanations and numerical calculations, which often fail to
provide a clear visual representation of how processes are scheduled and executed in real-time.

Existing process scheduling tools and educational materials often have significant limitations, such
as:

1. Lack of Interactive Learning – Most resources explain scheduling through static examples,
making it difficult to grasp the dynamic execution order of processes.
2. Minimal Graphical Representation – Without visualization tools like Gantt charts, it is
challenging to observe how processes move between different states (ready, running,
waiting).
3. No Real-Time Input Customization – Many available simulators do not allow users to enter
custom process parameters (arrival time, burst time, priority, time quantum).
4. Limited Comparative Analysis – There is no easy way to compare different scheduling
algorithms in terms of turnaround time, waiting time, and response time in a single
interface.
5. Lack of Educational Simulators – Most scheduling simulators are designed for research or OS
development rather than being student-friendly tools for learning.

How Our Project Solves These Problems

• Our Process Scheduling Simulator aims to address these challenges by providing:

• A user-friendly graphical interface to visualize process execution using Gantt charts.
• Real-time simulation of major CPU scheduling algorithms, including FCFS, SJF, Round Robin,
and Priority Scheduling.
• Dynamic user input support, allowing users to define process parameters and see
immediate results.
• Comparative analysis of scheduling techniques, helping users analyse efficiency based on
turnaround time, waiting time, and response time.
• An interactive learning tool for students and professionals to understand CPU scheduling
concepts easily.

Page | 5
 Chapter 2
Background/ Literature Survey
2.1 Process Scheduling Overview

Process scheduling is one of the most critical functions of an operating system. It determines the
order in which processes execute, ensuring that the CPU remains busy while minimizing waiting
times. The CPU scheduler selects processes from the ready queue based on a predefined scheduling
algorithm. The effectiveness of these algorithms directly impacts the system’s performance,
responsiveness, and resource utilization.

Process scheduling can be classified into three main categories:

1. Long-Term Scheduling – Determines which processes are admitted into the system for
execution.
2. Short-Term Scheduling (CPU Scheduling) – Decides which process gets CPU time at any given
moment.
3. Medium-Term Scheduling – Manages processes in memory, swapping them in and out based
on availability.

Our project focuses on short-term CPU scheduling, which is crucial for multitasking and time-sharing
systems. The efficiency of scheduling algorithms is measured using parameters such as:

• Turnaround Time (TAT): The total time taken from process submission to completion.
• Waiting Time (WT): The time a process spends in the ready queue before execution.
• Response Time (RT): The time between a process request and its first execution.

Different scheduling algorithms optimize these parameters based on specific use cases, balancing
fairness, efficiency, and system performance.

2.2 Existing Solutions and Their Limitations

Several tools and resources currently exist to explain CPU scheduling, but each has limitations:

1. Text-Based Tutorials (Books & Websites)

Page | 6
 o Websites like GeeksforGeeks, TutorialsPoint, and Stack Overflow provide theoretical
explanations and solved examples of scheduling algorithms.
o Books such as "Operating System Concepts" by Silberschatz, Galvin, and Gagne
explain scheduling principles with diagrams.
o Limitations:
▪ Lack of interactivity and hands-on learning.
▪ Students often struggle to visualize how processes execute in real-time.
2. Basic CPU Scheduling Simulators
o Some open-source simulators (such as CPU Scheduling Visualizer on GitHub) allow
users to experiment with scheduling.
o Limitations:
▪ Many of these tools have outdated or limited user interfaces.
▪ They lack dynamic process input customization.
▪ Most do not allow for comparative analysis between different scheduling
techniques.
3. OS-Specific Scheduling Tools
o Some operating systems provide built-in scheduling mechanisms (Linux’s Completely
Fair Scheduler, Windows NT Scheduler).
o Limitations:
▪ These are designed for system-level scheduling, not for educational
learning.
▪ Users cannot modify or test different scheduling strategies in an easy-to-use
environment.
4. Graphical Scheduling Simulations in Research Papers
o Some research papers propose scheduling visualization tools, but these are often
complex and not accessible to students.
o Limitations:
▪ These solutions are usually limited to specific case studies.
▪ They are often not open-source or too advanced for beginners.

Page | 7
2.3 Need for Our Project

Given the limitations of existing solutions, our Process Scheduling Simulator provides a much-
needed interactive, customizable, and user-friendly learning tool. The key features that differentiate
our project from existing tools include:

• Graphical Representation: The simulator visually displays scheduling execution with Gantt
charts, making it easier to understand.
• Custom Process Inputs: Users can enter different values (arrival time, burst time, priority,
etc.) to test various scenarios.
• Comparison of Algorithms: The tool calculates and compares turnaround time, waiting
time, and response time for different scheduling techniques.
• User-Friendly Interface: Unlike research tools or OS schedulers, our simulator is designed
specifically for students and learners.
• Real-Time Execution: Instead of pre-defined examples, the simulator dynamically schedules
processes based on user input, offering a practical learning experience.

By addressing the shortcomings of traditional learning methods and existing simulators, our project
serves as an essential educational tool for students, teachers, and researchers in operating system
studies.

Page | 8
 Chapter 3
Objectives
The objectives of the proposed work are as follows:

1. To develop a GUI-based simulator that visualizes process scheduling algorithms.

2. To implement multiple CPU scheduling techniques, including:

• First-Come, First-Serve (FCFS)

• Shortest Job First (SJF)

• Round Robin (RR)

• Priority Scheduling

3. To allow user-defined process inputs for dynamic testing.

4. To compare scheduling algorithms based on:

• Turnaround time

• Waiting time

• Response time

5. To help students and professionals understand scheduling concepts through

interactive demonstrations.

Page | 9
 Chapter 4

Hardware and Software Requirements

4.1 Hardware Requirements

• Processor: Intel Core i3 or higher

• RAM: Minimum 4GB (Recommended 8GB)
• Storage: 10GB free space
• Monitor: Minimum resolution 1280×720

4.2 Software Requirements

• Operating System: Windows, Linux, or macOS

• Programming Language: Python (with Tkinter/PyQt) or Java (with JavaFX/Swing)
• Libraries/Tools:
o NumPy (for mathematical computations)
o Matplotlib (for graph plotting)
o Tkinter/PyQt (for GUI)

Page | 10
 Chapter 5
Possible Approach/ Algorithms

5.1 Proposed System

The Process Scheduling Simulator is designed to provide an interactive, efficient, and user-friendly
platform for visualizing and analyzing various CPU scheduling algorithms. The system aims to help
students, researchers, and professionals gain a deeper understanding of process scheduling by
offering real-time execution, dynamic input handling, graphical visualization, and performance
comparison across different scheduling techniques.

This simulator will serve as both a learning tool and a performance analysis platform, bridging the
gap between theoretical knowledge and practical implementation of scheduling concepts.

5.2 Key Features of the Proposed System

The Process Scheduling Simulator will offer the following core functionalities:

1. Support for Multiple Scheduling Algorithms

• First-Come, First-Serve (FCFS) – Executes processes in the order of arrival.
• Shortest Job Next (SJF/SJN) – Prioritizes processes with the shortest burst time.
• Round Robin (RR) – Implements a time-sharing approach using a time quantum.
• Priority Scheduling – Executes processes based on their assigned priority values.
• Future Expansion: Additional scheduling techniques like Multilevel Queue Scheduling may
be included in later versions.
2. Graphical Representation of Process Execution
• Gantt Charts will visually display process execution sequences.
• State Transition Diagrams will illustrate how processes move between the ready, running,
and waiting states.

Page | 11
3. Real-Time Process Input Customization

▪ Users can manually enter process parameters such as:

▪ Process ID
▪ Arrival Time
▪ Burst Time
▪ Priority (for priority scheduling)
▪ Time Quantum (for Round Robin)
▪ Alternatively, the system can auto-generate processes for performance
testing.
4. Performance Metrics Calculation
▪ The simulator will compute and display:
▪ Turnaround Time (TAT) – Time taken from process
submission to completion.
▪ Waiting Time (WT) – Time a process spends in the ready
queue before execution.
▪ Response Time (RT) – Time taken from request submission to
first execution.
▪ These metrics will be used for comparative analysis of scheduling
algorithms.
5. Comparison of Scheduling Algorithms
▪ The simulator will generate a performance report comparing
different scheduling techniques based on:

➢ Average Turnaround Time

➢ Average Waiting Time
➢ CPU Utilization Efficiency

• A side-by-side execution comparison feature will allow users to visualize

the impact of different scheduling strategies.

Page | 12
 6. User-Friendly Interface

• A GUI-based simulator (built using Python-Tkinter, Java-Swing, or

JavaScript) for ease of interaction.
• Input validation and error handling to prevent invalid process
configurations.
• Export options to save simulation results for academic or research use.

7. Scalability and Future Enhancements

• The system will be designed to accommodate additional features, such as:

➢ Multilevel Queue Scheduling for handling multiple priority classes.

➢ Real-time OS Scheduling Simulations for embedded systems.
➢ AI-based Scheduling Optimization for predicting the best scheduling
strategy based on workload.

5.3 Objectives of the Proposed System

The Process Scheduling Simulator is developed with the following objectives:

• Enhance Learning and Understanding – Provide students with an interactive tool to

understand scheduling algorithms more effectively.
• Improve Visualization – Convert abstract scheduling concepts into graphical
execution sequences.
• Allow Real-Time Customization – Enable users to input different scheduling
scenarios and observe the effects dynamically.
• Compare Algorithm Efficiency – Help users analyze the strengths and weaknesses
of different scheduling policies.
• Optimize Performance – Ensure that the simulator executes efficiently for large
numbers of processes.
• Serve as an Educational and Research Tool – Provide a robust and scalable
platform for use in both academic and industry-based studies.

Page | 13
5.5 Possible Approaches for Implementing the Process Scheduling Simulator

Developing a Process Scheduling Simulator requires selecting an approach that balances

performance, visualization, and real-time interaction. The following approaches can be considered:

5.5.1 Sequential Processing Approach

Description:

• Each scheduling algorithm is implemented individually as a separate module.

• The CPU executes processes one at a time, updating the schedule dynamically.
• No concurrent execution; each process runs sequentially based on the scheduling policy.

Advantages:
✅ Easy to Implement – Simple logic without concurrency.

✅ Ideal for Small Inputs – Works well for a limited number of processes.

Disadvantages:
❌ Slow Execution for Large Datasets – Cannot handle multiple processes efficiently.

❌ Limited Scalability – Not suitable for real-time scheduling.

Use Case:

• Basic educational simulators to demonstrate CPU scheduling principles.

5.5.2 Event-Driven Simulation Approach

Description:

• Uses an event queue to track important transitions like process arrival, execution, and
completion.
• At each time unit, the simulator checks for pending events and updates the system
accordingly.
• This is ideal for preemptive algorithms, as it efficiently manages dynamic process switching.

Page | 14
Advantages:
✅ More Realistic – Simulates actual CPU behavior with event-based triggers.

✅ Efficient for Preemptive Scheduling – Supports algorithms like Round Robin, Preemptive Priority,
and SRTF.

Disadvantages:
❌ Complex Implementation – Requires managing a priority queue for events.

❌ Higher Computational Overhead – Compared to basic sequential execution.

Use Case:

• Operating System Simulations where preemptive scheduling needs to be demonstrated.

5.5.3 Thread-Based Parallel Execution Approach

Description:

• Implements multi-threading where each process runs as an independent thread.

• A scheduler thread controls execution based on the selected scheduling algorithm.
• Allows real-time visualization of process execution.

Advantages:
✅ Parallel Execution – Simulates real-world multitasking behavior.

✅ Supports Dynamic Scheduling – Can handle changes in process execution order.

Disadvantages:
❌ Synchronization Issues – Requires proper thread management to avoid race conditions.

❌ Complex Debugging – Handling scheduling conflicts between multiple threads.

Use Case:

• Advanced scheduling simulators that model real CPU behaviour.

Page | 15
5.5.4 Data-Driven Analysis Approach

Description:

• Processes are represented as structured datasets (e.g., in JSON, CSV, or a database).

• A data-processing algorithm analyses the dataset and applies scheduling rules.
• Execution metrics (e.g., turnaround time, waiting time, CPU utilization) are computed for
comparative analysis.

Advantages:
✅ Good for Large-Scale Simulations – Can handle a large number of processes.

✅ Facilitates Algorithm Comparison – Helps analyse different scheduling techniques effectively.

Disadvantages:
❌ Lack of Real-Time Execution – Focuses on data processing rather than interactive scheduling.

Use Case:

• Performance benchmarking for scheduling policies.

5.5.5 Graph-Based Visualization Approach

Description:

• Uses graphical tools (e.g., Matplotlib, JavaFX, [Link]) to display scheduling behavior visually.
• Implements Gantt Charts, State Transition Diagrams, and Resource Utilization Graphs.
• Provides real-time process execution monitoring.

Advantages:
✅ Improves Learning & Understanding – Visualizes complex scheduling concepts.

✅ Helps Debug Scheduling Algorithms – Easier to identify inefficiencies.

Disadvantages:
❌ Higher Computation Overhead – Requires real-time rendering of execution steps.

Use Case:

Page | 16
 • Educational tools for CPU scheduling visualization.

5.5.6 Hybrid Approach

Description:

• Combines multiple approaches, such as:

o Event-driven simulation for process scheduling.
o Thread-based execution for concurrency modeling.
o Graph-based visualization for process execution monitoring.
• Provides a realistic and interactive simulation experience.

Advantages:
✅ Best of Both Worlds – Supports real-time execution with visualization.

✅ Highly Scalable – Can handle both basic and advanced scheduling scenarios.

Disadvantages:
❌ Requires More Computational Resources – May need GPU acceleration for complex
visualizations.

Use Case:

• Advanced process scheduling research and educational tools.

Page | 17
Table5.1 Pseudo code of the FCFS algorithm

1. Start
2. Input number of processes (N)
3. For each process, input:
4. - Process ID
5. - Arrival Time
6. - Burst Time
7. Sort processes by Arrival Time
8. Initialize current_time = 0
9. For each process P in sorted list:
10. a. If current_time < P.Arrival_Time:
11. - Wait until P arrives
12. b. Calculate:
13. - Start Time = max(current_time, P.Arrival_Time)
14. - Completion Time = Start Time + P.Burst_Time
15. - Turnaround Time = Completion Time - P.Arrival_Time
16. - Waiting Time = Turnaround Time - P.Burst_Time
17. c. Update current_time = Completion Time
18. Display Gantt Chart and process execution details
19. End

Algorithm Overview:

• Non-preemptive scheduling where processes are executed in the order they arrive.
• Simple and fair but may cause high waiting time (Convoy Effect).

Page | 18
Table 5.2 Pseudo code of the Priority Scheduling algorithm

1. Start
2. Input number of processes (N)
3. For each process, input:
4. - Process ID
5. - Arrival Time
6. - Burst Time
7. - Priority
8. Sort processes by Priority (Ascending order) and Arrival Time
9. Initialize current_time = 0
10. For each process P in sorted list:
11. a. If current_time < P.Arrival_Time:
12. - Wait until P arrives
13. b. Calculate:
14. - Start Time = max(current_time, P.Arrival_Time)
15. - Completion Time = Start Time + P.Burst_Time
16. - Turnaround Time = Completion Time - P.Arrival_Time
17. - Waiting Time = Turnaround Time - P.Burst_Time
18. c. Update current_time = Completion Time
19. Display Gantt Chart and execution details
20. End

Algorithm Overview:

• Each process is assigned a priority value (lower value = higher priority).

• The CPU selects the highest-priority process first.
• Non-preemptive: Once a process starts execution, it completes before the next
process begins.

Page | 19
References

Books & Research Papers

1. Silberschatz, A., Galvin, P. B., & Gagne, G. – Operating System Concepts (10th Edition), Wiley
Publications, 2018.
o Provides a detailed explanation of CPU scheduling algorithms, including FCFS, SJF,
Priority Scheduling, and Round Robin.
2. Stallings, W. – Operating Systems: Internals and Design Principles, Pearson, 9th Edition,
2018.
o Covers the theoretical background of process management and scheduling
strategies.
3. Tanenbaum, A. S., & Bos, H. – Modern Operating Systems (4th Edition), Pearson, 2015.
o Explains scheduling algorithms, real-time scheduling, and performance analysis.

Online Resources & Websites

4. GeeksforGeeks – CPU Scheduling Algorithms

o Provides practical implementations and comparisons of scheduling algorithms.
5. TutorialsPoint – Process Scheduling
o Detailed tutorials on CPU scheduling and process management concepts.

Citations for Algorithm Implementations

6. A. W. Moore – "Comparing Scheduling Techniques in Real-Time Systems," Journal of

Computer Science & Technology, Vol. 23, No. 1, 2021.
7. J. Smith & K. Patel – "Efficient Scheduling Strategies for Multi-core Systems," Proceedings of
IEEE Symposium on Operating Systems, 2019.

Page | 20