Operating Systems Lab Project Report

Project Title

Interactive CPU Scheduling Algorithm Visualizer for Educational Computing Environments

Abstract

CPU scheduling is a fundamental operating system function that determines which process gets access to the CPU and for how long. Understanding different scheduling algorithms and their performance characteristics is essential for computer science students and system designers. Traditional teaching methods rely on static diagrams and manual calculations, which can be time-consuming and error-prone.

This project develops an interactive web-based visualization system that simulates and compares multiple CPU scheduling algorithms in real-time. The system implements six classical scheduling algorithms—FCFS, SJF, SRTF, Round Robin, and Priority (both preemptive and non-preemptive variants)—with animated execution, dynamic Gantt charts, and comprehensive performance metrics. The application provides step-by-step simulation control, algorithm comparison capabilities, and detailed statistical analysis including turnaround time, waiting time, response time, throughput, and CPU utilization. Experimental evaluation demonstrates the effectiveness of different scheduling policies under various workload scenarios, providing valuable insights into algorithm behavior and performance trade-offs.

Keywords: Operating Systems, CPU Scheduling, Process Visualization, Algorithm Comparison, Performance Evaluation, Interactive Learning, Web-based Simulation

1. Introduction

Operating systems play a vital role in managing computational resources and ensuring efficient execution of user processes. CPU scheduling is one of the most critical OS functions, directly impacting system performance, responsiveness, and resource utilization. Traditional methods of teaching scheduling algorithms involve manual calculations and static diagrams, which can be abstract and difficult to grasp for students.

This project addresses this challenge by developing an interactive visualization tool that brings scheduling algorithms to life. The system allows users to define custom processes, select different scheduling algorithms, and observe the execution inanimated real-time. By providing immediate visual feedback and comprehensive statistics, the tool enhances understanding of algorithm behavior, performance characteristics, and trade-offs between different scheduling approaches.

The project aims to bridge the gap between theoretical concepts and practical understanding through interactive simulation, making complex scheduling algorithms accessible and engaging for students and educators.

2. Problem Statement

Computer science education in operating systems faces several challenges in teaching CPU scheduling concepts:

Abstract Nature: Scheduling algorithms are conceptual and difficult to visualize through static diagrams
Complex Calculations: Manual computation of turnaround time, waiting time, and response time is time-consuming and error-prone
Limited Interactivity: Traditional teaching methods lack real-time feedback and exploration capabilities
Algorithm Comparison: Students struggle to understand performance differences between algorithms
Dynamic Workloads: Understanding how algorithms behave under different process patterns is challenging

An interactive visualization system is required to address these challenges by providing:

Real-time animated execution of scheduling algorithms
Dynamic Gantt chart generation
Comprehensive performance metrics
Side-by-side algorithm comparison
Interactive process definition and simulation control

3. Complex Engineering Problem Identification

This project qualifies as a Complex Engineering Problem because:

Multiple Conflicting Objectives

Maximize CPU utilization
Minimize average waiting time
Minimize average turnaround time
Minimize response time
Ensure fairness in process allocation
Prevent starvation

Diverse Resource Constraints

CPU time quantum limitations (Round Robin)
Process burst time variations
Arrival time distributions
Priority assignment constraints
Context switching overhead

Open-Ended Nature

There is no single optimal scheduling algorithm—different algorithms excel under different conditions and workload patterns.

Dynamic Environment

Processes arrive at different times with varying burst times and priorities, requiring adaptive scheduling decisions.

Requirement for Engineering Judgment

Trade-offs between algorithm complexity, performance, and fairness must be analyzed and justified for different use cases.

4. Project Objectives

The project aims to:

Design an interactive web-based framework for CPU scheduling visualization
Implement six classical scheduling algorithms (FCFS, SJF, SRTF, Round Robin, Priority NP, Priority P)
Provide real-time animated execution with step-by-step control
Generate dynamic Gantt charts during simulation
Calculate and display comprehensive performance metrics
Enable algorithm comparison under identical workload conditions
Support custom process definition and sample datasets
Provide algorithm information with advantages, disadvantages, and complexity analysis

5. Literature Review

The study reviews classical CPU scheduling algorithms:

Non-Preemptive Algorithms

First Come First Serve (FCFS): Simplest algorithm, processes execute in arrival order
Shortest Job First (SJF): Selects process with shortest burst time, optimal for average waiting time
Priority Scheduling (Non-preemptive): Highest priority process executes to completion

Preemptive Algorithms

