Name: Harshit Singh

Registration: 12411385
Section: K24IT
Roll no: 12
Course code: CSE 316

Advance Disk Scheduling

Simulator
Project Report

1. Project Overview
1.1 Project Title
Advance Disk Scheduling Simulator

1.2 Objective
This project aims to build an interactive disk-scheduling simulator that lets users input custom disk I/O request
sequences and visually compare how different scheduling algorithms (FCFS, SSTF, SCAN, C-SCAN) service those
requests. The simulator should demonstrate how each algorithm affects head movement and quantify performance so
users can see which algorithms minimize seek time under different workloads.
.

1.3 Target Users

Operating Systems students and learners
Computer Science professionals
Educational institutions
System designers and developers
 1.4 Key Features
Multi-Algorithm Support: Visualize 4 major scheduling algorithms
Algorithm Comparison Dashboard: Compare performance metrics across all algorithms
Real-time Animation : Animated process execution with timing
Interactive Process Management: Add, modify, and delete processes
Educational Panel: Detailed information about each algorithm
Visual Analytics : Gantt charts, bar charts, and line graphs
Dark Theme UI: Modern, sleek gradient interface
Horizontal Scrolling Results: Comprehensive result visualization

2. Module-Wise Breakdown
Module 1: Core Scheduling Engine
Responsibility: Algorithm Implementation and Calculation

FCFS Scheduling Algorithm

SJF (Shortest Job First) Scheduling
Priority-Based Scheduling
Round Robin Scheduling with Quantum
Metrics Calculation (Waiting Time, Turnaround Time, Response Time)

Files: scheduling_calculator.dart, process_model.dart, algorithm_type.dart

Module 2: User Interface & Input Management

Responsibility: Process and Algorithm Selection Interface

Algorithm Selector Widget

Process Input Table
Quantum Input for Round Robin
Dynamic Process Addition/Deletion
Real-time Input Validation

Files: algorithm_selector.dart, process_table.dart, quantum_input.dart

Module 3: Result Visualization & Display

Responsibility: Comprehensive Result Presentation

Result Display with Progress Animation

Gantt Chart Visualization
Bar Chart Analysis
Line Chart Trends
CPU Scheduling Table with Metrics
Files: result_display.dart, gantt_chart_widget.dart, bar_chart_widget.dart,

line_chart_widget.dart, cpu_scheduling_table.dart

Module 4: Advanced Analytics

Responsibility: Comparison and Educational Content

Algorithm Comparison Dashboard

Performance Metrics Ranking
Educational Information Panel
Algorithm Recommendations

Files: algorithm_comparison_dashboard.dart, educational_info_panel.dart

Module 5: Main Application & State Management

Responsibility: Core Application Logic and Navigation

Home Page with Gradient Background

State Management for Process and Results
Multi-button Interface
Horizontal Scrolling for Results
Animation Control and Timing

Files: home_page.dart, [Link]

3. Functionalities
3.1 Core Functionalities
3.1.1 Process Management
Add Process: Users can dynamically add new processes with custom arrival time, burst time, and priority
Delete Process: Remove unwanted processes from the scheduling queue
Modify Processes: Edit process parameters in real-time
Default Processes: Pre-populated with sample processes for quick testing

3.1.2 Algorithm Scheduling

FCFS: Execute processes in arrival order
SJF: Execute shortest burst time process first
Priority Scheduling: Execute based on priority values
Round Robin: Execute with fixed time quantum
 3.1.3 Result Visualization
Gantt Chart: Timeline visualization of process execution
Timeline Table: Detailed process execution with time blocks
Progress Animation: Real-time progress bar with timer
Horizontal Scrolling: Easy navigation through multiple results sections

3.1.4 Performance Analysis

Metrics Calculation: Completion Time, Turnaround Time, Waiting Time, Response Time
Average Metrics: Calculate and display average times for all processes
Bar Chart: Visual representation of process metrics
Line Chart: Trend analysis of scheduling performance
CPU Scheduling Table: Comprehensive data table with all metrics

3.1.5 Algorithm Comparison

