Operating System for GATE CSE 2027: Syllabus, Weightage, Notes, Formulas & PYQ Strategy

When one associates every subject associated with Operating Systems to a real-world query, it makes the study process easier. Which process runs on the CPU next?

What will occur when two different threads make a change to a specific variable? How will a program retrieve the data from disk that is not loaded on the RAM now?

All these queries are related to the following subjects, namely: scheduling, synchronization, virtual memory, etc. In order to plan for GATE exams efficiently, you have to understand the basic principles and work with the practical applications of the concepts studied.

Operating System Topics to Cover

Use this as a study checklist and compare it with the official syllabus for your examination year.

Important Operating System Topics for GATE CSE 2027

If you're preparing Operating Systems for GATE CSE 2027 some topics need practice than others. Focus on the following areas while solving previous-year questions (PYQs).

1. Paging and Virtual Memory: Learn how to calculate page table size TLB hit ratio and effective access time. These are frequent in exams. Need clear understanding.
2. Page Replacement: Practice FIFO, LRU and Optimal page replacement algorithms. Understand why Brady's anomaly occurs. It’s not about applying the algorithm. Know the why behind it.
3. CPU Scheduling: Solve questions based on SRTF, Round Robin waiting time and turnaround time. These problems test your ability to calculate and compare.
4. Process Synchronization: Understand semaphores, critical sections, race conditions and synchronization problems. Real-life examples help remember these concepts
5. Deadlocks: Practise Bankers algorithm. Learn how to identify safe sequences. Many students get confused here. Practice step by step.
6. Deadlock-Free Resource Allocation: Learn how to calculate the number of resources required to avoid deadlocks. This one is tricky but important.
7. File Systems: Understand inodes, file allocation methods and maximum file size calculations. Don’t skip the math part. It’s often asked.
8. Disk Scheduling: Practice FCFS, SSTF, SCAN and C-SCAN problems involving head movement. Draw the disk arm movement. It helps visualize and avoid mistakes.

Important Formulas for GATE Operating Systems

• Turnaround Time = Completion Time. Arrival Time
• Waiting Time = Turnaround Time minus Burst Time
• Page Table Size = Number of page table entries multiplied by Size of each entry
• Number of Pages = Virtual Address Space divided by Page Size
• Effective Access Time (EAT): Depends on the memory access time TLB hit ratio and page fault rate.

How to Prepare for Operating Systems

• Start with the basics of processes, threads and CPU scheduling.
• Practise numerical questions on paging, page replacement and scheduling algorithms.
• Understand semaphore-based problems of memorising code.
• Solve GATE Previous Year Questions topic by topic and review every answer.
• Revise. Tricky concepts regularly before attempting mock tests.

Preparation tip: Don't skip a topic just because it seems difficult. A few focused practice sessions can help you understand common question patterns and avoid mistakes in the exam.

Note: Treat the weightage in your table as a trend, not a fixed prediction. The number of questions and marks from each topic can vary from year to year.

Types of Operating Systems

System Calls in Operating System

I see a system call as the way a user program asks the kernel for a service, such as fork, exec, read, write or open. I notice that the system call switches the CPU from user mode to kernel mode by using a trap. I understand that the system call then runs the kernel routine and finally returns the CPU to user mode. I observe that library functions such as printf wrap system calls but library functions are not system calls themselves.

Kernel in Operating System, User Mode vs Kernel Mode

I know that the kernel is the part of the OS that runs with full hardware privilege. I notice that a mode bit in the CPU tells whether code runs in user mode or kernel mode. I understand that user mode is restricted while kernel mode is privileged. I see that instructions such as I/O access and changing memory mapping are privileged; if a privileged instruction runs, in user mode a trap is raised.

Monolithic Kernel vs Microkernel

Booting Process in Operating System

Power on firmware (BIOS or UEFI) runs a power-on self test, finds a boot device, loads the bootloader, which loads the kernel into memory, and the kernel starts the first process and the rest of the system.

Where GATE sets the trap: a library call is not a system call, and the mode bit changes on a trap, not on a normal function call.

GATE OS Formula Sheet

Process Management in Operating Systems