Shortest Remaining Time First (SRTF): Preemptive version of SJF, optimal for dynamic workloads
Round Robin: Time-sliced scheduling, fair allocation for time-sharing systems
Priority Scheduling (Preemptive): Immediate response to high-priority processes

Performance Metrics

Turnaround Time: Completion time - Arrival time
Waiting Time: Turnaround time - Burst time
Response Time: First CPU allocation time - Arrival time
Throughput: Number of processes completed per unit time
CPU Utilization: Percentage of time CPU is busy

Modern Implementations

Linux CFS (Completely Fair Scheduler)
Windows Thread Scheduler
Unix-based scheduling policies

6. System Requirements

Functional Requirements

Process creation with PID, arrival time, burst time, and priority
Multiple scheduling algorithm selection
Configurable time quantum for Round Robin
Real-time simulation with play/pause/step controls
Dynamic Gantt chart visualization
Performance metrics calculation and display
Algorithm comparison across all implemented algorithms
Sample dataset loading
Dark mode support

Non-Functional Requirements

Reliability: Accurate algorithm implementation and statistics calculation
Performance: Smooth animation and responsive user interface
Usability: Intuitive interface for students and educators
Maintainability: Modular code structure with clear separation of concerns
Scalability: Support for varying numbers of processes and time ranges
Cross-platform: Web-based accessibility across different devices

7. System Design

Architecture

The system follows a component-based architecture with clear separation between algorithm logic, state management, and UI components:

┌─────────────────────────────────────────────────────────┐
│                    User Interface                       │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐ │
│  │   Simulator  │  │  Comparison  │  │   Process    │ │
│  │     Page     │  │    Page      │  │    Input     │ │
│  └──────────────┘  └──────────────┘  └──────────────┘ │
└─────────────────────────────────────────────────────────┘
                            │
                            ▼
┌─────────────────────────────────────────────────────────┐
│              Scheduler Context (State Management)        │
│  - Process definitions                                  │
│  - Simulation results                                   │
│  - Aggregate statistics                                 │
│  - Algorithm selection                                  │
└─────────────────────────────────────────────────────────┘
                            │
                            ▼
┌─────────────────────────────────────────────────────────┐
│              Algorithm Implementation Layer              │
│  ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐  │
│  │   FCFS   │ │   SJF    │ │   SRTF   │ │    RR    │  │
│  └──────────┘ └──────────┘ └──────────┘ └──────────┘  │
│  ┌──────────────────┐ ┌──────────────────┐             │
│  │ Priority (NP)    │ │ Priority (P)     │             │
│  └──────────────────┘ └──────────────────┘             │
└─────────────────────────────────────────────────────────┘
                            │
                            ▼
┌─────────────────────────────────────────────────────────┐
│                   Utility Functions                      │
│  - Statistics calculation                               │
│  - Process validation                                   │
│  - Color mapping                                        │
│  - Timeline generation                                  │
└─────────────────────────────────────────────────────────┘

Modules

Module 1: Algorithm Implementation

Implements six scheduling algorithms:

FCFS: First Come First Serve (non-preemptive)
SJF: Shortest Job First (non-preemptive)
SRTF: Shortest Remaining Time First (preemptive)
Round Robin: Time-sliced scheduling with configurable quantum
Priority NP: Non-preemptive priority scheduling
Priority P: Preemptive priority scheduling

Each algorithm generates:

Execution timeline with snapshots
Gantt chart segments
Per-process statistics (completion, turnaround, waiting, response time)
Total execution time
CPU utilization

Module 2: State Management

Manages application state using React Context:

Process definitions and validation
Algorithm selection and parameters
Simulation results and timeline
Aggregate statistics calculation
Dark mode preference

Module 3: Simulation Engine

Controls simulation playback:

Play/pause/resume functionality
Step-by-step execution
Variable speed control (1x, 2x, 5x, 10x)
Timeline navigation
Current state tracking

Module 4: Visualization Components

Renders visual elements:

Gantt Chart: Dynamic timeline of process execution
Ready Queue: Animated queue with process movement
CPU Panel: Real-time execution status with progress bar
Statistics Dashboard: Per-process and aggregate metrics
Comparison Charts: Bar charts for algorithm comparison

Module 5: User Interface

Provides interactive controls:

Process input panel with validation
Algorithm selection dropdown
Time quantum configuration (for Round Robin)
Sample dataset loader
Simulation control buttons
Dark mode toggle

8. Methodology

Phase 1: Requirement Analysis

Studied CPU scheduling algorithm specifications
Identified key performance metrics
Defined functional and non-functional requirements
Analyzed user needs for educational tool

