Quantae - GitLite

KO | EN

gitlite — search

#editor #electron #terminal #artificial-intelligence #anthropic #chatbot #tailwindcss #video #codex #mysql

Quantae

(★ 21)

This project is a simulation of core operating system components, combining CPU scheduling and memory management concepts into a unified system. It is implemented in C and runs on a Linux environment using inter-process communication (IPC).

File Explorer

ZIP Download

- clk.c
- headers.h
- logger.c
- logger.h
- Makefile
- out.txt
- process.c
- process.h
- process_generator.c
- processes.txt
- queue.c
- queue.h
- README
- scheduler.log
- scheduler.perf
- scheduler2.log
- scheduler2.perf
- schedulerCPU2.c
- schedulerHPF.c
- schedulerRR.c
- test_generator.c
- clk.c
- clk.out
- headers.h
- logger.c
- logger.h
- Makefile
- memory.log
- mmu.c
- mmu.h
- nul
- out.txt
- process.c
- process.h
- process.out
- process_generator.c
- process_generator.out
- processes.txt
- queue.c
- queue.h
- requests_1.txt
- requests_10.txt
- requests_11.txt
- requests_12.txt
- requests_13.txt
- requests_14.txt
- requests_15.txt
- requests_16.txt
- requests_2.txt
- requests_3.txt
- requests_4.txt
- requests_5.txt
- requests_6.txt
- requests_7.txt
- requests_8.txt
- requests_9.txt
- scheduler.c
- scheduler.out
- test_generator.c
- test_generator.out
- testcase.txt
block_diagram.png
Final Test Cases.txt
README.md

# Use via CDN

jsDelivr

jsDelivr serves any public GitHub repository as a CDN with zero setup. Pick a version and a file to get a ready-to-paste link and snippet.

Version

File

Link

Example

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

<p align="center">
  <img src="https://img.shields.io/badge/Language-C-blue?style=for-the-badge&logo=c&logoColor=white"/>
  <img src="https://img.shields.io/badge/Domain-Operating_Systems-red?style=for-the-badge"/>
  <img src="https://img.shields.io/badge/IPC-Message_Queue%20%7C%20Semaphore-yellow?style=for-the-badge"/>
  <img src="https://img.shields.io/badge/Topic-CPU_Scheduling%20%7C%20Memory_Management-green?style=for-the-badge"/>
</p>

---

## 📖 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
![Block Diagram](https://raw.githubusercontent.com/HabibaMahmoud2005/Quantae/main/block_diagram.png)

---

## 📊 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)

```bash
cd phase1_code
make build
./process_generator.out
```

Or with a custom process file:

```bash
./process_generator.out custom_processes.txt
```

### Phase 2 (With Memory Management)

```bash
cd phase2_code
make build
```

Run the simulation:

```bash
./process_generator.out
```

Or with a custom process file:

```bash
./process_generator.out custom_processes.txt
```

#### Generate Random Workload

```bash
./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` |

---

<p align="center"><i>Quantae — A two-phase OS simulation project exploring CPU scheduling and memory management.</i></p>