CPU scheduling algorithms simulator

Introduction

The CPU scheduling algorithms simulator is a project that simulates different CPU scheduling algorithms using Python.
The project includes a Graphical User Interface (GUI) that allows the user to select the algorithm, view the results on
the screen, and visualize the results in a chart. The project uses four different algorithms: First Come, First Served (
FCFS), Shortest Job First (SJF), Round Robin (RR), and Priority.

Directory Structure

The project has four directories, each containing a Python file that implements a specific algorithm. The directories
are:

• First-Come-First-Serve-scheduling
• Priority-Scheduling
• Round-Robin-scheduling
• Shortest-Job-First-scheduling

Each of these directories contains a README file that explains the algorithm and how it is implemented.

Files

The project has three main Python files:

main.py

This file is the entry point to the simulation. It imports the algorithms from the corresponding directories and reads
the process data from a CSV file. Then, it calls the simulation function for each algorithm and prints the results on
the screen.

main_ui.py

This file contains the implementation of the GUI interface using the tkinter library. The user can select the algorithm
to simulate from the buttons on the home page. The GUI then displays the results on the screen, and the user can
visualize the results in a chart.

process_generator.py

This file contains a function to generate a CSV file containing the process data for the simulation. The user can specify
the number of processes to generate, and the function will generate random values for the arrival time, priority, and
burst time of each process.

Algorithms

First Come, First Served (FCFS)

The FCFS algorithm is a non-preemptive algorithm where the processes are executed in the order they arrive in the ready
queue. The process with the lowest arrival time is executed first, and the CPU is not released until the process
completes. This algorithm is simple and easy to implement, but it suffers from the problem of convoy effect, where a
long process can hold the CPU, causing other short processes to wait.

Shortest Job First (SJF)

The SJF algorithm is a non-preemptive algorithm where the processes are executed in order of their burst time. The
process with the shortest burst time is executed first, and the CPU is not released until the process completes. This
algorithm reduces the waiting time and turnaround time of the processes, but it suffers from the problem of starvation,
where a long process can keep waiting for the CPU if shorter processes keep arriving.

Round Robin (RR)

The RR algorithm is a preemptive algorithm where each process is executed for a fixed time slice. When the time slice
expires, the CPU is released, and the next process in the ready queue is executed. This algorithm ensures that every
process gets a fair share of the CPU, but it suffers from the problem of high context switching overhead, which can
reduce the overall performance of the system.

Priority Scheduling

The priority scheduling algorithm is a non-preemptive algorithm where each process is assigned a priority, and the
process with the highest priority is executed first. If two processes have the same priority, then the FCFS algorithm is
used to break the tie. This algorithm ensures that high-priority processes are executed first, but it suffers from the
problem of starvation, where low-priority processes may have to wait indefinitely if high-priority processes keep
arriving.

GUI Interface

The GUI interface is implemented in the main_ui.py file using the tkinter library. The interface has two main pages:
the home page and the results page.

Home Page

The home page contains buttons for each algorithm, and the user can select the algorithm to simulate by clicking the
corresponding button. The home page also has a button to exit the application.

Results Page

The results page displays the results of the simulation on the screen. The page shows the average waiting time, average
turnaround time, and average response time for the selected algorithm. The results page also has a button to visualize
the results in a chart and a back button to return to the home page.

Chart Page

The chart page displays a chart that visualizes the results of the simulation. The chart shows the waiting time,
turnaround time, and response time for each process. The chart page has a back button to return to the results page.

How to use

To use the project, follow these steps:

1. Clone the repository to your local machine.
2. Open a terminal and navigate to the project directory.
3. Run the process_generator.py file to generate the process data CSV file. Specify the number of processes to
   generate when prompted.
4. Run the main_ui.py file to open the GUI interface.
5. Select the algorithm to simulate from the buttons on the home page.
6. View the results on the screen. The results page displays the average waiting time, average turnaround time, and
   average response time for the selected algorithm.
7. Click the "Chart" button to visualize the results in a chart. The chart page displays a chart that shows the waiting
   time, turnaround time, and response time for each process.
8. Click the "Back" button to return to the results page and view the results for another algorithm.
9. Click the "Exit" button on the home page to exit the application.

Note: Make sure you have the required Python packages installed, such as pandas and matplotlib. You can install them
using pip. Also, the project assumes that the process data is stored in a CSV file with the following columns: "Process
ID", "Arrival Time", "Priority", and "Burst Time". If your data is stored in a different format, you will need to modify
the code accordingly.