Operating Systems Guide | Interview Ready

Interview Guide

Operating Systems: Processes, Synchronization & Memory

A focused, interview-ready guide covering race conditions, critical sections, synchronization primitives, and memory management.

Contents

1. Overview
2. Race conditions & critical section
3. Synchronization primitives
4. Scheduling & processes
5. Memory management & virtual memory
6. Deadlock & avoidance
7. Practical tips for interviews
8. 10 Practice MCQs

Overview

Operating systems coordinate hardware and software, providing abstractions such as processes, threads, files, and virtual memory. They ensure isolation, manage resources, and provide services like process scheduling, memory allocation, and I/O handling.

Interviewers often probe OS topics because they reveal how you reason about concurrency, correctness, and trade-offs under constraints. This guide emphasizes core synchronization concepts from the classic producer-consumer problem through more advanced memory management issues.

Race conditions and the critical-section problem

A race condition occurs when multiple processes or threads access shared data concurrently and the final outcome depends on the order of their execution. The critical-section problem formalizes the need to protect regions of code that access shared resources.

Requirements for a correct solution to the critical-section problem are:

• Mutual exclusion: only one process in its critical section at a time.
• Progress: if no process is in the critical section, one that wants to enter should be able to decide who enters without delay.
• Bounded waiting: a process should not wait indefinitely while others repeatedly enter the critical section.

The producer-consumer bounded buffer example illustrates how naive shared counters (like count) produce incorrect behavior when increments and decrements interleave. On modern machines, even simple operations like count++ are multiple machine instructions, so concurrent updates need proper synchronization.

Synchronization primitives

Peterson's solution

Peterson's algorithm is a classic software-only solution for two processes using two shared variables, flag[2] and turn. Each process sets its flag and yields turn to the other, then waits while the other is interested and it's their turn. It satisfies mutual exclusion, progress, and bounded waiting (on sequentially consistent architectures) but can fail on some modern architectures due to instruction reordering or weak memory models.

Locks and mutexes

Most systems provide kernel or user-level mutexes that use atomic hardware support (compare-and-swap, test-and-set) to implement mutual exclusion efficiently. Mutexes are practical for general use and are the building block for higher-level primitives.

Semaphores

Semaphores are integer counters with two operations: wait(P) (decrement, blocking if value is zero) and signal(V) (increment). They express resource counts (counting semaphores) or mutual exclusion (binary semaphores). They are useful to solve producer-consumer, reader-writer, and other classic problems.

Monitors and condition variables

Monitors encapsulate shared data and procedures, providing mutual exclusion implicitly and condition variables for signaling. They simplify reasoning about concurrency by structuring access and signaling in language-level constructs.

Processes, threads, and scheduling

A process is an instance of a running program with its own address space; a thread is a schedulable unit of execution within a process that shares memory with sister threads. Scheduling algorithms (round-robin, priority, multi-level feedback queues) balance fairness, latency, and throughput.

Important interview points:

• Preemptive vs non-preemptive kernels: preemptive kernels allow interrupts and context switches even in kernel mode, improving responsiveness but increasing complexity for kernel developers.
• Context switch cost: saves/restores registers, TLB effects, cache warm-up—affects how you design concurrency.
• Thread vs process design: use threads for shared-memory parallelism; processes for strong isolation.

Memory management and virtual memory

Memory management provides each process with an address space and uses virtual memory to map virtual addresses to physical frames. Key topics include paging, segmentation, page replacement algorithms (LRU, CLOCK), and the Translation Lookaside Buffer (TLB).

Interviewers like concrete examples: explain page faults, what causes thrashing, and how to tune working set sizes. Discuss how shared libraries reduce memory duplication via copy-on-write and how kernel-level memory allocators differ from user-level allocators.

Deadlock: detection, prevention, and avoidance

Deadlock arises when processes hold resources while waiting for others; four necessary conditions are mutual exclusion, hold-and-wait, no preemption, and circular wait. Strategies:

• Prevention: design to eliminate one of the conditions (e.g., require processes request all resources at once).
• Avoidance: use the Banker’s algorithm to ensure safe states (costly and rarely used in general-purpose OSes).
• Detection and recovery: allow deadlocks, detect cycles in resource allocation graphs, and recover by killing or rolling back processes.

Practical interview tips

When asked an OS question in an interview, follow this pattern:

1. Clarify assumptions: single/multi-core, single/multi-threaded workload, and constraints (latency, throughput, power).
2. State the correctness properties you care about (safety: mutual exclusion; liveness: progress).
3. Propose a simple design and enumerate trade-offs: latency vs throughput, simplicity vs performance.
4. Provide a short test plan: what counters or logs you'd collect to verify behavior (e.g., event traces, perf counters).

Also be ready to sketch code for simple primitives (e.g., how to implement a semaphore using atomic operations) and explain pitfalls (race conditions under weak memory models, priority inversion).

10 Practice MCQs

1. What is a race condition? A scheduled interrupt An incorrect outcome from concurrent accesses depending on timing A type of deadlock A memory leak

2. Peterson's solution requires which shared variables? A mutex and a semaphore A lock variable only An array flag[2] and turn A condition variable

3. Which is true about semaphores? They are integer counters with wait/signal operations They always avoid deadlock They replace virtual memory They are a file-system primitive

4. Which scheduling algorithm favors short interactive tasks? FIFO Round-robin with large quantum Batch scheduling Round-robin with small quantum

5. What causes thrashing? High CPU utilization only Excessive page faults due to insufficient physical memory Too many semaphores Using a wrong file-system type

6. Which of the following is NOT a necessary condition for deadlock? Mutual exclusion Hold and wait Preemption allowed Circular wait

7. What is the main benefit of virtual memory? Provides each process with a private address space larger than physical memory Replaces scheduling Guarantees zero page faults Prevents race conditions

8. Which primitive helps avoid priority inversion? Semaphores only Priority inheritance LRU cache Virtual memory

9. What does context switching typically NOT involve? Saving registers Restoring registers TLB flush or effect Rewriting the program binary on disk

10. Which is a safe deadlock recovery action? Always abort all processes Disable virtual memory Detect and selectively kill or roll back processes Convert semaphores to mutexes automatically

Final notes

Mastering OS concepts requires both conceptual understanding and practical examples. Practice designing simple synchronization schemes, reason about correctness properties, and learn to measure behavior using tracing and counters. During interviews, be explicit about assumptions and trade-offs.

If you'd like, I can:

• Embed your attached infographic image into the workspace (update the filename in the hero).
• Adjust typography, spacing, or theme to match `p61.html` exactly.
• Export the MCQs to a printable or CSV format.