Compare All Algorithms: Run all 4 algorithms simultaneously
Performance Ranking: Rank algorithms based on average waiting time
Detailed Comparison Table: Side-by-side metrics comparison
Winner Badge: Highlight the best-performing algorithm
Recommendations: Smart suggestions based on workload analysis

3.1.6 Educational Support

Algorithm Information: Detailed explanation for each algorithm
Pros and Cons: Advantages and disadvantages listing
Use Cases: Real-world applications and scenarios
Time Complexity: Big O notation for each algorithm
Metrics Explanation: Detailed guide for understanding metrics

4. Technology Used
4.1 Programming Languages
Dart: Primary programming language for Flutter
Version: Dart 3.0+

4.2 Libraries and Tools

Flutter Packages
flutter: Core Flutter framework
flutter/[Link]: Material Design
components flutter/[Link]: System
services for input handling
fl_chart: Advanced charting library for graphs
 Bar charts for metric visualization
Custom chart widgets
Interactive chart features

State Management
StatefulWidget: For local state management
setState(): UI update mechanism

Data Processing
Built-in Collections: List, Map, Set for data structures
Custom Models: Process, ResultBlock, AlgorithmResult classes

Development Tools
Flutter SDK: Complete Flutter development kit
Dart Analysis: Code quality and error checking
DevTools: Flutter debugging and profiling

4.3 Other Tools

Version Control
GitHub: Repository management and version tracking
Repository Name: cpu-scheduling-algorithim-visualizer
GitHub Link: [Link]

Development Environment
VS Code: Code editor
Android Studio: Android emulation
Chrome DevTools: Web debugging

Documentation
Markdown: For documentation
PDF: For report generation

Visualization
Gantt Chart Library: Custom implementation for process timeline
FL Chart: For statistical charts

5. Flow Diagram
5.1 Application Flow
┌─────────────────────────────────────────────────────────────────┐ │
START APPLICATION │
└────────────────────────┬────────────────────────────────────────┘
│
▼
┌────────────────────────────────────┐
│ Load Home Page with Gradient │
│ Background (Pink-Purple) │
└────────────┬───────────────────────┘
│
▼
┌────────────────────────────────────┐
│ Display Algorithm Selector │
│ - FCFS │
│ - SJF │
│ - Priority │
│ - Round Robin │
└────────────┬───────────────────────┘
│
▼
┌────────────────────────────────────┐
│ Input Process Table │
│ - Add/Delete Processes │
│ - Set Arrival Time │
│ - Set Burst Time │
│ - Set Priority (if applicable) │
└────────────┬───────────────────────┘
│
┌────────┴────────┐
│ │
▼ ▼
[Go Button] [Compare All Button]
│ │
│ ▼
│ ┌──────────────────┐
│ │ Run all 4 algos │
│ │ Calculate metrics│
│ └────────┬─────────┘
│ │
│ ▼
│ ┌──────────────────────────┐
│ │ Show Comparison Dashboard│
│ │ - Winner Badge │
 │ │ - Ranking Table │
│ │ - Recommendation │
│ └──────────────────────────┘
│
▼
┌──────────────────────┐
│ Run Selected Algorithm│
│ Calculate Metrics │
│ Generate Result Blocks
└──────────┬───────────┘
│
▼
┌──────────────────────────────┐
│ Show Results (Horizontal Scroll)
│ ┌─────────────────────────────┤
│ │ Section 1: CPU Table │
│ │ Section 2: Gantt + Results │
│ │ Section 3: Bar Chart │
│ │ Section 4: Line Chart │
│ └─────────────────────────────┤
│ - Animation Progress │
│ - Timer Display │
└──────────┬────────────────────┘
│
▼
┌──────────────────────────────┐
│ User Options │
│ - Learn About Algorithms │
│ - Compare All │
│ - Modify Processes │
│ - Run Again │
└──────────┬────────────────────┘
│
▼
┌──────────────────────────────┐
│ Educational Panel │
│ (Modal Bottom Sheet) │
│ - Algorithm Details │
│ - Pros/Cons │
│ - Use Cases │
│ - Time Complexity │
│ - Metrics Explanation │
└──────────────────────────────┘
 5.2 Data Flow Diagram
