Operating Systems: 5-Chapter Comprehensive Practice & 75 Verified MCQs

Question 1

What data structure does the operating system kernel use to store all execution state, program counter, CPU registers, and scheduling metadata for an individual process?

Accepted Answer

B. Process Control Block (PCB). The Process Control Block (PCB) is the central data structure in the OS kernel representing a process. It maintains the Process ID (PID), process state, program counter, CPU register snapshot, memory management limits, and open file descriptors.

Question 2

Which CPU scheduling algorithm is mathematically proven to produce the minimal average waiting time for a given set of stationary processes?

Accepted Answer

B. Shortest Job First (SJF) / Shortest Remaining Time First (SRTF). Shortest Job First (SJF) is provably optimal in terms of minimizing average waiting time because scheduling shorter jobs ahead of long jobs reduces the wait time of all subsequent processes more rapidly than any other order.

Question 3

What phenomenon occurs in Round Robin CPU scheduling when the time quantum is chosen to be extremely small (e.g., 1 microsecond)?

Accepted Answer

B. Excessive CPU time is wasted on context switching overhead rather than executing useful user instructions.. If the Round Robin time slice (quantum) is too small relative to context switch overhead (which takes 1–5 microseconds for register saving, cache invalidation, and TLB flushes), the CPU spends a substantial fraction of its cycles switching between processes rather than performing actual computation.

Question 4

Which of the following conditions is NOT one of Coffman's four necessary conditions for a deadlock to occur?

Accepted Answer

C. Preemption Allowed. The four Coffman conditions required for deadlock are: 1) Mutual Exclusion, 2) Hold and Wait, 3) NO Preemption (resources cannot be forcibly confiscated from a process), and 4) Circular Wait. If preemption IS allowed, deadlock is broken.

Question 5

What is 'Priority Inversion' in concurrent real-time systems, and how is it resolved?

Accepted Answer

B. A higher-priority process is blocked waiting for a lock held by a lower-priority process, while an intermediate-priority process preempts the lower one; resolved by Priority Inheritance.. Priority Inversion occurred famously on the Mars Pathfinder spacecraft. A low-priority thread acquired a mutex. Before releasing it, a medium-priority thread preempted it. A high-priority thread needing the mutex was indefinitely blocked behind the medium thread. The solution is 'Priority Inheritance': the low-priority thread temporarily inherits the high priority until releasing the mutex.

Question 6

What are the three mandatory requirements that any valid solution to the Critical Section problem must satisfy?

Accepted Answer

A. Mutual Exclusion, Progress, and Bounded Waiting. A critical section solution must guarantee: 1) Mutual Exclusion (only one process in the critical section at a time), 2) Progress (if no process is in the critical section, only processes wishing to enter participate in deciding who enters next), and 3) Bounded Waiting (a bound exists on the number of times others can enter after a process requests entry, preventing starvation).

Question 7

How does a Counting Semaphore initialized to value K differ functionally from a Binary Semaphore (Mutex)?

Accepted Answer

B. A counting semaphore controls access to a finite resource pool containing K identical resource units, allowing up to K concurrent threads.. A counting semaphore is initialized with integer value K representing the number of available identical resources. Calling wait() (P) decrements the counter; if the counter drops below 0, the thread blocks. Calling signal() (V) increments the counter and unblocks waiting threads. A binary semaphore is restricted to values 0 and 1.

Question 8

What is the primary role of the Translation Lookaside Buffer (TLB) in virtual memory architectures?

Accepted Answer

B. It is a high-speed hardware associative cache that stores recent virtual-to-physical page number translations, bypassing multi-level page table lookups in RAM.. Translating virtual addresses to physical frames across multi-level page tables requires multiple memory accesses per instruction. The TLB caches recently accessed page table entries in hardware. A TLB hit resolves the physical frame address in under 1 nanosecond, avoiding multiple memory bus round-trips.

Question 9

What counter-intuitive anomaly occurs with the First-In, First-Out (FIFO) page replacement algorithm, known as Bélády’s Anomaly?

Accepted Answer

B. Allocating MORE physical memory page frames can actually INCREASE the total number of page faults for certain reference strings.. Bélády’s Anomaly demonstrates that under the FIFO replacement policy, allocating a larger frame allocation (e.g., increasing frames from 3 to 4) can result in an increased number of page faults on specific reference strings. Algorithms belonging to the 'stack algorithms' class (such as LRU and Optimal) never suffer from Bélády’s Anomaly.

