Process Practice Questions

A context switch occurs when the OS saves the state of a currently running process and loads the state of another process. This causes the current process to move from the running state to a non-running state (ready or blocked).
(a) A timer interrupt is raised by the hardware: The OS scheduler gets control and might decide to switch to another process. This can trigger a context switch.
(b) P tries to access a page that is in the swap space, triggering a page fault: A page fault requires the OS to load the page from disk. This is a blocking operation, so the OS will block process P and perform a context switch to run another process or an I/O handler. This will always trigger a context switch.
(c) An interrupt is raised by the disk to deliver data requested by some other process: This interrupt signals completion of I/O for another process. While the OS will handle the interrupt, it doesn't necessarily cause a context switch from process P (unless P was blocked waiting for this I/O, which isn't specified). It might lead to the other process becoming ready, potentially causing a future context switch to that process, but not always from P.
(d) P makes a blocking system call to read a block of data from the disk: This is a blocking operation. Process P must wait for the I/O to complete, so the OS will move P to the blocked state and perform a context switch to another process. This will always trigger a context switch.
Therefore, (b) and (d) will always trigger a context switch by the OS resulting in process P moving to a non-running state.

Let's examine the possible process state transitions:

1. Waiting to Running: A process in the Waiting state is waiting for an event (like I/O completion). It cannot directly transition to Running. It must first move to the Ready state when the event occurs, and then the scheduler can dispatch it to Running. So, Waiting to Running is NOT possible.
2. Ready to Waiting: A process in the Ready state is waiting for the CPU. It cannot transition to Waiting from Ready. It first needs to be running to initiate an I/O operation and then move to Waiting. So, Ready to Waiting is NOT possible.
3. Running to Terminated: A process in the Running state finishes its execution or is explicitly killed. It transitions to the Terminated state. This is possible.
4. Running to Ready: A running process might be preempted by the scheduler (e.g., due to a time slice expiry) and moved back to the Ready state. This is possible.

Therefore, the process state transitions that are NOT possible are Waiting to Running and Ready to Waiting.

Here's a step-by-step explanation for the given question:

A preemptive scheduling system allows the operating system to interrupt a running process and move it to the ready state. This means statement I is true.

A ready process is one that is waiting for the CPU. When the CPU becomes free, the scheduler can pick a ready process and move it to the running state. This makes statement II true.

A blocked process is waiting for an I/O event or resource. It cannot directly move to the running state; it must first transition to the ready state once the event completes. Therefore, statement III is false.

Once a blocked process's waiting event (e.g., I/O completion) occurs, it transitions to the ready state, from where it can then be scheduled to run. This means statement IV is true.

Thus, statements I, II, and IV are true.

The dispatcher is the module that gives control of the CPU to the process selected by the scheduler. Dispatch latency is defined as the time it takes for the dispatcher to stop one process and start running another one. This process involves saving the state of the current process, loading the state of the new process, and switching to the user mode. If we denote $T_{stop}$ as the time the process is halted and $T_{start}$ as the time the new process begins, the latency is effectively $T_{switch} = T_{start} - T_{stop}$. Thus, it represents the overhead associated with context switching.

Operating systems ensure memory isolation through hardware support for memory protection. The system utilizes two specific hardware registers: the relocation (or base) register and the limit register. For every memory access request $A$ generated by the CPU, the hardware automatically verifies if the address lies within the valid range, specifically checking $base \leq A < base + limit$. If the address falls outside this defined boundary, the hardware triggers a trap, preventing any process from modifying restricted memory space. Consequently, this continuous hardware validation mechanism protects the OS and other processes from illegal access.

The Working Set, often denoted as $W(t, \Delta)$, is defined as the set of unique pages referenced by a process during a specific time interval $(t-\Delta, t)$. Here, $\Delta$ represents the length of the time window. Among the given choices, option D accurately describes this concept by defining the working set as the collection of pages referenced within the preceding time duration, which is the standard definition of the working set model.

The number of CPUs in a system determines the maximum number of processes that can be in the Running state simultaneously. The Ready state, however, contains processes that are loaded in memory and are waiting for CPU time. The size of the ready queue is not constrained by the number of CPUs but rather by the amount of available system memory and operating system limits. A single-CPU system can have many processes in its ready queue. Therefore, the maximum number of processes in the Ready state is independent of n.

The Round-Robin algorithm cyclically schedules processes $P_1, P_2, \dots, P_n$ by assigning a fixed time slice to each in a First-In-First-Out (FIFO) order. After a process uses its time slice, it is moved to the back of the ready list, requiring a structure that handles this wraparound efficiently. While a linear queue manages FIFO order, a circular queue is superior because it naturally models the cyclic transition from the last process back to the first without requiring expensive memory shifting or re-allocation. Thus, the circular queue is the most optimized data structure for maintaining the cyclic ready list in Round-Robin scheduling.