USER INPUT (Processes)
↓
ALGORITHM SELECTION
↓
├─→ FCFS Engine
├─→ SJF Engine
├─→ Priority Engine
└─→ Round Robin Engine
↓
SCHEDULING CALCULATOR
├─ Generate Result Blocks
├─ Calculate Waiting Time
├─ Calculate Turnaround Time
└─ Calculate Response Time
↓
RESULT BLOCKS + METRICS
↓
├─→ Gantt Chart Generator
├─→ Result Display Module
├─→ Bar Chart Generator
└─→ Line Chart Generator
↓
VISUALIZATION MODULES
├─ Animated Progress Bar
├─ Tabular Results
├─ Timeline Visualization
└─ Statistical Charts
↓
USER INTERFACE OUTPUT

6. Revision Tracking on GitHub

6.1 Repository Information
Repository Name: cpu-scheduling-algorithim-visualizer
GitHub Link: [Link]
Platform: GitHub Version Control: Git

6.2 Commit History

Commit ID Date Description
Initial Oct 2024 Project initialization with basic structure
v1.0 Oct 2024 FCFS algorithm implementation
v1.1 Oct 2024 SJF and Priority scheduling added
v1.2 Oct 2024 Round Robin implementation
v2.0 Oct 2024 UI redesign with gradient background
v2.1 Oct 2024 Gantt chart and visualization
v2.2 Oct 2024 Bar and line charts integration
v2.3 Oct 2024 Algorithm comparison dashboard
v2.4 Oct 2024 Educational info panel
v2.5 Nov 2024 Horizontal scrolling results
v3.0 Nov 2024 Bug fixes and UI improvements
6.3 Key Branches
main: Production-ready code develop:
Development branch with latest features
feature/algorithms: Algorithm
implementations
feature/visualization: UI and visualization features

6.4 Contribution Guidelines

Fork the repository
Create feature branch: git checkout -b feature/your-feature
Commit changes: git commit -am 'Add feature'
Push to branch: git push origin feature/your-feature
Submit pull request

7. Conclusion and Future Scope

7.1 Conclusion
The CPU Scheduling Algorithms Visualizer successfully demonstrates a comprehensive understanding of operating
system concepts, particularly CPU scheduling. The application provides:

Educational Value: Clear visualization of how different scheduling algorithms work

Interactive Learning: Users can experiment with different scenarios and immediately see results
Professional UI: Beautiful dark-themed interface with gradient backgrounds and smooth animations
Comprehensive Analysis: Multiple visualization types (Gantt charts, bar charts, line charts) provide
different perspectives on the same data

Algorithm Comparison: The comparison dashboard enables users to make informed decisions about algorithm

selection based on workload characteristics

The project successfully bridges the gap between theoretical OS concepts and practical implementation, making it an
excellent tool for students, educators, and professionals in the field of operating systems.
 7.2 Achievements
All 4 major scheduling algorithms implemented Real-time animation and visualization Algorithm comparison
functionality Educational information panels Professional UI with dark theme Responsive design with horizontal
scrolling Comprehensive metrics calculation Interactive process management

7.3 Future Scope

Short-term Enhancements (1-2 months)
1. Memory Management Visualizer

First Fit, Best Fit, Worst Fit algorithms

Visual memory block representation
Fragmentation analysis

2. Page Replacement Algorithms

FIFO, LRU, Optimal algorithms

Page fault visualization
Hit/Miss ratio calculation

3. Advanced Scheduling Features

Multilevel Queue Scheduling

Shortest Remaining Time First (SRTF)
Aging mechanism for starvation prevention

Medium-term Enhancements (3-6 months)

4. Disk Scheduling Visualization

SSTF, SCAN, C-SCAN algorithms

Animated disk head movement
Seek time visualization

5. Synchronization Problems

Producer-Consumer problem
Readers-Writers problem
Dining Philosophers animation
6. Export & Reporting

PDF report generation

CSV data export
Share results via QR code
 Long-term Enhancements (6-12 months)
7. File System Simulator