Question 10

What algorithm does an operating system execute to detect whether allocating requested resources will leave the system in a 'Safe State' during Deadlock Avoidance?

Accepted Answer

B. Banker's Algorithm. The Banker’s Algorithm tests resource requests by simulating the allocation of predetermined maximum possible amounts of all resources, checking whether a safe sequence exists where all processes can complete without deadlock. If a safe sequence exists, the allocation is granted; otherwise, the requesting process waits.

Question 11

What is the fundamental difference in execution model between User-Level Threads (ULT) and Kernel-Level Threads (KLT)?

Accepted Answer

B. User-level threads are managed by a runtime library in user space without kernel awareness (meaning one blocking syscall blocks the entire process); Kernel-level threads are managed directly by the OS scheduler, allowing true multi-core parallelism.. User-level threads are scheduled by a user-space library; thread switching requires no kernel mode transitions, making creation extremely lightweight. However, because the kernel sees only one process, if one user thread issues a blocking I/O call, all threads in that process stall. Kernel-level threads allow the OS to schedule separate threads across multiple physical CPU cores simultaneously.

Question 12

What is 'Thrashing' in an operating system virtual memory subsystem?

Accepted Answer

B. A condition where the operating system spends more time paging data in and out of swap space than executing application instructions, causing system throughput to collapse to near zero.. Thrashing occurs when the sum of the working set sizes of all active processes exceeds the available physical RAM. The OS constantly experiences page faults, repeatedly evicting pages only to immediately demand-page them back in from disk, stalling the CPU on disk I/O.

Question 13

What hardware CPU instruction provides atomic read-modify-write capability to implement mutual exclusion spinlocks without software race conditions?

Accepted Answer

B. Test-and-Set (TSL) or Compare-and-Swap (CAS). Hardware atomic instructions like Test-and-Set (TSL) or Compare-and-Swap (CAS) execute an read-modify-write cycle as an indivisible operation at the hardware bus/cache coherency level. This prevents any other CPU core from interleaving an access, providing the foundation for spinlocks and lock-free algorithms.

Question 14

In Linux and Unix operating systems, what is a 'Zombie Process'?

Accepted Answer

B. A process that has completed execution via exit(), but its entry remains in the process table because its parent has not yet read its exit status via wait() / waitpid().. When a process terminates, its memory space and open files are released, but its entry in the process table remains with status 'Z' so the parent process can read its termination exit code. Until the parent calls wait() or waitpid(), the process remains a zombie. If the parent terminates without waiting, the zombie is adopted by systemd/init (PID 1), which reaps it immediately.

Question 15

What is the primary difference between Hard Real-Time and Soft Real-Time operating systems?

Accepted Answer

B. In hard real-time systems, missing a deadline constitutes total system failure; in soft real-time systems, missing a deadline degrades service quality but does not cause catastrophic failure.. Hard real-time systems (e.g., pacemakers, anti-lock brakes, avionics flight controllers) require deterministic guarantees that tasks complete before their deadline, where any missed deadline represents catastrophic failure. Soft real-time systems (e.g., video streaming, gaming, VoIP) strive to meet deadlines, but occasional delays merely cause temporary glitching or frame drops without physical catastrophe.

Question 16

What is the Convoy Effect in First-Come, First-Served (FCFS) CPU scheduling?

Accepted Answer

B. Short CPU-bound processes and I/O-bound processes are forced to wait for long periods behind a heavy CPU-intensive process, resulting in severe degradation of CPU and device utilization. In non-preemptive FCFS, when a long CPU-burst process gains the CPU, all subsequent shorter processes (even those needing only 1ms) wait in the ready queue, dragging down average turnaround and response times.

Question 17

Why is Shortest Job First (SJF) scheduling provably optimal for minimizing average waiting time, and why is it difficult to implement in general-purpose interactive OS kernels?

Accepted Answer

B. It is mathematically optimal for average wait time, but predicting the exact length of the next CPU burst for arriving processes in advance is impossible. Moving shorter jobs ahead reduces waiting time for subsequent jobs more than it increases waiting time for longer jobs. However, the OS cannot know future burst lengths, resorting to exponential smoothing estimations.

Question 18

