Operating System for GATE CS 2027: Weightage, PYQs & Plan

Operating Systems is worth about 7 to 8 marks per GATE CS paper, or roughly 7.6% of the 100-mark paper. We counted every OS question in all 23 official GATE CS papers from 2014 to 2026. OS averaged 7.6 marks per paper, ranged from 5 to 10, and has held at about 7.8 marks per paper since 2021. It is also the most numerical subject in the paper: since 2021, 45% of OS marks have come from numerical answer type (NAT) questions. Memory management alone is about a third of the subject. This guide covers the official 2027 syllabus, topic-by-topic numbers, five worked questions from past papers and a study order based on that data.

GATE CS 2027 Operating System Syllabus

Operating System is Section 8 of the official GATE 2027 CS syllabus. The official text lists:

• System calls, processes, threads, inter-process communication
• Concurrency and synchronization
• Deadlock
• CPU and I/O scheduling
• Memory management and virtual memory
• File systems

This is identical to the GATE 2026 CS syllabus. Topics that operating systems textbooks cover but GATE does not list include distributed systems, security and protection, virtual machines and specific OS case studies. For the full CS syllabus, see our GATE CS syllabus page.

How Many Marks Does Operating System Carry in GATE CS?

The official question paper pattern fixes marks only for General Aptitude (15) and Engineering Mathematics (13). This is what OS actually carried in each paper:

What this means: OS is steady. It averaged 7.5 marks per paper from 2014 to 2020 and 7.8 from 2021 to 2026, and in 13 of the 23 papers it carried 7 marks or more. Most OS questions are worth 2 marks (67 of 108), so a weak OS section costs more than the question count suggests. For how OS compares with other subjects, see our GATE CSE subject-wise weightage analysis.

Topic-Wise Weightage: Where OS Marks Come From

We grouped the 108 OS questions by syllabus heading, with the average marks per paper across all 23 papers:

Looking at individual topics, the most-asked across all 23 papers were page replacement (9 questions, 16 marks), semaphores (7 questions, 13 marks), CPU scheduling numericals (7 questions, 12 marks) and paging and address translation (7 questions, 11 marks).

Three patterns stand out:

1. Memory management keeps growing. At 2.7 marks per paper since 2021, it is the one OS topic that appears almost every year. The questions are mostly numerical: TLB size, page table size, effective access time and page faults for a reference string.
2. Processes and threads have tripled. They rose from about 0.5 to 1.5 marks per paper. Recent papers ask which state transitions are impossible, what triggers a context switch, what threads share, and how many processes a fork() loop creates. These are usually 1-mark MSQs that reward exact definitions.
3. Deadlock has roughly halved, from 1.3 to 0.7 marks per paper, but it was still asked twice in 2026 Set 1. The minimum-resources formula in worked example 2 is the most common form.

Question Types: OS Is a Numerical Subject

From 2021 to 2026, the 49 OS questions split into 20 MSQs, 19 NATs and 10 MCQs. By marks, NATs carried 35 of 78 (45%), MSQs 27 (35%) and MCQs only 16 (21%). Success Tracker rates 20 of the 108 OS questions as hard, which is a higher share than in DBMS or Discrete Maths.

The official marking rules are on the question paper pattern page. NAT and MSQ questions carry no negative marks, but NAT answers must be exact, with no options to check against. For OS, that means:

• Write units at every step of paging calculations. Most wrong answers come from mixing up bits, bytes, KB and entries.
• Draw the Gantt chart for every scheduling question, even easy-looking ones.
• For page replacement, write the frame contents after every reference instead of tracking them mentally.

Topic by Topic: What GATE Asks and How to Prepare

1. Memory Management and Virtual Memory

What gets asked: logical and physical address splits, page table size, multilevel and inverted page tables, TLB reach and effective memory access time, page faults under FIFO, LRU and optimal replacement, demand paging, and contiguous allocation with variable partitions.

How to prepare: learn one template and reuse it. Page offset bits come from the page size. Page number bits are virtual address bits minus offset bits. Frame number bits are physical address bits minus offset bits. Page table size is the number of entries times the entry size. Nearly every paging NAT is a variation on this. For replacement, practise recognising a policy from a given frame trace, which GATE asked in 2025.

Recent PYQs: variable-partition allocation (2026, NAT), demand paging address split (2025), identify the replacement policy (2025, MSQ), optimal page replacement (2025, NAT).

2. CPU Scheduling

What gets asked: average waiting and turnaround times under FCFS, SJF, SRTF, round robin and priority scheduling, which algorithms can be preemptive, and multi-processor variants.

How to prepare: draw a Gantt chart every time. Remember that turnaround time = completion − arrival and waiting time = turnaround − burst. With SRTF, re-check the queue at every arrival and every completion. That is where the preemptions happen (worked example 4).

Recent PYQs: two process types on one CPU (2026, NAT), which algorithm cannot be preemptive (2026), two processors, priority scheduling (2025).

3. Concurrency and Synchronization