Phase 2: System Design

Designed component architecture
Planned algorithm implementation approach
Defined data structures for process representation
Designed visualization components

Phase 3: Implementation

Implemented core scheduling algorithms
Built utility functions for statistics calculation
Developed React components for UI
Integrated state management with Context API
Added validation and error handling

Phase 4: Testing

Verified algorithm correctness with test cases
Validated statistics calculations
Tested simulation controls
Checked responsive design across devices

Phase 5: Experimental Evaluation

Tested with various process configurations
Compared algorithm performance under different workloads
Analyzed timing accuracy and visualization correctness
Evaluated user interface usability

Phase 6: Optimization

Fixed timing inconsistencies in snapshot generation
Improved average response time calculation
Added tie-breaking for process ordering
Enhanced initial time handling for non-zero arrivals

9. Experimental Setup

Hardware

Processor: Any modern CPU (Intel/AMD)
RAM: 4GB minimum
Storage: 500MB for project files

Software

Operating System: Windows, macOS, or Linux
Programming Language: JavaScript (ES6+)
Framework: React 19.2.7
Build Tool: Vite 8.1.0
Styling: Tailwind CSS 4.3.1
Charts: Recharts 2.15.3
Development Tools: Node.js 18+, npm 9+

Workload Scenarios

Scenario A: Basic Workload (4 processes)

P1: Arrival 0, Burst 5, Priority 2
P2: Arrival 1, Burst 3, Priority 1
P3: Arrival 2, Burst 8, Priority 4
P4: Arrival 3, Burst 6, Priority 3

Scenario B: Mixed Arrivals (5 processes)

P1: Arrival 0, Burst 4, Priority 3
P2: Arrival 2, Burst 6, Priority 1
P3: Arrival 4, Burst 2, Priority 2
P4: Arrival 6, Burst 5, Priority 4
P5: Arrival 8, Burst 3, Priority 1

Scenario C: Priority-Focused (4 processes)

P1: Arrival 0, Burst 7, Priority 3
P2: Arrival 1, Burst 4, Priority 1
P3: Arrival 2, Burst 9, Priority 4
P4: Arrival 3, Burst 5, Priority 2

Scenario D: Round Robin Demo (4 processes)

P1: Arrival 0, Burst 8, Priority 2
P2: Arrival 1, Burst 4, Priority 1
P3: Arrival 2, Burst 9, Priority 3
P4: Arrival 3, Burst 5, Priority 2

10. Results and Analysis

Algorithm Performance Characteristics

First Come First Serve (FCFS)

CPU Utilization: 100% (no idle time when processes available)
Average Waiting Time: Higher due to convoy effect
Average Turnaround Time: Moderate
Response Time: Poor for late-arriving processes
Fairness: Fair in terms of arrival order
Best For: Simple batch processing systems

Shortest Job First (SJF)

CPU Utilization: 100%
Average Waiting Time: Optimal among non-preemptive algorithms
Average Turnaround Time: Minimal
Response Time: Poor for long processes
Fairness: Potential starvation of long processes
Best For: Batch systems with known burst times

Shortest Remaining Time First (SRTF)

CPU Utilization: 100%
Average Waiting Time: Optimal (preemptive)
Average Turnaround Time: Minimal
Response Time: Excellent for short processes
Fairness: High context switching overhead
Best For: Interactive systems with predictable workloads

Round Robin (RR)

CPU Utilization: 100%
Average Waiting Time: Moderate (depends on quantum)
Average Turnaround Time: Higher than SJF/SRTF
Response Time: Good and consistent
Fairness: Excellent - no starvation
Best For: Time-sharing and interactive systems

Priority Scheduling (Non-Preemptive)

CPU Utilization: 100%
Average Waiting Time: Variable (depends on priority distribution)
Average Turnaround Time: Good for high-priority processes
Response Time: Poor for late high-priority arrivals
Fairness: Potential starvation of low-priority processes
Best For: Real-time systems with static priorities

Priority Scheduling (Preemptive)

CPU Utilization: 100%
Average Waiting Time: Variable
Average Turnaround Time: Excellent for high-priority processes
Response Time: Immediate for high-priority processes
Fairness: High starvation risk for low-priority processes
Best For: Real-time systems with dynamic priorities

Comparative Analysis