What happens in Shortest Remaining Time First (SRTF) when a new process arrives with a CPU burst shorter than the remaining burst of the currently running process?

Accepted Answer

B. The currently running process is preempted and returned to the Ready queue; the new process is allocated the CPU immediately. SRTF is the preemptive variant of SJF. Whenever a process arrives with a remaining burst strictly shorter than that of the active process, the CPU scheduler preempts the executing task.

Question 19

In Round Robin (RR) scheduling, what is the impact of choosing an excessively large vs an excessively small Time Quantum (Time Slice)?

Accepted Answer

A. Large quantum degrades to FCFS; extremely small quantum causes excessive context switch overhead that consumes substantial CPU capacity. If quantum q -> infinity, RR behaves as FCFS. If q is comparable to context switch time (e.g. 10 microseconds), the CPU spends a dominant percentage of its time switching process contexts rather than executing instructions.

Question 20

What phenomenon occurs in static Priority Scheduling when high-priority tasks continually enter the system, and what technique resolves it?

Accepted Answer

B. Starvation (Indefinite Blocking); resolved by Aging (gradually increasing the priority of processes that wait in the ready queue for long periods). Low-priority processes may wait indefinitely if high-priority jobs keep arriving. Aging steadily elevates the priority of waiting processes over time, guaranteeing eventual execution.

Question 21

How does a Multilevel Feedback Queue (MLFQ) scheduler dynamically categorize CPU-bound vs I/O-bound processes?

Accepted Answer

B. New processes enter the highest priority queue with a short time quantum; if a process uses its entire quantum without relinquishing the CPU, it is demoted to a lower queue; if it yields for I/O, it remains in high priority. MLFQ learns process behavior: interactive I/O-bound jobs yield quickly and stay in top-priority low-latency queues, while CPU-intensive batch jobs exhaust quantums and sink to background queues with larger slices.

Question 22

What is the Completely Fair Scheduler (CFS) used by the Linux kernel based upon?

Accepted Answer

B. A Red-Black Tree that orders tasks according to their virtual runtime (vruntime), always selecting the leftmost node with the least accrued execution time. CFS models an 'ideal multi-tasking CPU'. Each runnable task has a vruntime scaled by its 'nice' priority weight. Tasks are organized in a Red-Black Tree; CFS dispatches the process with minimum vruntime in O(log N) or O(1) cached time.

Question 23

What is the definition of Turnaround Time for a process?

Accepted Answer

B. The total time elapsed from the moment the process is submitted/created to the moment of its complete termination (Turnaround = Completion Time - Arrival Time). Turnaround time measures the entire lifespan of the process in the system: Completion Time - Arrival Time = Waiting Time + Execution (Burst) Time.

Question 24

What is Processor Affinity in symmetric multiprocessing (SMP) operating systems?

Accepted Answer

B. The tendency of an OS scheduler to keep a process running on the same physical CPU core to capitalize on warm L1/L2 hardware cache state ('cache affinity'). Migrating a process to another core invalidates cache entries, requiring costly main memory cache-line reloads. Schedulers maintain soft or hard processor affinity to avoid cache thrashing.

Question 25

In Real-Time Operating Systems (RTOS), what is Rate Monotonic Scheduling (RMS)?

Accepted Answer

B. A static priority preemptive algorithm that assigns priority inversely proportional to task period (shorter period = higher frequency = higher priority). RMS is the optimal static-priority scheduling algorithm for periodic real-time tasks. Tasks with shorter periods (higher rates) receive higher static priorities.

Question 26

How does Earliest Deadline First (EDF) differ from Rate Monotonic Scheduling (RMS)?

Accepted Answer

B. EDF dynamically assigns priorities at runtime based on deadlines: the task with the closest absolute deadline receives highest priority, achieving up to 100% theoretical CPU utilization. EDF is an optimal dynamic-priority real-time scheduling algorithm. As tasks run, deadlines shift, and priorities adjust dynamically, permitting 100% CPU schedulable utilization without missing deadlines.

Question 27

What is 'Response Time' in interactive operating systems?

Accepted Answer

B. Time elapsed from the submission of a request/process until the very first response or output is produced. In desktop and interactive systems, response time (time to start responding) is far more important to user perception than total turnaround time. Round Robin provides superior response times.

Question 28

What happens during Gang Scheduling in parallel computing environments?

Accepted Answer

