Questions: Processes and the Process Control Block

Question 1

Two users on the same Linux system both launch the same Python interpreter. User A's program sets a global variable `counter = 100`. Will User B's Python process see `counter = 100`?

• A. Yes — they share the same program binary, so they share global variables
• B. Yes — global variables in Python are shared across all instances of the interpreter
• C. No — each process has its own isolated address space; changes in one process's memory are invisible to the other
• D. It depends on whether both processes are running at exactly the same time

Answer: (C)

Two processes running the same program binary maintain completely separate address spaces. User A's `counter` and User B's `counter` may share the same virtual address, but they map to different physical memory locations managed by separate page tables. Process isolation is the default — not sharing — enforced by the hardware MMU. If processes need to share data, they must use explicit IPC mechanisms (shared memory segments, pipes, sockets, etc.).

Question 2

During a context switch from Process A to Process B, what must the operating system do?

• A. Save only Process A's program counter to its PCB, since it is the only register that changes between processes
• B. Write Process A's entire address space to disk before loading Process B
• C. Save all of Process A's register values to its PCB, then load all of Process B's saved register values from its PCB
• D. Restart Process B from the beginning of its program to ensure a clean execution environment

Answer: (C)

A context switch saves the complete CPU state of the departing process — all register values including the program counter, stack pointer, and general-purpose registers — into its PCB. Then it loads the incoming process's saved register values from its PCB. This save-restore cycle is what enables multitasking: Process B resumes exactly where it left off, as if it had never stopped. The illusion of simultaneous execution is created by switching between processes fast enough that users don't notice.

Question 3

Two instances of the same program running simultaneously share the same address space, allowing each to access the other's variables.

• T. True
• F. False

Answer: False

Each process has its own completely isolated address space, even when running the same program binary. The code (text segment) may come from the same file on disk, but each process's stack, heap, and data segment occupy separate physical memory locations managed by separate page tables. One process cannot read or modify another's data without explicit OS-mediated IPC. This isolation is a fundamental OS guarantee enforced by the hardware memory management unit.

Question 4

The Process Control Block (PCB) contains all the information the OS needs to pause and correctly resume a process.

• T. True
• F. False

Answer: True

The PCB stores the process's complete execution context: saved register values (including the program counter), process state, memory management information (page tables), open file descriptors, scheduling data, and I/O status. During a context switch, the OS saves the running process's CPU state into its PCB and loads the next process's saved state from its PCB. With this snapshot, the OS can resume the process exactly where it left off — this is the mechanism behind multitasking.

Question 5

Explain the difference between a program and a process, and why two processes running the same program cannot interfere with each other's data.

Model answer: A program is a passive file on disk — compiled code waiting to be executed. A process is a program in execution: an active entity with its own CPU state (registers, program counter), memory segments (text, data, heap, stack), and OS resources. The OS gives each process its own isolated virtual address space, and the hardware MMU enforces that the same virtual address in two different processes maps to different physical memory. Neither process can read or write the other's memory without explicit OS-mediated IPC mechanisms.

This distinction changes how you reason about bugs and security. A memory corruption bug in one process cannot propagate to another. A crash in Process A cannot take down Process B. Two users running the same program cannot observe each other's data. Process isolation is one of the core abstractions the OS provides, and the PCB is the data structure that makes save-and-restore possible.