Directory structure visualization

File allocation methods
Inode representation

8. Process State Diagram

Interactive state transitions

Context switching visualization
Queue management display

9. Mobile Optimization

Responsive design improvements

Touch-friendly controls
Mobile-specific features

10. Multiplayer/Collaborative Features

Real-time collaboration
Shared experiment scenarios
Performance comparison

8. References
8.1 Academic References
[1] Silberschatz, A., Galvin, P. B., & Gagne, G. (2018). Operating System Concepts (10th ed.). John Wiley & Sons.

[2] Tanenbaum, A. S., & Bos, H. (2014). Modern Operating Systems (4th ed.). Pearson.

[3] Stallings, W. (2018). Operating Systems: Internals and Design Principles (9th ed.). Pearson.

8.2 Technology References

[4] Google Flutter Team. (2024). "Flutter Documentation." Available: [Link] ([Link]

[5] Dart Foundation. (2024). "Dart Language Documentation." Available: [Link] ([Link]

[6] "FL Chart - Flutter Charting Library." Available: [Link] ([Link]

8.3 Algorithm References

[7] Coffman, E. G., & Denning, P. J. (1973). Operating Systems Theory. Prentice Hall.

[8] Hoare, C. A. R. (1974). "Monitors: An Operating System Structuring Concept." Communications of the ACM, 17(10),
 549-557.

[9] Lamport, L. (1974). "A New Solution of Dijkstra's Concurrent Programming Problem." Communications of the ACM,
17(8), 453-455.

8.4 Online Resources

[10] GeeksforGeeks. "CPU Scheduling in Operating Systems." Available: [Link]
in-operating-systems/ ([Link]

[11] TutorialsPoint. "Operating System - Process Scheduling." Available:

[Link]
([Link]

[12] JavaPoint. "Operating System Scheduling." Available: [Link]

([Link]

Appendix
Appendix A: AI-Generated Project Elaboration/Breakdown
The CPU Scheduling Algorithms Visualizer is a rehensive Flutter-based application designed to
provide an interactive learning platform for understanding operating system scheduling concepts.
The project is structured into five core modules: the Scheduling Engine implements FCFS, SJF,
Priority, and Round Robin algorithms with complete metrics calculation (waiting time, turnaround
time, response time); the Input Management Module provides an intuitive interface for process
creation, modification, and algorithm selection with real-time validation; the Visualization
Module delivers rich graphical representations through Gantt charts, bar charts, and line charts,
enhanced with animated progress tracking; the Analytics Module features a unique algorithm
comparison dashboard that simultaneously executes all algorithms and ranks them based on
performance metrics while providing intelligent recommendations; and the UI/UX
Module implements a modern dark-themed gradient interface (pink-to-purple) with horizontal
scrolling results and responsive design. The application employs Flutter's StatefulWidget for state
management, FL Chart library for statistical visualizations, and custom-built components for process
timeline rendering. Key architectural decisions include modular widget composition for reusability,
separation of business logic (scheduling calculations) from presentation logic (UI components), and
data-driven chart generation using the fl_chart package. The application calculates comprehensive
metrics including completion time, turnaround time, waiting time, and response time for each
process, displays average metrics across all processes, and provides educational content explaining
algorithm mechanics, advantages, disadvantages, use cases, and time complexity. The project
demonstrates proficiency in Flutter development, object-oriented design patterns, algorithm
implementation, data visualization, and user experience design, making it an excellent educational
tool for operating systems courses and a practical demonstration of mobile application development
skills.
 Appendix B: Problem Statement
Problem Statement:

Operating System scheduling algorithms are complex concepts that are difficult
for students to understand through traditional lecture methods. There is a need
for an interactive, visual tool that can:

1. Demonstrate how different CPU scheduling algorithms work in real-time

2. Allow users to input custom processes and see how they are scheduled
3. Compare the performance of different algorithms on the same workload
4. Provide educational information about each algorithm
5. Generate visual representations (Gantt charts, graphs) for analysis

This project addresses the need for an interactive educational tool that makes OS
scheduling concepts more accessible and understandable through visualization and
experimentation.