B. A group of related parallel threads/processes that communicate frequently are scheduled to run simultaneously across multiple CPU cores at the exact same time quantum. When threads in a parallel program synchronize frequently using spinlocks or message passing, scheduling them at different times wastes cycles waiting. Gang scheduling co-schedules them across cores simultaneously.

Question 29

What is the primary difference between Preemptive and Non-Preemptive scheduling?

Accepted Answer

A. Preemptive scheduling allows the OS kernel to forcibly interrupt a running process to allocate the CPU to another task; Non-preemptive allows a process to hold the CPU until it voluntarily yields or terminates. In preemptive scheduling, hardware timer interrupts return control to the OS, which can context switch away. In cooperative/non-preemptive systems, a rogue infinite loop freezes the entire operating system.

Question 30

Given 3 processes arriving at time 0 with burst times P1=24ms, P2=3ms, P3=3ms under FCFS. What is the average waiting time?

Accepted Answer

A. 17 ms ((0 + 24 + 27) / 3 = 17 ms). Execution order: P1 [0-24], P2 [24-27], P3 [27-30]. Waiting times: P1 = 0, P2 = 24, P3 = 27. Average waiting time = (0 + 24 + 27) / 3 = 51 / 3 = 17 ms.

Question 31

What are the three mandatory requirements that any valid solution to the Critical Section Problem must satisfy?

Accepted Answer

B. Mutual Exclusion, Progress, and Bounded Waiting. 1) Mutual Exclusion: Only one process can execute in its critical section at a time. 2) Progress: If no process is in critical section, only processes wishing to enter can participate in selection. 3) Bounded Waiting: Bound on number of times other processes enter before a waiting process is granted entry.

Question 32

What is a Race Condition in concurrent software?

Accepted Answer

B. A situation where multiple concurrent threads access and manipulate shared data, and the final outcome depends unpredictably on the exact order or timing of thread execution. Race conditions occur when non-atomic read-modify-write sequences on shared memory are interleaved by the scheduler, leading to data corruption or silent loss of updates.

Question 33

How does Peterson's Algorithm achieve mutual exclusion between two processes in software?

Accepted Answer

B. Using two shared variables: a boolean flag[2] array indicating intention to enter, and an integer 'turn' variable indicating whose turn it is, with polite yielding ('turn = other'). Peterson's algorithm sets flag[i] = true and yields turn = j. Process i waits while 'flag[j] && turn == j'. This elegantly satisfies Mutual Exclusion, Progress, and Bounded Waiting for 2 processes.

Question 34

What is the architectural purpose of atomic hardware instructions such as Test-and-Set (TAS) and Compare-and-Swap (CAS)?

Accepted Answer

B. To perform read-modify-write memory operations in a single indivisible bus/cache cycle, providing the building blocks for lock-free data structures and OS mutexes. CAS atomically compares the contents of a memory location with a given value and, only if they match, modifies the contents to a new value. This indivisibility prevents race conditions without disabling hardware interrupts.

Question 35

What is the difference between a Counting Semaphore and a Binary Semaphore?

Accepted Answer

B. A binary semaphore's value ranges only between 0 and 1 (acting essentially as a mutex lock); a counting semaphore's value can range over an unrestricted integer domain to control access to a finite pool of N identical resources. Dijkstra defined semaphores with P (wait/decrement) and V (signal/increment) operations. Counting semaphores initialize to N available resources; when count reaches 0, subsequent wait() calls block.

Question 36

What is a Spinlock, and in what context is it preferred over a blocking mutex?

Accepted Answer

B. A lock where a thread waits in a tight busy-waiting loop ('spins') repeatedly testing lock availability; preferred on multi-core systems when the critical section is extremely short, avoiding expensive thread sleep/wakeup context switch overhead. Context switching takes ~1-3 microseconds. If a lock is held for only a few CPU clock cycles, spinning consumes fewer cycles than putting the thread to sleep and rescheduling it later. Spinlocks are forbidden on single-core systems without preemption.

Question 37

What is Priority Inversion and how did the Mars Pathfinder spacecraft encounter this classic synchronization bug in 1997?

Accepted Answer

B. A low-priority task held a shared mutex; a high-priority task blocked waiting for it; an intermediate medium-priority task preempted the low-priority task, starving the high-priority task indefinitely; fixed by Priority Inheritance. Pathfinder's information bus mutex was held by a low-priority meteorological task. Medium-priority communications tasks preempted it, preventing it from releasing the mutex needed by the critical high-priority attitude control thread, triggering watchdog system resets.