What gets asked: possible outputs of processes synchronised with semaphores, final values of shared variables after race conditions, critical-section requirements (mutual exclusion, progress, bounded waiting), and producer–consumer variants.

How to prepare: for semaphore questions, mark which lines run inside the critical section and which signal can run when. Then test each option by building the interleaving that would produce it. Proving an output impossible usually comes down to one mutual-exclusion argument.

Recent PYQs: three processes and two semaphores (2026, MSQ), two threads and shared variables (2024), semaphores in a multi-threaded program (2024, MSQ).

4. Deadlock

What gets asked: the four necessary conditions, the banker's algorithm and safe states, resource allocation graphs, the minimum number of resources needed to avoid deadlock, and prevention strategies.

How to prepare: learn the formula for n processes that each need at most m instances: at least n(m − 1) + 1 instances guarantee freedom from deadlock. For the banker's algorithm, compute the Need matrix first, then look for a safe sequence greedily.

Recent PYQs: deadlock statements (2026, MSQ), resource allocation graph (2025, MSQ), deadlock prevention (2021, MSQ).

5. Processes, Threads and System Calls

What gets asked: process state transitions, what causes a context switch, user versus kernel threads, what threads share (code, data and open files, but not stack or registers), counting processes created by fork(), and which library calls trigger system calls.

How to prepare: for fork() questions, draw the process tree and track which branch each process takes. n unconditional forks create 2ⁿ processes, but any condition on the return value changes that (worked example 1). For thread questions, memorise the list of what is shared and what is private.

Recent PYQs: C program in a multiprogramming system (2025, NAT), impossible state transitions (2024, MSQ), what triggers a context switch (2024, MSQ).

6. File Systems

What gets asked: contiguous, linked and indexed allocation, inode block-pointer arithmetic (maximum file size), free-space management with bitmaps or linked lists, and directory implementations.

How to prepare: practise the inode maximum-file-size calculation and the bitmap-versus-free-list size comparison. These are 2-mark NATs, and they have appeared more often since 2021.

Recent PYQs: free-space management (2026, NAT), file allocation on a 512 MB disk (2025, NAT), inode maximum file size (2019, NAT).

Worked Examples from Official GATE CS Papers

Each answer below matches the official answer key, as reproduced on the linked question page.

Example 1: Counting fork() calls (GATE CS 2026 Set 1, Q63, 2 marks, NAT)

Question: a loop runs for i = 0, 1, 2. In each iteration, if fork() == 0 the process does continue, otherwise it does break. After the loop, every process prints "Hello!" once. How many times is it printed?

Solution: only the child goes on to the next iteration, and every parent leaves the loop. So the original process forks once and exits the loop. Its child forks once and exits. That child's child forks once and exits. The last child finishes the loop normally. This makes a chain of 4 processes, not a tree of 2³ = 8, so the answer is 4. Practise this question.

Example 2: Minimum resources for no deadlock (GATE CS 2026 Set 1, Q35, 1 mark, NAT)

Question: 5 processes share k instances of resource R. Each needs at most 2 instances and requests them one at a time. What is the minimum k that keeps the system deadlock-free?

Solution: the worst case is that every process holds one instance and waits for its second. That uses 5 × (2 − 1) = 5 instances with no process able to finish. One more instance lets some process complete and release both. So k = n(m − 1) + 1 = 5 × 1 + 1 = 6. Practise this question.

Example 3: Semaphore outputs (GATE CS 2026 Set 2, Q51, 2 marks, MSQ)

Question: three processes run identical code with binary semaphores A = 1 and B = 0 and a shared X = 0. Each process does: Wait(A); print *; X = X + 1; if X == 2 { print $; Signal(B) }; Signal(A); Wait(B); print #; Signal(B). Which outputs are possible: **$*###, **$#*##, **$##*# or ***$###?

Solution: A is a mutex, so the second process prints * and then $ inside the same critical section, with no * in between. That makes ***$### impossible. After $, B is signalled and every # passes the signal on, so the # outputs chain one after another. The third process can enter the critical section and print its * before, between or after those # outputs. So **$*###, **$#*## and **$##*# are all possible. Practise this question.

Example 4: SRTF turnaround time (GATE CS 2025 Set 2, Q26, 1 mark)

Question: P1 to P4 arrive at 0, 1, 2 and 8 ms with bursts of 10, 13, 6 and 9 ms. Under SRTF, what is the average turnaround time?

Solution: P1 runs from 0 to 2. P3 arrives with 6 < 8 remaining, so it preempts P1 and runs from 2 to 8. At 8, the remaining times are P1 = 8, P4 = 9 and P2 = 13, so P1 runs from 8 to 16, P4 from 16 to 25 and P2 from 25 to 38. The turnaround times are 16, 37, 6 and 17, which sum to 76. 76 ÷ 4 = 19 ms. Practise this question.

Example 5: TLB size from TLB reach (GATE CS 2026 Set 2, Q54, 2 marks, NAT)

