The Complete OS Exam Preparation Kit
A data-driven, all-module survival guide built from analyzing 100+ questions across 2019–2024 exam papers. Contains the guaranteed questions, the exact mark distribution, the 72-hour study plan, and the critical mistakes that fail students.
Learning Goals
- Understand the exact module-wise mark distribution and identify the three highest-ROI modules to study.
- Know the 8 guaranteed question types that appear every single year — and have answer templates ready for each.
- Follow the 72-hour, 7-day, and 14-day study plans matched to your available preparation time.
- Avoid the 10 most common exam mistakes that cost students marks every year.
The Exam Architecture: Understanding the Paper
Before studying a single topic, understand how the exam is built. Based on 2019–2024 paper analysis:
Paper Structure:
- Total Marks: 70 marks (external exam)
- Duration: 3 hours
- Section A: ~10 MCQs × 2 marks = 20 marks (compulsory — all must be answered)
- Section B: 5–6 long-answer questions × 7–14 marks = 50 marks (attempt all or choose from given options)
The Critical Implication: Section A (MCQs) is worth 20 marks — nearly 30% of the paper — and takes only 15–20 minutes. This is the highest marks-per-minute section. Getting MCQs wrong is the single biggest reason students fail who "knew the material."
The Module Power Ranking: Where Your Marks Actually Come From
Based on 100+ questions across 2019–2024, here is the data-driven importance ranking:
| Rank | Module | Avg. Marks/Year | Guaranteed Q? | Priority |
|---|---|---|---|---|
| #1 | Module 5: Memory Management | ~33M/year | ✅ Page replacement + TLB | 🔴 CRITICAL |
| #2 | Module 2: Processes & Scheduling | ~28M/year | ✅ Gantt chart numerical | 🔴 CRITICAL |
| #3 | Module 3: IPC & Synchronization | ~18M/year | ✅ Peterson's + Semaphores | 🟠 HIGH |
| #4 | Module 4: Deadlocks | ~16M/year | ✅ Banker's Algorithm | 🟠 HIGH |
| #5 | Module 6: I/O & File Management | ~14M/year | ✅ Disk scheduling | 🟡 MEDIUM |
| #6 | Module 1: Introduction | ~4M/year | ❌ No guaranteed Q | 🟢 LOW |
The ROI calculation: If you only study Modules 5, 2, and 3 perfectly, you can answer questions worth ~79 marks out of the 70-mark paper (i.e., more than enough material even with choice). Add Module 4 (Banker's Algorithm) and you are virtually guaranteed to pass.
The 8 Guaranteed Question Types (Appear EVERY Year)
These are questions that have appeared in every exam from 2019 to 2024, or in 3+ of the 4 years. If you master these 8, you can answer at least 50 out of 70 marks on any paper.
🔴 GUARANTEED #1: Page Replacement Numerical (7–14 Marks)
Module 5 | Appeared: 2019, 2022, 2023, 2024
Given a reference string and N frames, trace FIFO, LRU, and/or Optimal. Count page faults.
What to practice:
- Draw a table: columns = each reference, rows = frame contents after each reference
- Mark each fault with ✅ and each hit with ❌
- Always count the cold-start faults (first N unique pages = N faults automatically)
Time to solve: 10–15 mins for all 3 algorithms
🔴 GUARANTEED #2: CPU Scheduling Gantt Chart (7–14 Marks)
Module 2 | Appeared: 2019, 2022, 2023, 2024
Given process arrival times and burst times, draw Gantt charts and calculate AWT/ATAT for SJF, SRTF, or Round Robin.
What to practice:
- SJF vs SRTF (2019, 2024) — know the preemption check at each arrival
- Round Robin (2022, 2023) — track remaining burst after each quantum
- ALWAYS: AWT = (sum of waiting times) / n, ATAT = (sum of turnaround times) / n
🔴 GUARANTEED #3: Banker's Algorithm (7 Marks)
Module 4 | Appeared: 2022, 2023, 2024
Given Allocation, Max, and Available matrices — find Need, run Safety Algorithm, find safe sequence.
What to practice:
- Need = Max − Allocation (do this FIRST, check for errors)
- Safety Algorithm: iterate through processes, find one where Need ≤ Work, add its Allocation to Work, mark finished
- Sometimes: "Can request X be granted?" → temporarily allocate, re-run safety
🔴 GUARANTEED #4: TLB / Paging Theory or Numerical (7 Marks)
Module 5 | Appeared: 2022, 2023, 2024
Either: (a) Explain paging with TLB diagram, or (b) Calculate EAT given hit ratio.
The EAT formula to memorize:
🟠 GUARANTEED #5: Critical Section + Peterson's Solution (7–8 Marks)
Module 3 | Appeared: 2019, 2022, 2023, 2024
Define CS problem + 3 requirements, and/or write Peterson's pseudocode.
The 3 requirements you MUST name: Mutual Exclusion, Progress, Bounded Waiting.
🟠 GUARANTEED #6: Thrashing (5–7 Marks)
Module 5 | Appeared: 2022, 2023, 2024
Define thrashing, explain cause, describe prevention.
3-sentence answer template:
- Thrashing = processes spend more time paging than executing.
- Cause: total working set demand D exceeds available frames m.
- Fix: working set strategy — suspend processes until D ≤ m.
🟠 GUARANTEED #7: Disk Scheduling Numerical (7–14 Marks)
Module 6 | Appeared: 2019, 2022, 2023, 2024
Calculate total head movement for SSTF, SCAN, C-SCAN, or FCFS.
Key formulas:
- SSTF: always go to the nearest request next
- SCAN: go in one direction to the end, reverse, then serve remaining
- C-SCAN: go in one direction to the end, jump to the start, continue in the same direction
🟡 GUARANTEED #8: Fragmentation + Fit Algorithms (7 Marks)
Module 5 | Appeared: 2022, 2024
Compare internal vs external fragmentation, and/or First-Fit vs Best-Fit vs Worst-Fit with actual partition sizes.
The 10 Most Common Exam Mistakes
These mistakes cost students 2–7 marks each and are entirely avoidable:
| # | Mistake | Where | Marks Lost | Fix |
|---|---|---|---|---|
| 1 | Confusing Pages (logical) with Frames (physical) | Module 5 MCQ | 2M | Pages = logical, Frames = physical. Period. |
| 2 | Forgetting cold-start faults in page replacement | Module 5 Numerical | 2–3M | First N unique pages = N guaranteed faults |
| 3 | Reversing wait(empty) and wait(mutex) in Producer-Consumer | Module 3 | 3–4M | wait(empty) BEFORE wait(mutex). Always. |
| 4 | Confusing Progress with Bounded Waiting | Module 3 Theory | 2M | Progress = "selection finishes in finite time." BW = "there's a limit on how many times others can cut in line." |
| 5 | Not computing Need = Max − Allocation as the first step in Banker's | Module 4 | 7M | Always show the Need matrix first. Partial marks depend on it. |
| 6 | Drawing Gantt chart but forgetting AWT and ATAT calculations | Module 2 | 3–4M | Always end with: "AWT = __ / n = __, ATAT = __ / n = __" |
| 7 | Saying "Belady's Anomaly can occur with LRU" | Module 5 Theory | 2M | ONLY FIFO. LRU and Optimal are stack algorithms — immune. |
| 8 | Writing "Virtual Memory is a large secondary memory" | Module 5 MCQ | 2M | It's an illusion of large memory, not actual memory. |
| 9 | Confusing Seek Time with Rotational Latency | Module 6 | 2M | Seek = arm movement (track to track). Rotation = waiting for sector. |
| 10 | Not specifying the safe sequence in Banker's Algorithm | Module 4 | 2M | Always write: "Safe state. Safe sequence: ⟨P₀, P₂, P₃, P₁, P₄⟩" |
The Study Plans: 72 Hours, 7 Days, and 14 Days
🔴 THE 72-HOUR EMERGENCY PLAN (3 Days Before Exam)
Goal: Pass (35/70 marks). Focus ONLY on guaranteed questions.
| Day | Hours | What to Study | Expected Marks Secured |
|---|---|---|---|
| Day 1 (8hr) | 4hr | Page replacement: trace FIFO + LRU on 2 reference strings | 7–14M |
| 2hr | Banker's Algorithm: solve 2 problems | 7M | |
| 2hr | All MCQ definitions: frames/pages, Belady's, Virtual memory, RAID | 8–10M | |
| Day 2 (8hr) | 4hr | CPU Scheduling: SJF + Round Robin Gantt charts | 7–14M |
| 2hr | Thrashing + Belady's Anomaly (write 3-point answers) | 7M | |
| 2hr | Disk Scheduling: SSTF numerical | 7M | |
| Day 3 (4hr) | 2hr | Peterson's Solution: memorize pseudocode + 3 requirements | 7–8M |
| 2hr | Revise all MCQ definitions + redo 1 numerical from each module | — |
Expected score: 43–60+ marks. You will pass.
🟡 THE 7-DAY PLAN (One Week Before Exam)
Goal: Score well (50–60/70 marks).
| Day | Focus Module | Topics |
|---|---|---|
| Day 1 | Module 5 (Memory) | Address binding, fragmentation, fit algorithms, paging + TLB + EAT |
| Day 2 | Module 5 (Memory) | Page replacement (FIFO/LRU/Optimal), Belady's, thrashing, working sets |
| Day 3 | Module 2 (Processes) | Process states, PCB, threads, CPU scheduling (all 4 algorithms with numericals) |
| Day 4 | Module 3 (IPC) | Race condition, CS problem, Peterson's, semaphores, Producer-Consumer |
| Day 5 | Module 4 (Deadlocks) | 4 conditions, Banker's Algorithm (2 problems), prevention strategies |
| Day 6 | Module 6 (I/O) | Disk scheduling (SSTF, SCAN, C-SCAN), file allocation methods, DMA |
| Day 7 | Full Revision | Redo all MCQs from PYQ sections, write 1 numerical per module, revise definitions |
🟢 THE 14-DAY MASTERY PLAN (Two Weeks Before Exam)
Goal: Score 60+ marks.
| Week 1 | Focus | Detail |
|---|---|---|
| Day 1–2 | Module 5 | All 4 content sections in depth + every PYQ numerical solved |
| Day 3–4 | Module 2 | All scheduling algorithms + PCB + threads + every Gantt chart PYQ |
| Day 5 | Module 3 | Sections 1–2 (CS problem + Peterson's + hardware solutions) |
| Day 6 | Module 3 | Sections 3–4 (semaphores + monitors + all 3 classic problems) |
| Day 7 | Module 4 | All 3 sections + Banker's Algorithm (3 problems minimum) |
| Week 2 | Focus | Detail |
|---|---|---|
| Day 8 | Module 6 | I/O + File management + disk scheduling numericals |
| Day 9 | Module 1 | Quick review — definitions, OS structures, system calls |
| Day 10 | PYQ Marathon | Attempt every MCQ from all 6 PYQ sections (timed: 20 minutes) |
| Day 11 | Numerical Marathon | Solve 1 full page replacement, 1 Gantt chart, 1 Banker's, 1 disk scheduling |
| Day 12 | Theory Revision | Write out answer templates for all guaranteed subjective questions |
| Day 13 | Mock Paper | Attempt a full 2023 or 2024 paper under exam conditions (3 hours) |
| Day 14 | Final Review | Review mistakes from mock paper, re-read all "common mistakes" tables |
Quick-Reference: The 15 Definitions You MUST Memorize
These exact definitions have appeared as 2-mark MCQs. Memorize them word-for-word.
| # | Term | One-Line Definition |
|---|---|---|
| 1 | Operating System | A collection of programs that manages hardware resources and provides services to applications. |
| 2 | Process | A program in execution — with its own address space, PC, registers, and stack. |
| 3 | PCB | The data structure that stores all information about a process: PID, state, PC, registers, scheduling info, memory info, I/O status. |
| 4 | Context Switch | Saving the state of the current process and restoring the state of the next process. |
| 5 | Race Condition | When the final outcome depends on the non-deterministic interleaving of concurrent processes. |
| 6 | Critical Section | The segment of code where a process accesses shared resources; only one process may be in its CS at a time. |
| 7 | Semaphore | An integer variable accessed only through atomic wait() and signal() operations. |
| 8 | Deadlock | A state where every process in a set is waiting for a resource held by another process in the set. |
| 9 | Frame | A fixed-size block of physical memory (RAM). |
| 10 | Page | A fixed-size block of a process's logical address space. |
| 11 | Virtual Memory | An illusion of extremely large memory created by keeping only active pages in RAM and the rest on disk. |
| 12 | Demand Paging | Loading a page into RAM only when the CPU references it (lazy loading). |
| 13 | Thrashing | When a process spends more time paging (disk I/O) than executing useful work. |
| 14 | Belady's Anomaly | The counterintuitive property of FIFO where more frames can cause more page faults. |
| 15 | SPOOLING | Simultaneous Peripheral Operation Online — buffering output to disk before sending to a slow device. |
Formula Sheet: All Numericals in One Place
Keep these formulas on a single sheet for last-minute revision.
Module 2 — CPU Scheduling:
Turnaround Time (TAT) = Completion Time − Arrival Time Waiting Time (WT) = TAT − Burst Time AWT = Σ(WT) / n ATAT = Σ(TAT) / n
Module 4 — Banker's Algorithm:
Need[i] = Max[i] − Allocation[i] Safety Check: Find process where Need[i] ≤ Work Work += Allocation[i], mark as finished Repeat until all finished (safe) or stuck (unsafe) Max n for deadlock-free: n(K-1) < R → n < R/(K-1)
Module 5 — Paging & TLB:
Page Number (p) = floor(logical_address / page_size) Offset (d) = logical_address mod page_size Physical Address = frame_number × page_size + offset Number of Pages = logical_address_space_size / page_size EAT = α(ε + m) + (1-α)(ε + 2m) α = TLB hit ratio, ε = TLB lookup time, m = memory access time
Module 5 — Demand Paging:
EAT = (1-p) × m + p × page_fault_service_time p = page fault rate, m = memory access time
Module 6 — Disk Scheduling:
Total Head Movement = Σ |current_position − next_request| Seek Time = Total Head Movement × time_per_cylinder
Knowledge Check
You have exactly 6 hours before the OS exam. Which THREE topics should you prioritize to maximize your marks?