Question 38

What is a Monitor in programming language concurrency constructs (e.g. Java synchronized methods)?

Accepted Answer

B. A high-level synchronization abstraction that encapsulates shared variables and procedures, guaranteeing that only one thread can be active within the monitor at any given moment. Introduced by Hoare and Brinch Hansen, monitors eliminate error-prone manual semaphore wait/signal placement by automatically providing mutual exclusion to encapsulated methods, supplemented by condition variables (wait/notify).

Question 39

In the Classic Dining Philosophers Problem, how can deadlock be eliminated without restricting concurrency?

Accepted Answer

B. Allow an odd-numbered philosopher to pick up their left chopstick first and right second, while an even-numbered philosopher picks up right first and left second (asymmetric solution). If all 5 philosophers grab their left chopstick simultaneously, a circular wait deadlock occurs. Introducing asymmetry breaks the circular dependency condition, ensuring at least one philosopher can always eat.

Question 40

What is the Bounded-Buffer (Producer-Consumer) synchronization problem?

Accepted Answer

B. Producer threads generate data into a fixed-size buffer while consumer threads remove data; producers must block when buffer is full, consumers must block when buffer is empty, and access must be mutually exclusive. Solved using 3 semaphores: 'mutex' (binary, initialized to 1 for exclusive access), 'empty' (counting, initialized to Buffer Size N), and 'full' (counting, initialized to 0).

Question 41

In the Readers-Writers Problem, what is the consequence of giving strict preference/priority to Readers?

Accepted Answer

B. Writer starvation: if a continuous stream of reader threads keeps arriving, the shared read-count never drops to 0, leaving writer threads waiting indefinitely. First Readers-Writers problem allows multiple readers to read concurrently. If new readers arrive before older readers finish, the room is never vacated, starving writers. Second Readers-Writers problem prioritizes writers.

Question 42

What is the difference between Hoare (Signal-and-Wait) and Mesa (Signal-and-Continue) semantics in Monitor Condition Variables?

Accepted Answer

B. In Hoare semantics, the signaling thread yields CPU immediately to the awakened thread; in Mesa semantics (used in Java/POSIX), the signaling thread continues and awakened threads must re-check conditions in a 'while' loop. Under Mesa semantics, another thread might enter between signal and awakening. Therefore, threads must ALWAYS test conditions inside a while loop: 'while (!condition) { wait(); }' rather than an 'if' statement.

Question 43

What is a Futex (Fast Userspace Mutex) in Linux kernel architecture?

Accepted Answer

B. A synchronization mechanism where uncontended locking/unlocking is executed purely in user-space via atomic instructions (zero system call overhead), only invoking the kernel to sleep/wake threads when lock contention occurs. Syscalls are expensive. In 90%+ of cases, locks are uncontended. Futexes allow atomic CAS in userspace for uncontended paths, only transitioning to the kernel via sys_futex when a thread must actually sleep or be awakened.

Question 44

What is the ABA Problem in lock-free concurrent programming using Compare-and-Swap (CAS)?

Accepted Answer

B. Thread 1 reads value A; Thread 2 changes A to B and back to A; Thread 1 executes CAS(expected=A), which succeeds thinking nothing changed, despite intermediate node recycling and corrupted pointer state. CAS checks value equality, not mutation history. If a memory address is freed and reallocated with original value A, CAS erroneously succeeds. Resolved by pairing pointers with monotonic version stamps (Tagged Pointers).

Question 45

What is a Memory Barrier (Memory Fence) in multi-core CPU architecture?

Accepted Answer

B. A CPU instruction that enforces an ordering constraint on memory read and write operations, preventing compilers and out-of-order execution pipelines from reordering operations across the barrier. Modern superscalar processors reorder independent instructions for performance. In concurrent lock implementations, memory fences (e.g. MFENCE, acquire/release barriers) ensure writes are made visible to other cores before lock release.

Question 46

What are the Four Coffman Conditions that must hold simultaneously for a Deadlock to occur?

Accepted Answer

B. Mutual Exclusion, Hold and Wait, No Preemption, and Circular Wait. Edward G. Coffman Jr. proved in 1971 that deadlocks occur if and only if all four conditions hold: 1) Mutual Exclusion, 2) Hold and Wait, 3) No Preemption, 4) Circular Wait. Invalidating any ONE condition prevents deadlock.