Question: TLB reach is 1 MB, pages are 4 KB, virtual memory is 64 GB and physical memory is 1 GB. Each TLB entry holds a 4-bit process ID, a page number, a frame number and 2 control bits. How many bytes is the TLB?

Solution: the number of entries is reach ÷ page size = 2²⁰ ÷ 2¹² = 256. The page number has 36 − 12 = 24 bits and the frame number has 30 − 12 = 18 bits. Each entry is 4 + 24 + 18 + 2 = 48 bits = 6 bytes. The TLB is 256 × 6 = 1536 bytes. Practise this question.

Study Order and Time Plan

OS takes roughly 4 to 5 weeks at 2 hours a day. This order builds each topic on the one before it:

1. Processes, threads and system calls (4 days): the vocabulary for everything else, and now worth about 1.5 marks per paper.
2. CPU scheduling (4–5 days): do one Gantt chart a day until it becomes automatic.
3. Synchronization (5–6 days): semaphores, critical sections and classic problems.
4. Deadlock (3 days): the four conditions, the banker's algorithm, resource allocation graphs and the n(m − 1) + 1 formula.
5. Memory management and virtual memory (7–8 days): the biggest topic, so give it the most numerical practice.
6. File systems and disk scheduling (3–4 days): allocation methods, inode arithmetic, free-space management, and FCFS, SSTF, SCAN and C-SCAN head movement.
7. PYQ sweep (3–4 days): all 108 OS questions from 2014 to 2026 on the GATE CS PYQ archive.

For where OS fits among all the subjects, see the GATE CSE 2027 month-by-month study plan.

Best Books for GATE CS Operating Systems

Skip the chapters on security, protection, virtual machines, distributed systems and the Linux and Windows case studies, which are not on the GATE CS syllabus. For other subjects, see our best books for GATE CSE 2027.

The full course, covering all subjects with lectures and mock tests, is on the GATE CS course page.

Common Mistakes in GATE OS

• Assuming n forks always make 2ⁿ processes. Check what each branch does with the return value (Example 1).
• Mixing bits and bytes in page table and TLB size calculations.
• Not re-checking the queue at each arrival under SRTF and preemptive priority scheduling.
• Treating a thread's stack as shared. Threads share code, data and files, but each has its own stack and registers.
• Using n × m instead of n(m − 1) + 1 for the minimum resources that prevent deadlock.

Key Takeaways

• OS averaged 7.6 marks per paper (7.6% of the paper) across 23 official GATE CS papers (2014–2026), and 7.8 from 2021.
• Memory management is the largest topic, at 54 marks overall and about 2.7 marks per paper since 2021.
• Processes and threads tripled to about 1.5 marks per paper, while deadlock halved to about 0.7.
• NATs carried 45% of OS marks from 2021 to 2026. Practise calculating to an exact final answer.

Frequently Asked Questions

How many marks does Operating System carry in GATE CS?

The official pattern does not fix marks per CS subject. Across all 23 official GATE CS papers from 2014 to 2026, OS averaged 7.6 marks per paper, which is 7.6% of the 100-mark paper, with a range of 5 to 10. It has averaged 7.8 marks since 2021.

Which OS topics are most important for GATE CS 2027?

Memory management and virtual memory carry the most marks (54 across 23 papers), followed by CPU scheduling, synchronization and deadlock. Processes and threads have grown the fastest since 2021.

Is OS hard to score in GATE CS?

OS has more hard questions than most subjects: Success Tracker rates 20 of 108 as hard. Most of the difficulty is in the calculations rather than the concepts, though. A fixed method for paging, scheduling and deadlock questions removes most of it.

Which book is best for OS for GATE CS?

Operating System Concepts by Silberschatz, Galvin and Gagne (the "Galvin" book) covers the full syllabus. Operating Systems: Three Easy Pieces is a good free companion for virtual memory and concurrency.

Is disk scheduling in the GATE CS 2027 syllabus?

The official syllabus lists "CPU and I/O scheduling", which covers disk scheduling algorithms such as FCFS, SSTF, SCAN and C-SCAN. GATE CS asked 5 disk scheduling questions between 2014 and 2020 (9 marks) and none from 2021 to 2026, so revise it but give it less time than memory management.

Where can I practise GATE CS OS PYQs?

Every GATE CS question from 2014 to 2026 is free on Success Tracker's GATE CS PYQ archive, with the official answer and a worked solution.

Next in This Series

• Algorithms for GATE CS 2027: weightage, PYQs and plan
• DBMS for GATE CS 2027: weightage, PYQs and plan
• Discrete Mathematics for GATE CS 2027
• GATE CSE subject-wise weightage
• GATE CS 2027 complete guide

Sources

• GATE 2027 CS Syllabus (PDF), IIT Madras: Section 8, Operating System
• GATE 2026 CS Syllabus (PDF), IIT Guwahati
• GATE 2027 Question Paper Pattern, IIT Madras: marks distribution and negative marking
• Official GATE CS question papers and answer keys, 2014–2026 (23 papers), as reproduced on Success Tracker. Weightage figures are The ML Hub's own count, done on 25 October 2026.