Quantae

---

📖 Overview

Quantae is a comprehensive operating systems project spanning two phases, implementing CPU process scheduling algorithms and memory management for a simulated OS. The project demonstrates how a real operating system kernel manages process lifecycle, IPC, and virtual memory.

Project Goals

• Phase 1: Implement multiple CPU scheduling algorithms (RR, HPF, FCFS 2 CPUs) to compare performance metrics.
• Phase 2: Integrate memory management with the scheduler—introducing page tables, memory requests, blocked queues, and memory-induced process blocking.

---

🗂️ Project Structure

Quantae/
├── phase1_code/                   # Phase 1: CPU Scheduling Algorithms
│   ├── schedulerRR.c              # Round-Robin scheduler
│   ├── schedulerHPF.c             # Highest Priority First scheduler
│   ├── schedulerCPU2.c            # FCFS 2 CPUs scheduler
│   ├── process_generator.c        # Phase 1 driver for loading processes
│   ├── process.c / process.h      # Child process execution
│   ├── queue.c / queue.h          # Process queue data structure
│   ├── clk.c                      # Simulated system clock
│   ├── logger.c / logger.h        # Event logging for analysis
│   ├── test_generator.c           # Random workload generator
│   ├── process.h                  # PCB (Process Control Block) definition
│   ├── headers.h                  # Shared constants and IPC keys
│   ├── Makefile                   # Build configuration
│   ├── scheduler.log              # Simulation output log
│   ├── scheduler.perf             # Simulation performance metrics
│   ├── scheduler2.log             # Simulation output log (2nd CPU)
│   └── scheduler2.perf            # Simulation performance metrics (2nd CPU)
│
├── phase2_code/                   # Phase 2: Memory Management Integration
│   ├── scheduler.c                # Enhanced scheduler with memory support
│   ├── mmu.c / mmu.h              # Memory Management Unit (page tables, requests)
│   ├── process_generator.c        # Phase 2 driver
│   ├── clk.c                      # Simulated clock
│   ├── process.c / process.h      # Enhanced process with memory requests
│   ├── queue.c / queue.h          # Enhanced queue for blocked processes
│   ├── logger.c / logger.h        # Enhanced logging
│   ├── headers.h                  # Shared definitions
│   ├── test_generator.c           # Random workload generator
│   ├── requests_i.txt             # Per-process memory request traces
│   ├── processes.txt              # Input process list (user-defined)
│   ├── Makefile                   # Build configuration
│   └── memory.log                 # Simulation memory actions log
│
├── README.md
└── Final Test Cases.txt           # Comprehensive test suite documentation

📈 Block Diagram

---

📊 Project Phases

Phase 1: CPU Scheduling Algorithms

The first phase focuses on implementing and comparing different CPU scheduling strategies in a simulated environment.

Implemented Algorithms

Algorithm	File	Description
Round-Robin (RR)	schedulerRR.c	Time-sliced execution with fixed quantum; processes rotate in ready queue
Highest Priority First (HPF)	schedulerHPF.c	Non-preemptive; always runs the highest-priority ready process
FCFS 2 CPUs	schedulerCPU2.c	FCFS with dual CPUs; distributes processes across two independent queues with load balancing via work stealing to reduce imbalance and improve overall utilization.

Key Features

• Process Generator: Reads processes.txt and sends processes to scheduler at their arrival times
• Simulated Clock: clk.c provides a synchronized global time for all components
• IPC Communication: Uses UNIX message queues and semaphores for inter-process communication
• Event Logging: Records all process state transitions (start, preemption, finish) with timestamps
• Performance Metrics: Computes turnaround time, weighted turnaround time, and CPU utilization

---

Phase 2: Memory Management Integration

Phase 2 extends the scheduler with virtual memory management, introducing page tables, memory requests, and process blocking due to memory I/O.

New Components

Component	File	Purpose
MMU	mmu.c / mmu.h	Manages page tables, frame allocation, and memory request handling
Memory Requests	requests_*.txt	Per-process traces of memory access patterns (read/write)
Blocked Queue	Enhanced scheduler	Manages processes waiting for memory operations to complete
Enhanced Scheduler	scheduler.c	Coordinate CPU scheduling with memory request handling

Key Improvements

• Page Table Management: Each process gets allocated a page table frame upon start
• Memory Requests Handling: Processes issue memory read/write requests that may block execution
• Blocked Queue: Separate queue for processes waiting on memory I/O
• Simulated Page Faults: System models realistic memory access delays
• R-bit Clearing: Periodic clearing of reference bits (R-bits) based on a parameter K

Processing Flow

1. Process Arrival → Scheduler receives via message queue
2. Memory Initialization → MMU allocates page table frame
3. CPU Execution → RR scheduling with quantum-based preemption
4. Memory Request → Process issues R/W at scheduled time
5. Blocking → If memory busy, process moves to blocked queue
6. Resumption → Process returns to ready queue when memory operation completes
7. Completion → Process finishes when remaining time reaches zero

---

🔬 Key Components (Phase 2)

process_generator.c

Main simulation driver:

• Parses processes.txt
• Validates process fields
• Creates IPC resources (message queue, semaphores)
• Forks clock and scheduler
• Sends processes to scheduler at arrival times
• Logs all events

scheduler.c

Core scheduling logic with memory integration:

• Ready queue and blocked queue management
• RR quantum enforcement
• Process fork/exec and state transitions
• Calls to mmu.c for memory operations
• Loads per-process memory request files (requests_*.txt)
• Processes memory requests and manages blocking

mmu.c

Memory Management Unit simulation:

• Initializes page tables for each process
• Loads memory request traces from per-process files
• Simulates page allocation and frame assignment
• Tracks memory operations and request completion

clk.c

Simulated system clock shared across all processes:

• Uses signal-based time advancement
• Accessed via getClk() for process synchronization
• Initialized/destroyed by process generator

process.c

Child process behavior:

• Executes scheduled process logic
• Issues memory requests at scheduled relative times
• Communicates with scheduler via IPC
• Implements R-bit functionality for memory tracking

---

▶️ Build & Run

Phase 1 (CPU Scheduling Only)

cd phase1_code
make build
./process_generator.out

Or with a custom process file:

./process_generator.out custom_processes.txt

Phase 2 (With Memory Management)

cd phase2_code
make build

Run the simulation:

./process_generator.out

Or with a custom process file:

./process_generator.out custom_processes.txt

Generate Random Workload

./test_generator.out
# Follow prompts to specify number of processes

Makefile Targets

Target	Action
make build	Compile all executables
make clean	Remove all .out binaries
make all	Clean and rebuild
make run	Execute process_generator.out

---

Quantae — A two-phase OS simulation project exploring CPU scheduling and memory management.