Process Management: States and Process Control Block (PCB)

This chapter dives deep into the fundamentals of process management in operating systems, exploring the precise distinction between programs and processes, the internal data structures that manage them (PCB), the lifecycle states a process transitions through, and the mechanics of context switching.

1. Quick Recap: Specialized Operating Systems (Real-Time, Distributed, and Embedded)

Before delving into process management, it is essential to categorize the specialized environments where modern operating systems execute:

• Real-Time Operating Systems (RTOS): Designed for mission-critical applications with strict time constraints. Deadlines must always be met.
  • Hard RTOS: Zero tolerance for deadline misses (e.g., flight control systems, medical pacemakers).
  • Soft RTOS: Deadlines are important, but minor lag or delays are tolerable (e.g., media streaming).
  • Examples: FreeRTOS, VxWorks.
• Distributed Operating Systems: Multiple independent computers connected over a network that appear to the user as a single unified system (e.g., Google's infrastructure, Hadoop clusters).
• Embedded Operating Systems: Specialized OS built into dedicated hardware with limited resources (RAM, storage, processing power) to perform specific tasks (e.g., microwave controllers, smart TVs, mobile phone sub-systems like camera management).

2. What is a Process? (The Core Definition)

A process is formally defined as a program in execution.

• Active Entity: Unlike static code sitting on a disk, a process is actively running, utilizing system resources, and changing state.
• Resource Ownership: Every process requires its own dedicated memory space (RAM), registers, file descriptors, and execution state to function correctly.

Program (Static Code on Disk)
         |
         |  OS loader brings into memory and executes
         v
Process (Dynamic, Active Entity in RAM)

3. Program vs. Process: Key Differences

Interviewers and university exams frequently test the fundamental differences between a static program and an active process.

4. Process Components: The Process Control Block (PCB)

To manage multiple concurrent processes, the operating system maintains a dedicated data structure for each process known as the PCB (Process Control Block)—sometimes referred to as a Task Control Block.

Whenever a program is loaded into memory and becomes a process, the OS creates its PCB to store all vital bookkeeping information required to manage and resume it.

Major Fields inside a PCB:

1. Process ID (PID): Unique numerical identifier for the process.
2. Process State: Current operational status (New, Ready, Running, Waiting, Terminated).
3. Program Counter (PC): Points to the address of the next instruction to be executed for this process.
4. CPU Registers: Accumulators, index registers, stack pointers, and general-purpose registers that must be saved when interrupted.
5. Memory Management Information: Base/limit registers, page tables, or segment tables.
6. I/O Status Information: List of allocated I/O devices and open files.
7. Accounting Information: Amount of CPU time used, time limits, account numbers, job/process IDs.

5. The 5-State Process Model

In standard operating system architecture, a process traverses through distinct states during its lifecycle.

Detailed Breakdown of the 5 States:

1. New State: The process has just been created, but hasn't yet been admitted to the pool of executable processes by the operating system.
2. Ready State: The process has all necessary resources and memory allocated, and is waiting solely for a free CPU core to be assigned for execution.
3. Running State: The instructions of the process are actively being executed by the CPU. (Note: On a single-core CPU, only one process can be in the Running state at any given time).
4. Waiting (or Blocked) State: The process cannot continue execution until a specific event occurs or an I/O operation completes (e.g., waiting for user keyboard input or disk read).
5. Terminated (or Exit) State: The process has finished execution (either successfully or via an error abort), and the OS reclaims its memory and PCB resources.

6. Context Switching: Mechanics and Overhead

When the operating system stops executing Process A and switches over to execute Process B, it performs an operation called Context Switching.

Step-by-Step Context Switch Workflow:

1. Interrupt / Scheduler Trigger: A timer interrupt fires or Process A requests I/O, forcing the CPU to pause Process A.
2. Save State of Process A: The OS saves all current CPU register values, program counter, and execution state into PCB of Process A.
3. Load State of Process B: The OS retrieves the saved register values and program counter from the PCB of Process B.
4. Resume Execution: The CPU loads the new context and begins executing Process B.

The Cost of Context Switching (Pure Overhead):

• Wasted CPU Cycles: During the exact window where the OS is saving PCB-1 and loading PCB-2, no useful user-level computation happens.
• This idle administration time is referred to as pure overhead. If an OS performs context switches too frequently (known as thrashing or excessive scheduling overhead), system performance degrades drastically.

7. Summary and Key Takeaways

• Program vs. Process: A program is a passive, static block of code stored on disk, whereas a process is an active, dynamic entity currently executing in memory with its own resources.
• Real-Time Systems: RTOS categories are split into Hard RTOS (zero tolerance for missed deadlines) and Soft RTOS (minor lag tolerated).
• Distributed & Embedded OS: Distributed OS links multiple computers to appear as one (e.g., Hadoop), while Embedded OS runs on dedicated hardware for specific appliances (smart TVs, microwaves).
• Process Control Block (PCB): The central data structure holding all vital metadata for a process, including PID, state, program counter, CPU registers, and memory management pointers.
• 5-State Lifecycle: Processes transition through New, Ready, Running, Waiting (Blocked), and Terminated states.
• Context Switching: The mechanism of saving a running process's state into its PCB and loading another process's state to achieve multitasking.
• Overhead Reality: Context switching introduces pure system overhead because CPU cycles are consumed on administrative saving/loading rather than executing application logic.