[Feature]: Operating System Process Simulator using C++

[prajwal3114]

So, what is it about?

C++ Operating System Process Simulator

Overview

This project is an Operating System Process Simulator implemented entirely in C++. It allows users to simulate the scheduling and execution of multiple processes as handled by an operating system.

The system is designed using Object-Oriented Programming (OOP) principles, making the code modular, maintainable, and easy to extend.

---

Features

• Simulate multiple processes with attributes like process ID, arrival time, burst time, and priority
• Supports different CPU scheduling algorithms, including:
  • First-Come-First-Served (FCFS)
  • Shortest Job Next (SJN/SJF)
  • Priority Scheduling
  • Round Robin (optional)
• Displays process execution order and Gantt charts in console
• Calculates metrics such as:
  • Waiting time
  • Turnaround time
  • Completion time
• Optional: interactive mode to add, modify, or remove processes

---

Requirements

• C++ Implementation: Entirely written in C++
• Object-Oriented Design: Uses classes like Process, Scheduler, OSSimulator, etc.
• Clean Code Practices:
  • Meaningful variable and function names
  • Proper input validation and error handling
  • Well-documented methods and classes

---

Simulation & Metrics

• Users can input processes with their arrival and burst times.
• The simulator calculates execution order based on the selected scheduling algorithm.
• Provides metrics such as average waiting time, turnaround time, and CPU utilization.
• Useful for understanding how operating systems manage process scheduling.

---

Code of Conduct

• I agree to follow this project's Code of Conduct

[harshsankhla18]

@prajwal3114 assign this to me

[harshthakur3]

@prajwal3114 assign this

Proposed Approach:

I would like to work on this Operating System Process Simulator project in C++. My approach will focus on building a robust, scalable, and well-structured simulation system using OOP principles:

1. Core Architecture & Design:
I will design a modular class hierarchy with:

• A Process class encapsulating process attributes (PID, arrival time, burst time, remaining time, priority, completion time, turnaround time, waiting time) with getters/setters and state management methods.
• An abstract Scheduler base class defining the interface for scheduling algorithms, with derived classes (FCFSScheduler, SJFScheduler, PriorityScheduler, RoundRobinScheduler) implementing specific algorithm logic using polymorphism.
• An OSSimulator class acting as the main controller, managing the ready queue, CPU state, and coordinating between processes and schedulers.
• A GanttChart utility class to visualize process execution timelines in the console.

2. Scheduling Algorithm Implementation:
Each scheduling algorithm will be implemented as a separate class inheriting from the Scheduler base class:

• FCFS: Simple queue-based execution in arrival order
• SJF: Min-heap or priority queue sorted by burst time
• Priority Scheduling: Priority queue with aging mechanism to prevent starvation
• Round Robin: Circular queue with configurable time quantum, tracking remaining burst times

3. Data Structures:
I'll leverage STL containers efficiently:

• std::vector<Process> for storing all processes
• std::queue or std::priority_queue for ready queues depending on the algorithm
• std::map for quick process lookups by PID

4. Simulation Logic:
The simulator will operate on discrete time units, advancing through each time step and:

• Checking for process arrivals and adding them to the ready queue
• Dispatching processes based on the selected algorithm
• Updating process states (waiting, running, completed)
• Tracking context switches and idle time

5. Metrics Calculation:
After simulation completion, I'll calculate:

• Waiting Time = Turnaround Time - Burst Time
• Turnaround Time = Completion Time - Arrival Time
• Average metrics across all processes
• CPU Utilization = (Total Burst Time / Total Time) × 100
• Throughput = Processes Completed / Total Time

6. User Interface:
I'll create an intuitive console-based menu system allowing users to:

• Choose scheduling algorithms dynamically
• Input process details with validation (non-negative times, unique PIDs)
• View Gantt charts with ASCII art representation (e.g., |P1--P2----P3--|)
• Display detailed metrics in formatted tables
• Optional interactive mode for adding/removing processes during runtime

7. Code Quality & Best Practices:

• Follow SOLID principles and clean code standards
• Implement comprehensive input validation and exception handling
• Use meaningful naming conventions (camelCase for variables, PascalCase for classes)
• Add detailed comments and documentation for each class and method
• Create separate header (.h) and implementation (.cpp) files for each class
• Include a driver main.cpp for demonstration

8. Testing & Validation:
I'll test each algorithm with various scenarios:

• Edge cases (single process, all processes arriving at once)
• Starvation scenarios for priority scheduling
• Different time quantum values for Round Robin
• Processes with identical burst/arrival times

[prajwal3114]

@harshthakur3 Assigned to you ✅
Please try to complete it by October 30 , 2025.