Processes

Process Fundamentals

A process is a program in execution — the unit of work in an OS. A program is passive (a file on disk); a process is active (has CPU state, memory, resources).

Each process has: an address space, CPU registers (saved when not running), open file descriptors, a priority, and accounting information — all stored in the Process Control Block (PCB).

Process Memory Layout

High address
┌─────────────────┐
│    Stack        │  ← grows downward (local vars, return addrs)
│       ↓         │
│   (gap)         │
│       ↑         │
│    Heap         │  ← grows upward (malloc/new)
├─────────────────┤
│  BSS segment    │  uninitialized global/static data (zeroed)
├─────────────────┤
│  Data segment   │  initialized global/static data
├─────────────────┤
│  Text segment   │  read-only code + constants
└─────────────────┘
Low address

Process Control Block (PCB) Fields

Process States

        admit
New ──────────→ Ready ←──────── Waiting
                  │    I/O done   ↑
           dispatch│              │ I/O request
                  ↓              │
               Running ──────────┘
                  │
            exit / abort
                  ↓
              Terminated

Process Creation

pid_t pid = fork();     // clone current process
if (pid == 0) {
    execve("/bin/ls", argv, envp);  // replace image
} else {
    wait(NULL);         // parent waits for child
}

• fork() duplicates parent → child gets a copy-on-write clone of address space
• exec*() replaces the process image (code, data, stack) — PID stays the same
• On Windows: CreateProcess() combines fork + exec in one call

fork() Return Values

Process Termination

Zombie: child terminated, parent hasn't called wait() — PCB still in table. Orphan: parent terminated before child — child re-parented to PID 1 (init/systemd).

Inter-Process Communication (IPC)

Pipe Example

int fd[2];
pipe(fd);          // fd[0]=read end, fd[1]=write end
if (fork() == 0) {
    close(fd[1]);
    read(fd[0], buf, sizeof(buf));
} else {
    close(fd[0]);
    write(fd[1], "hello", 5);
}

Context Switch

When the OS switches the CPU from process A to process B:

1. Save A's CPU registers into A's PCB
2. Update A's state (Ready or Waiting)
3. Load B's PCB registers into CPU
4. Update B's state to Running
5. Jump to B's saved PC

Cost: pure overhead — no useful work done. Typical cost: 1–10 µs (cache flush, TLB flush, register load).

Process Scheduling Queues

Long-term scheduler (job scheduler): decides which jobs enter the ready queue (admission control — mostly gone in modern systems). Short-term scheduler (CPU scheduler): picks which ready process gets the CPU next (runs every ~1–10 ms). Medium-term scheduler: swaps processes in/out of memory (handles degree of multiprogramming).