By Piyush Wairale (M.Tech, IIT Madras) · Former Instructor, IIT Madras BS Degree Programme · Mentor to 20,000+ GATE aspirants · Updated November 2026

GATE CSE Operating System Syllabus 2027 (Official, IIT Madras)

Section 8 of the CS paper: System calls, processes, threads, inter-process communication, concurrency and synchronization. Deadlock. CPU and I/O scheduling. Memory management and virtual memory. File systems.

Full paper structure: GATE CS 2027 syllabus and exam pattern.

Topic-wise Weightage and Priority (GATE CSE Operating System)

System Calls, Processes, Threads and IPC

A system call switches from user mode to kernel mode. Process states: new, ready, running, waiting, terminated. n calls to fork() in sequence (as in a loop with no conditions) create 2ⁿ processes in total, of which 2ⁿ − 1 are children. Threads of one process share code, data, heap and open files but have their own stack, registers and program counter. User-level threads are fast to switch but one blocking call blocks the whole process (in a many-to-one model); kernel-level threads can be scheduled independently. IPC uses shared memory or message passing.

CPU and I/O Scheduling

Turnaround time = completion − arrival; waiting time = turnaround − burst; response time = first run − arrival. FCFS suffers the convoy effect; SJF (non-preemptive) and SRTF (preemptive) minimise average waiting time but can starve long jobs; Round Robin gives good response time, and as the quantum grows it becomes FCFS; priority scheduling needs aging to prevent starvation. For disk I/O scheduling, know FCFS, SSTF, SCAN, C-SCAN and LOOK, and compute total head movement.

Concurrency and Synchronization

A correct critical-section solution needs mutual exclusion, progress and bounded waiting. Peterson’s solution satisfies all three for two processes. A counting semaphore S: wait/P decrements (blocks if the result is negative), signal/V increments. Final value after x P’s and y V’s on initial value s (with no blocking issues) = s − x + y. Know the classic problems: producer-consumer (empty, full, mutex), readers-writers and dining philosophers, and why the order of wait operations can cause deadlock.

Deadlock

Four necessary conditions: mutual exclusion, hold and wait, no preemption, circular wait. Prevention breaks one condition; avoidance uses the Banker’s algorithm (Need = Max − Allocation, find a safe sequence); detection uses a wait-for graph. If n processes each need at most k instances of a resource, deadlock is impossible when the total instances are at least n(k − 1) + 1.

Memory Management and Virtual Memory

Number of pages = virtual address space / page size; page table size = number of pages × PTE size. Multi-level paging keeps each level’s table within one page. Effective access time with a TLB = h(t_TLB + t_mem) + (1 − h)(t_TLB + 2t_mem) for single-level paging. With page faults, EAT = (1 − p) × t_mem + p × t_fault. Page replacement: FIFO (can show Belady’s anomaly), Optimal (lowest faults, needs the future), LRU (stack algorithm, no Belady’s anomaly). Thrashing happens when the working sets of active processes exceed physical memory. Internal fragmentation occurs with paging; external fragmentation with variable partitions and segmentation.

File Systems

Allocation methods: contiguous (fast, external fragmentation), linked (no random access), indexed (inodes). For a Unix-style inode with direct, single, double and triple indirect pointers, max file size = (direct + P + P² + P³) × block size, where P = block size / pointer size.

Six GATE-Style Problems, Solved (GATE CSE Operating System)

Q1 (NAT). How many child processes does for (i = 0; i < 3; i++) fork(); create?
Solution: 2³ = 8 processes in total, so 7 children.

Q2 (NAT). 32-bit virtual addresses, 4 KB pages, 4-byte PTEs. Single-level page table size?
Solution: 2³²/2¹² = 2²⁰ entries × 4 B = 4 MB.

Q3 (NAT). SRTF with P1 (arrival 0, burst 8), P2 (1, 4), P3 (2, 2). Average waiting time?
Solution: P1 runs 0 to 1, P2 1 to 2, P3 2 to 4, P2 4 to 7, P1 7 to 14. Waiting: P1 = 14 − 0 − 8 = 6, P2 = 7 − 1 − 4 = 2, P3 = 0. Average = 8/3 ≈ 2.67.

Q4 (NAT). FIFO with 3 frames on reference string 1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, 5. Page faults?
Solution: 9. (With 4 frames it rises to 10, the classic Belady’s anomaly.)

Q5 (NAT). 3 processes each need at most 2 units of a resource. Minimum units that guarantee no deadlock?
Solution: 3(2 − 1) + 1 = 4.

Q6 (NAT). A counting semaphore starts at 10. 6 P operations and 4 V operations are performed. Final value?
Solution: 10 − 6 + 4 = 8.

Common Mistakes to Avoid (GATE CSE Operating System)

Forgetting to subtract arrival time when computing turnaround and waiting time.

Counting the parent as a child in fork() questions.

Using 2 memory accesses on a TLB hit: a hit needs only one memory access for single-level paging.

Assuming Belady’s anomaly applies to LRU: it does not.

Mixing up progress and bounded waiting when judging synchronization code.

5-Week Preparation Strategy (GATE CSE Operating System)

Week 1: Processes, threads, system calls, fork. Week 2: CPU scheduling with 30+ Gantt-chart problems. Week 3: Synchronization and deadlock. Week 4: Memory management, paging, TLB and page replacement. Week 5: File systems and disk scheduling, then 10 years of GATE CS OS questions and the OS tests in the GATE CSE 2027 Test Series. Pair it with COA, since cache and paging questions often combine.

FAQs: GATE CSE Operating System 2027

GATE CSE 2027: All Subject-wise Guides

1. Engineering Mathematics · 2. Digital Logic · 3. Computer Organization & Architecture · 4. Programming & Data Structures · 5. Algorithms · 6. Theory of Computation · 7. Compiler Design · 8. Operating System · 9. Databases (DBMS) · 10. Computer Networks

That completes this GATE CSE Operating System guide. Full paper overview: GATE CS 2027 Syllabus, Exam Pattern & Cutoff. Practise all ten subjects in one place with the GATE CSE 2027 Test Series.