This project is a comprehensive CPU Scheduling Algorithms Visualizer and Simulator. It is built to help students and professionals understand how different CPU scheduling algorithms work and how they affect process execution over time.
- Takes user input via a web frontend for process details: Arrival Time, Burst Time, and Priority (optional).
- Simulates scheduling using various classic algorithms.
- Displays:
- 🟦 Gantt Chart: Shows when each process runs, with distinct colors per process.
- 🟩 Ready Queue: Shows the set of waiting processes at each time unit.
- 🟨 Process Table: Displays Turnaround Time (TAT), Waiting Time (WT), Response Time (RT), and Normalized TAT.
Each process is shown in a different color, making it easier to visualize execution order, idle times, and preemption (if applicable).
Below are the 10 CPU scheduling algorithms implemented in this project, along with their behavior and use cases:
- Type: Non-Preemptive
- Working: Processes are scheduled in the order they arrive.
- Advantage: Simple and easy to implement.
- Disadvantage: Long jobs can delay shorter ones (convoy effect).
- Use Case: Suitable for batch processing systems.
- Type: Preemptive
- Working: Each process gets a fixed time slice (quantum). After using its time, it goes to the back of the ready queue.
- Advantage: Fair CPU allocation among all processes.
- Disadvantage: Too large a quantum leads to FCFS-like behavior; too small leads to high context switching.
- Use Case: Ideal for time-sharing operating systems.
- Type: Non-Preemptive
- Working: Runs the process with the shortest burst time among ready processes.
- Advantage: Minimizes average waiting time.
- Disadvantage: Risk of starvation for longer processes.
- Use Case: Systems where burst time is known in advance.
- Type: Preemptive
- Working: Runs the process with the least remaining execution time.
- Advantage: Reduces average waiting time compared to SPN.
- Disadvantage: Frequent preemptions and possible starvation of long jobs.
- Use Case: Real-time or highly responsive systems.
- Type: Non-Preemptive
- Working: Selects process with highest response ratio: [ \text{Response Ratio} = \frac{\text{Waiting Time} + \text{Burst Time}}{\text{Burst Time}} ]
- Advantage: Balances fairness and efficiency. Prevents starvation.
- Disadvantage: Requires calculating response ratio for all ready processes.
- Use Case: Balanced scheduling in production or job queues.
- Type: Preemptive, Multi-level Queues
- Working: Processes start at high priority. If they don’t finish, they are demoted to lower queues.
- Advantage: Dynamic priority adjustment improves responsiveness.
- Disadvantage: Longer jobs may be delayed repeatedly.
- Use Case: Mixed workloads with both short and long processes.
- Type: Preemptive, Multi-level Queues
- Working: Similar to FB but each queue has increasing time quantum (e.g., 1, 2, 4...).
- Advantage: Short jobs finish quickly; long jobs gradually get more CPU time.
- Disadvantage: May still cause starvation without proper tuning.
- Use Case: Interactive systems where adaptive scheduling is critical.
- Type: Priority-based with dynamic updates
- Working: Waiting processes have their priority increased gradually to avoid starvation.
- Advantage: Ensures even low-priority jobs eventually get executed.
- Disadvantage: Adds overhead of managing dynamic priorities.
- Use Case: Real-time systems where fairness is critical.
- Type: Non-Preemptive
- Working: Runs the process with the highest priority (lowest number if lower = higher).
- Advantage: High-priority tasks are serviced first.
- Disadvantage: Starvation possible for lower-priority processes.
- Use Case: Embedded systems or fixed-priority environments.
- Type: Preemptive
- Working: Like non-preemptive, but will interrupt running process if a higher-priority one arrives.
- Advantage: High-priority tasks get immediate attention.
- Disadvantage: More context switching; starvation risk remains.
- Use Case: Real-time operating systems with strict priority rules.
🛠️ Selection Tips:
Each of these algorithms can be tested and visualized using the provided web interface or through command-line input. You can choose by ID (e.g., 1 for FCFS, 2-4 for RR with quantum 4, etc.) and see how they perform in terms of:
- Turnaround Time (TAT)
- Waiting Time (WT)
- Response Time (RT)
- Normalized TAT
Use the simulator to compare performance and understand trade-offs for different scheduling strategies.
📦CPU-Scheduling-Algorithms/
├── main.cpp # Core simulator in C++
├── server.py # Flask backend to run simulation
├── scheduler.html # Frontend UI
├── scheduler.js # Frontend logic
├── style.css # Visual styles for frontend
├── makefile # For compiling C++ code
├── input.txt # Optional input file for testing
├── result # Compiled binary after build
└── testcases/ # Input/output test samples
In frontend or in web‑UI we will give input like:
- Scheduling algorithm
- No. of Processes
- Arrival times
- Burst times
- Priority values (if applicable)
- Time quantum (for RR)
- Mode: TRACE (visual) or STATS (table)
👉 Input UI is shown below .
After filling all necessary details, you will see output like:
- Gantt Chart
• Time‑unit timeline showing which process ran at each tick
• Each process has a distinct color for easy visual tracking
• Idle slots are marked clearly
- Ready Queue (per time unit)
• Snapshot of processes waiting at each tick
• Helps verify preemption and queue order
- Process Table
• Columns: PID | Arrival | Burst | Priority | Finish | TAT | WT | RT | Norm TAT
• Values auto‑computed from the simulation
- Averages
• TAT_avg, WT_avg, RT_avg, NormTAT_avg
- Timeline Length
• last_instant (effective simulated time based on actual execution)
👉 An example output is shown below .