A process is initially in the 'Running' state while utilizing the CPU to execute instructions. When an I/O instruction is encountered, the process must wait for the slower external device to finish its operation before it can proceed. Because the process cannot continue execution without the I/O completion, the operating system moves it from the 'Running' state to the 'Blocked' (or 'Waiting') state. This transition effectively frees the CPU to be scheduled for other processes while the I/O request is being handled asynchronously. Thus, the process state becomes 'Blocked'.

When the currently running process requests I/O, it must transition from the Running state to the Blocked state. This process requires two distinct context switch operations:

1. The first switch involves saving the state (context) of the currently running process to its Process Control Block ($PCB$).
2. The second switch involves loading the saved state (context) of the next process selected from the ready queue into the CPU registers.

Because one process is removed and another is initiated, a total of 2 process switches take place.

In operating systems, a program is a passive entity, such as an executable file stored on the disk. A process is the active, dynamic entity that exists when the operating system loads the program into memory and begins executing its instructions on the CPU. Unlike a static program, a process includes the current activity, represented by the program counter, stack, and data segments. Consequently, a process is fundamentally defined as a program in execution.

In an operating system, the transition of a process from the "Ready" state to the "Running" state occurs when the scheduler selects a process from the ready queue and allocates the CPU to it. This action is formally defined as the "Dispatch" transition, represented as $Ready \rightarrow Running$. Conversely, "Wake Up" typically moves a process from Blocked to Ready, "Block" moves a process from Running to Blocked, and "Timer runout" moves a process from Running to Ready. Since "Dispatch" is the only option that correctly maps the name of the transition to the specified state change, it is the correct definition.

Based on the provided process state transition diagram:

1. Statement I is False: Transition D (Running to Terminated) signifies a process finishing. It does not force a new process to enter the system (Transition A); rather, the scheduler simply selects the next process from the ready state (Transition B).
2. Statement II is True: Transition E (Blocked to Ready) represents an I/O completion or event. This asynchronous event can occur while the CPU is busy executing a different process (P1) in the Running state.
3. Statement III is True: The diagram explicitly includes transition C (Running to Ready), which is the standard representation of preemption where a running process is interrupted by the OS and returned to the ready queue.
4. Statement IV is False: Since the system supports preemption (Transition C exists), it is a preemptive scheduling system, not non-preemptive.

Thus, only statements II and III are true.

In computing, a spooler is a specialized software program designed to manage "Simultaneous Peripheral Operations On-Line" (SPOOL) by organizing incoming tasks. It operates by capturing data destined for peripheral devices, like printers, and storing it in a temporary buffer, effectively creating a job queue to ensure tasks are processed sequentially without system delay. Other options are incorrect: a driver handles hardware communication, an interpreter translates source code, and a linkage editor merges object modules into an executable. Therefore, the spooler is the dedicated component for managing job queues.

A context switch involves saving the state of a process-including the Program Counter, Stack Pointer, and General Purpose Registers-into its Process Control Block (PCB) to resume execution later. These registers store process-specific execution data that is essential for continuity. In contrast, the Translation Look-aside Buffer (TLB) caches virtual-to-physical address mappings specific to the current process's page table. When a process switch occurs, the TLB is typically flushed or invalidated because these cached mappings are generally irrelevant to the new process's address space. Thus, the TLB contents are not preserved or restored in the PCB.

A context switch requires saving the architectural state of the current process to its Process Control Block ($PCB$) to enable later resumption. The Program Counter ($PC$) and general-purpose registers are fundamental to this state and must be saved to ensure execution continuity. Conversely, the Translation Look-aside Buffer ($TLB$) acts as a volatile cache for memory address mappings. Modern hardware typically either tags $TLB$ entries with an Address Space Identifier ($ASID$) to distinguish processes or simply invalidates (flushes) the cache upon switching, meaning its contents are not saved to memory. Thus, the $TLB$ need not be saved.

Checkpointing is a fault-tolerance mechanism that saves the current state $S$ of a process-including memory contents and register values-to stable storage. By preserving this state, the system creates a restart point. If a system failure or preemption occurs, the job can load state $S$ to resume execution from the exact point of the last checkpoint, rather than starting from the beginning. This functionality directly enables the job to continue executing later after an interruption. accurately describes the utility of checkpointing.

Multi-tasking is an operating system feature that allows a computer to execute multiple processes concurrently. It achieves this by rapidly switching the CPU among various tasks, often using time-slicing techniques, which creates the illusion of simultaneous execution to the user. Other options like Partitioning and Paging relate specifically to memory management, while Windowing refers to the graphical interface presentation. Thus, the correct term for this concurrent execution technique is multi-tasking.

In operating system process management, a process enters the "Blocked" (or "Waiting") state when it cannot continue execution because it requires an external resource or event. Unlike a "Ready" process, which is waiting for $CPU$ allocation in the run queues, a blocked process is ineligible for execution until the specific dependency is satisfied. Options A and B are incorrect because blocked processes are neither executable nor currently running. Option C is incorrect because a blocked task is removed from the run queues while waiting. Thus, a task in a blocked state is suspended because it is waiting for some temporarily unavailable resources, such as I/O completion or a synchronization lock.