A process is a program that is running. The OS manages the creation of a process, the time that a process uses the CPU, the resources that a process uses and the termination of a process.

A process moves through five states: Ready, Running, Waiting and Terminated. In the Ready state a process waits for the CPU. In the Waiting state a process waits for an event, such as an I/O operation to finish.

The Process Control Block (PCB) holds information about a process, such as the ID of a process, the state of a process, the CPU context of a process and the resource details of a process. During a context switch the OS saves the context of one process. Restores the context of another process.

Memory Management in OS

The OS gives memory to processes, keeps each process's memory area safe and handles memory use in a way.

Logical, vs Physical Address

• The CPU makes addresses and the MMU changes those addresses into physical memory addresses.
• Contiguous fragmentation
• First Fit: the block that fits.
• Best Fit: the block that's just right.
• Worst Fit: the block.
• Internal Fragmentation: space that is not used inside a block that is given out.
• External Fragmentation: memory that is broken into pieces.

Paging and Multilevel Paging

Physical memory uses frames while logical memory uses equal‑sized pages. The page table maps pages to frames.

Formula:

Page table size = Number of entries × Entry size

Example: a 32‑bit address, with 4 KB pages has a 12‑bit offset and a 20‑bit page number. With 4‑byte entries the page table size is 4 MB.

Multilevel paging divides page tables into levels to save memory.

TLB (Translation Lookaside Buffer)

The TLB caches recent page table entries.

Effective Access Time (EAT):

EAT = h(t + m) + (1 − h)(t + 2m)

Here, h = hit ratio, t = TLB access time, and m = memory access time.

Inverted Page Table

Uses one entry per physical frame, reducing page table memory but requiring efficient lookup.

Paging vs Segmentation

GATE Tip: Check address bits, page size, and entry size carefully in numericals.

Virtual Memory

Demand Paging and Page Faults

Demand paging loads pages on an "as needed" basis. When a requested page is not available in RAM, it results in a page fault.

• EAT = (1 − p)m + ps
• where p = page fault rate, m = memory access time, and s = page fault service time.
• Page Replacement Algorithms
• FIFO: Replaces the oldest page.
• LRU: Replaces the least recently used page.
• Optimal: Replaces the page that will not be used for the longest time.
• Belady's Anomaly
• The FIFO page replacement algorithm, unfortunately, might result in an increased number of page faults when it is provided with additional frames. The LRU algorithm and the Optimal algorithm do not have an anomaly.
• Thrashing and Working Set
• Thrashing is a process that happens when page faults reduce the performance of the CPU. The working set is that part of the working memory that has the pages that are used over a recent time window.

GATE Tip: Consider the initial loading of pages as page faults.

An inode holds file metadata and block pointers. With D direct pointers and one pointer at each indirect level, its addressable file capacity is:

Maximum file size=D+n+n2+n3B,n=BP

Here, B is block size and P is pointer size.

Directories may use single-level, two-level, tree or graph structures. Free space is tracked using bitmaps, linked lists, grouping or counting.

• For inode numericals, convert block and pointer sizes to the same unit first.
• Disk access time involves seek time, rotational latency and transfer time.
• Disk Scheduling Algorithms
• FCFS: Handles requests in the order they arrive.
• SSTF: Choose the request that's nearest.
• SCAN: Moves to the end of the disk before turning
• C-SCAN: Moves in one direction. Then go back to the start.
• LOOK: Reverses direction at the pending request.
• C-LOOK: Jumps from the pending request, to the first pending request.

Example Numerical

Queue: 82, 170 43 140 24 16 190. Initial head: 50.

Assumption: Cylinders 0–199, moving upward first for SCAN and LOOK.

Spooling vs Buffering

• Buffering: Temporarily stores data in memory during transfer.
• Spooling: Stores jobs on disk for processing by a slower device, such as a printer.

Final Revision Tip: Focus on paging formulas, page replacement, inode calculations, and disk scheduling numericals. Practise GATE PYQs after each topic.

Operating System Short Notes for GATE

Write one page per unit, with only definitions you could be asked, the formula, one worked example and your own trap list. Re-read your notes, not the textbook.

Operating System GATE Revision Plan