Question 47

How can the 'Circular Wait' condition be eliminated to prevent deadlocks in complex software systems?

Accepted Answer

B. Impose a total global linear ordering on all resource types, requiring every process to request resources strictly in increasing numerical order. Assign each resource R_i a unique integer F(R_i). A process can request resource R_j only if F(R_j) > F(R_i) for all held resources. This mathematically prevents cycles from forming in the Resource Allocation Graph.

Question 48

In a Resource Allocation Graph (RAG), under what condition is the presence of a directed cycle a definitive, guaranteed indicator of a deadlock?

Accepted Answer

B. Only when every resource type in the graph has exactly ONE single instance. If each resource type has strictly 1 instance, a cycle is necessary AND sufficient for deadlock. If resource types have multiple instances, a cycle is necessary but NOT sufficient (a cycle may exist without deadlock if outside instances become free).

Question 49

What is the core premise of Dijkstra's Banker's Algorithm for Deadlock Avoidance?

Accepted Answer

B. Before granting any resource allocation request, the OS simulates the allocation to ensure that the system remains in a 'Safe State' (where at least one execution sequence exists that allows all processes to finish). The Banker's Algorithm maintains Max, Allocation, Need (Need = Max - Allocation), and Available vectors/matrices. A request is granted only if granting it leaves the system in a Safe State.

Question 50

Given Available = [3, 3, 2] and a process with Need = [1, 2, 2]. Can this process's request be granted under the Banker's Algorithm?

Accepted Answer

B. Yes, because Need <= Available component-wise ([1<=3, 2<=3, 2<=2] is TRUE). The safety algorithm checks if Need[i] <= Work. Since [1, 2, 2] <= [3, 3, 2] for all components, the system has sufficient free resources to satisfy the process's peak demand.

Question 51

What is the 'Ostrich Algorithm' approach to deadlocks, and why is it used by modern commodity OSes (Windows, Linux)?

Accepted Answer

B. Stick your head in the sand and pretend the problem never happens: ignore deadlocks because the runtime performance cost of continuous avoidance/prevention outweighs the rare occurrence of deadlocks, relying on user restarts. Banker's algorithm requires knowing maximum resource needs upfront and incurs heavy O(M * N^2) runtime overhead on every lock request. Commodity OSes favor speed and let rare deadlocked processes be killed by users or watchdog timers.

Question 52

What is the difference between Deadlock Prevention and Deadlock Avoidance?

Accepted Answer