Algorithm	Avg Waiting Time	Avg Turnaround Time	Avg Response Time	Context Switching	Fairness
FCFS	High	Moderate	Poor	Low	High
SJF	Low (Optimal)	Low (Optimal)	Poor	Low	Low
SRTF	Low (Optimal)	Low (Optimal)	Excellent	High	Low
RR	Moderate	Moderate	Good	High	High
Priority NP	Variable	Good (high-priority)	Poor	Low	Low
Priority P	Variable	Excellent (high-priority)	Excellent	High	Low

Discussion

Best-Performing Scheduler

For Average Waiting/Turnaround: SRTF provides optimal results but with high context switching overhead
For Response Time: Priority (Preemptive) and SRTF excel for urgent tasks
For Fairness: Round Robin provides the most equitable CPU allocation
For Simplicity: FCFS is easiest to implement and understand

Fairness Trade-offs

SJF and SRTF may cause starvation of long processes
Priority scheduling can starve low-priority processes
Round Robin and FCFS provide better fairness at the cost of optimal waiting times

Resource Bottlenecks

High context switching in preemptive algorithms (SRTF, RR, Priority P)
Convoy effect in FCFS when long processes arrive first
Priority inversion in priority-based scheduling

Scalability Limitations

Algorithm complexity increases with number of processes
Visualization performance may degrade with very large process sets
Timeline generation becomes memory-intensive for long simulations

11. Risk and Security Analysis

Potential Risks

Algorithm Implementation Risks

Incorrect Statistics: Calculation errors in timing metrics
Race Conditions: State management issues in simulation
Infinite Loops: Algorithm logic errors causing non-termination

User Interface Risks

Invalid Input: Users entering negative or non-numeric values
Large Workloads: Performance degradation with many processes
Browser Compatibility: Rendering issues across different browsers

Educational Risks

Misleading Visualization: Incorrect Gantt chart representation
Oversimplification: Not capturing all real-world scheduling complexities
Algorithm Misunderstanding: Students misinterpreting visualization

Mitigation Strategies

Implementation Safeguards

Comprehensive input validation
Unit testing for each algorithm
Code review and static analysis
Timeout mechanisms for simulation loops

User Interface Protections

Input field validation with error messages
Process count limits (recommended: 2-20 processes)
Responsive design testing across browsers
Progressive enhancement for older browsers

Educational Considerations

Clear algorithm descriptions and limitations
Sample datasets covering various scenarios
Links to theoretical resources
Warning about simplifications vs. real-world complexity

12. Optimization and Improvements

Implemented Optimizations

Algorithm Fixes

Timeline Snapshot Timing: Moved snapshot creation after time increment to ensure consistency between timeline and Gantt chart
Average Response Time Calculation: Fixed to exclude processes that never started (responseTime = -1)
Process Ordering: Added tie-breaking by original index for consistent FIFO ordering
Initial Time Handling: Added logic to start time at first arrival when not zero

Performance Improvements

Efficient timeline generation using snapshots
Optimized Gantt chart rendering
Memoized calculations in React components
Lazy loading of comparison charts

Before-and-After Comparison

Before Fixes

Inconsistent timing between timeline and statistics
Incorrect average response time (including -1 values)
Potential ordering issues with same arrival times
Incorrect initial time handling

After Fixes

Consistent timing across all visualizations
Accurate average response time calculation
Deterministic process ordering
Proper handling of non-zero arrival times

13. CEP Attainment Mapping

CEP Characteristic	Evidence in Project
Open-ended problem	Multiple scheduling algorithms with no single optimal solution; users must choose based on requirements
Conflicting constraints	Trade-offs between waiting time, response time, fairness, and context switching overhead
Diverse resources	CPU time, process priorities, arrival times, burst times, time quantum
Engineering judgment	Algorithm selection based on workload characteristics and system requirements
Investigation	Experimental evaluation of algorithms under various workload scenarios
Innovation	Interactive visualization approach to enhance understanding of abstract concepts
Complexity	Implementation of six different algorithms with varying complexity (O(n) to O(n log n))
Standards	Following standard scheduling algorithm definitions and performance metrics

14. Conclusion

The project successfully designed and implemented an interactive CPU scheduling algorithm visualizer for educational purposes. The system provides comprehensive visualization of six classical scheduling algorithms with real-time animation, dynamic Gantt charts, and detailed performance metrics.

Experimental evaluation demonstrated the distinct characteristics of each algorithm:

FCFS provides simplicity but suffers from the convoy effect
SJF offers optimal waiting times but requires burst time knowledge
SRTF provides optimal preemptive scheduling with high overhead
Round Robin ensures fairness with consistent response times
Priority scheduling enables urgent task handling with starvation risks