B. Prevention structurally invalidates one of the 4 Coffman conditions at design time; Avoidance dynamically monitors runtime requests and circumvents entering unsafe states using process claim limits. Prevention imposes static design rules (e.g. require all locks at once, or lock ordering). Avoidance requires knowledge of future resource demands (e.g. Banker's algorithm) to avoid unsafe allocations dynamically.

Question 53

What is Livelock in concurrent systems?

Accepted Answer

B. Two or more processes actively change their execution states in response to each other without making any functional forward progress, continually consuming 100% CPU cycles while effectively remaining stuck. Like two polite people in a hallway repeatedly stepping to the same side simultaneously: unlike deadlock (where threads are blocked asleep), livelocked threads are active and running, but caught in a futile loop.

Question 54

When a deadlock detection algorithm identifies a deadlocked cycle, what are the primary recovery mechanisms?

Accepted Answer

B. Process Termination (aborting all deadlocked tasks or aborting one-by-one until cycle is broken) and Resource Preemption (successively preempting resources from victim processes and rolling them back to checkpoints). Recovery requires breaking the cycle by terminating processes (favoring lowest-cost victims) or preempting resources, rolling victim processes back to a safe checkpoint state.

Question 55

What is the computational complexity of the Banker's Safety Algorithm for N processes and M resource types?

Accepted Answer

B. O(M * N^2). In the worst case, finding a safe process takes O(M * N) comparisons, and this step may be repeated for all N processes, resulting in O(M * N^2) overall time complexity.

Question 56

What is a 'Wait-For Graph' (WFG) and how is it derived from a Resource Allocation Graph?

Accepted Answer

B. A collapsed variant of a single-instance RAG where resource nodes are removed and directed edges Pi -> Pj directly signify that process Pi is waiting for process Pj to release a needed resource. By removing resource nodes from a single-unit RAG and drawing direct edges between processes, WFG simplifies deadlock detection to classic cycle-finding algorithms (DFS) in O(V^2) or O(V + E) time.

Question 57

Why is 'Resource Preemption' difficult to implement for general computing resources during deadlock recovery?

Accepted Answer

B. Preempting resources like printers, tape drives, or partially written database tables leaves system state corrupted unless the process can be safely rolled back to a known clean checkpoint. Unlike CPU cores or RAM pages (which can be saved and restored easily), many devices have stateful, non-resumable physical interactions that cannot be preempted cleanly without checkpoint/rollback mechanisms.

Question 58

How does the 'Hold and Wait' condition prevention protocol work, and what is its operational downside?

Accepted Answer

A. Require processes to request all needed resources simultaneously before starting execution; downside: severely reduces resource utilization and can cause starvation for processes needing many resources. If a process must acquire everything upfront (or release current resources before requesting new ones), it never 'holds and waits'. However, resources allocated for later stages sit idle, wasting system capacity.

Question 59

What is 'Starvation' in the context of Deadlock Recovery victim selection?

Accepted Answer

B. If victim selection is based strictly on cost, the exact same low-priority process may be repeatedly chosen as victim and rolled back, never completing its execution. To prevent starvation, rollback count must be factored into cost: as a process is rolled back, its priority weight increases so it will not be victimized indefinitely.

Question 60

Can a system in an Unsafe State still avoid experiencing a deadlock?

Accepted Answer

B. Yes, because an unsafe state merely indicates that the OS can no longer GUARANTEE avoiding deadlock; if running processes do not request their maximum declared resources, no deadlock will occur. An unsafe state means there is at least one sequence of future requests that COULD lead to deadlock. If processes terminate without claiming their theoretical peak Max allocation, the system completes safely.

Question 61

What is the primary difference between Internal Fragmentation and External Fragmentation in memory management?

Accepted Answer

B. Internal fragmentation occurs when allocated memory blocks are larger than requested data (wasted space INSIDE allocated partitions, typical in Paging); External fragmentation occurs when total free memory is sufficient but broken into small scattered non-contiguous holes (typical in Segmentation). In paging, fixed page size (e.g. 4KB) means a 1-byte allocation wastes 4095 bytes inside the page (internal). In variable partitioning, allocating and freeing varying chunks creates unusable small gaps between allocated spaces (external).

Question 62

What is the role of the Translation Lookaside Buffer (TLB) in virtual memory address translation?

Accepted Answer

B. A high-speed hardware associative cache located inside the CPU MMU that caches recent Virtual Page Number (VPN) to Physical Frame Number (PFN) mappings to avoid multi-level page table memory lookups. Accessing RAM takes ~50-100ns. With 4-level page tables, translating an address without a cache requires 4 additional RAM accesses (~300ns). TLB lookups take <1ns, achieving 99%+ hit rates.

Question 63

What causes a Page Fault interrupt in an operating system?

Accepted Answer

B. The CPU attempts to access a virtual memory address whose page table entry has its 'Valid/Present' bit set to 0 (the page is either not allocated or currently swapped out on disk). When Present bit = 0, hardware MMU triggers trap to kernel page fault handler. The OS locates the page in swap space, allocates a free physical RAM frame, reads page from disk, updates page table (Valid=1), and restarts instruction.

Question 64

What is Belady's Anomaly in page replacement algorithms?

Accepted Answer

B. The counter-intuitive phenomenon where increasing the number of physical page frames results in an INCREASE in the number of page faults (observable in FIFO page replacement). Discovered by Laszlo Belady in 1969. While one expects more frames to reduce page faults, FIFO can produce MORE page faults with 4 frames than with 3 frames for certain reference strings (e.g. 1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, 5).

Operating Systems: 5-Chapter Comprehensive Practice & 75 Verified MCQs

Operating Systems: 5-Chapter Comprehensive Practice & 75 Verified MCQs

Explore Other Comprehensive 75-Question Subject Tracks

Queryiest

Queryiest – Technology Writer | Software Developer | Digital Learning Enthusiast

What is a database?

How to rotate an array in-place with O(1) space and ...

What steps can businesses take to identify the most valuable ...

Queryiest

Anonymous

paperubofficial