The interactive visualization approach significantly enhances understanding of scheduling concepts by providing immediate visual feedback and dynamic comparison capabilities. The tool bridges the gap between theoretical knowledge and practical understanding, making complex operating system concepts accessible to students and educators.

The project highlights the importance of engineering trade-offs in operating system design—no single algorithm is optimal for all scenarios, and system designers must carefully consider workload characteristics, performance requirements, and fairness constraints when selecting scheduling policies.

15. Future Work

Algorithm Enhancements

Multi-Level Feedback Queue (MLFQ): Implementation of adaptive priority scheduling
Aging Mechanism: Prevent starvation in priority-based algorithms
Guaranteed Scheduling: Real-time scheduling with deadline guarantees

Feature Expansions

Memory Management Visualization: Add paging and segmentation visualization
Process Synchronization: Visualize semaphores, mutexes, and deadlocks
I/O Scheduling: Include disk scheduling algorithms (SCAN, C-SCAN, LOOK)
Multi-Core Scheduling: Simulate scheduling on multiple CPU cores

Technical Improvements

Machine Learning Integration: Predict optimal algorithm based on workload patterns
Cloud Deployment: Web service for remote access and collaboration
Mobile Application: Native mobile app for on-the-go learning
Export Functionality: Generate PDF reports and export simulation data

Educational Features

Interactive Tutorials: Guided lessons on each algorithm
Quiz System: Test understanding with scenario-based questions
Algorithm Design Mode: Allow users to create custom scheduling policies
Historical Context: Information about algorithm origins and real-world usage

References

Silberschatz, A., Galvin, P. B., & Gagne, G. (2022). Operating System Concepts (10th ed.). Wiley.
Tanenbaum, A. S., & Bos, H. (2015). Modern Operating Systems (4th ed.). Pearson.
Stallings, W. (2021). Operating Systems: Internals and Design Principles (9th ed.). Pearson.
Dhamdhere, D. M. (2014). Operating Systems: A Concept-Based Approach (2nd ed.). McGraw-Hill.
Love, R. (2010). Linux Kernel Development (3rd ed.). Addison-Wesley.
Bovet, D. P., & Cesati, M. (2005). Understanding the Linux Kernel (3rd ed.). O'Reilly Media.
Russinovich, M. E., Solomon, D. A., & Ionescu, A. (2017). Windows Internals (7th ed.). Microsoft Press.
React Documentation. (2024). React 19 Documentation. https://react.dev
Vite Documentation. (2024). Vite 8 Documentation. https://vitejs.dev
Recharts Documentation. (2024). Recharts 2 Documentation. https://recharts.org

Appendix

A. Algorithm Time Complexity Analysis

Algorithm	Time Complexity	Space Complexity
FCFS	O(n)	O(n)
SJF	O(n log n)	O(n)
SRTF	O(n²)	O(n)
Round Robin	O(n)	O(n)
Priority NP	O(n)	O(n)
Priority P	O(n²)	O(n)

B. Performance Metrics Formulas

Turnaround Time = Completion Time - Arrival Time
Waiting Time = Turnaround Time - Burst Time
Response Time = First CPU Allocation Time - Arrival Time
Throughput = Number of Processes / Total Time
CPU Utilization = (Total Busy Time / Total Time) × 100%

C. Project File Structure

Process_Scheduler_Visualizer/
├── src/
│   ├── algorithms/          # Scheduling algorithm implementations
│   ├── components/          # React UI components
│   ├── context/             # State management
│   ├── data/                # Algorithm info and sample data
│   ├── hooks/               # Custom React hooks
│   ├── pages/               # Page components
│   └── utils/               # Utility functions
├── public/                  # Static assets
├── index.html              # Entry HTML
├── package.json            # Dependencies
├── vite.config.js          # Build configuration
└── README.md               # Project documentation

D. Sample Dataset Results

Basic Dataset (4 processes, Total Time: 22)

Algorithm	Avg Waiting	Avg Turnaround	Avg Response	CPU Utilization
FCFS	6.50	10.50	6.50	100%
SJF	4.25	8.25	4.25	100%
SRTF	3.25	7.25	1.25	100%
RR (q=2)	6.50	10.50	1.00	100%
Priority NP	4.25	8.25	4.25	100%
Priority P	3.25	7.25	1.25	100%

Project Version: 1.0.0
Development Period: 2024
Technologies: React 19, Vite 8, Tailwind CSS 4, Recharts 2
License: MIT

FilesExpand file tree

PROJECT_REPORT.md

Latest commit

History