Process Concept — Scheduling, Operations & Inter-Process Communication

What Is a Process? — The Program Comes Alive

In Galvin's words: "A process is a program in execution." But it is more than just code — a process is a container of context. The operating system must track every process's state, resources, and progress so it can pause one, run another, and resume the first exactly where it stopped.

Process States — The Life Cycle

A process is never just "running." It shifts through five states during its lifetime, driven by scheduler decisions, I/O events, and user actions. Galvin's state diagram is the foundation of everything that follows in scheduling and IPC.

The Process Control Block (PCB)

For every process, the OS keeps one struct in kernel memory called the Process Control Block — Linux calls it task_struct, Windows calls it EPROCESS. This is the process's identity card. When the CPU switches away from a process, everything needed to resume it is saved here.

Introduction to Process Scheduling

Modern computers run dozens to hundreds of processes but have only a handful of CPU cores. Process scheduling is how the OS decides which ready process gets the CPU next, and for how long. The goal is to keep the CPU busy (utilisation), finish many jobs per second (throughput), and keep interactive users happy (short response time).

Scheduling Queues

The OS maintains several queues. Newly created processes enter the job queue. Processes in memory ready to run sit in the ready queue. Processes waiting for a specific device sit in a device queue (one per device).

The Three Schedulers

Context Switching — The Hidden Cost

When the CPU switches from process A to process B, it must save all of A's registers into A's PCB and load B's registers from B's PCB. This is pure overhead — no useful work is done during the switch. Times range from 1 to 1000 microseconds depending on hardware.

Operations on Processes

The OS exposes a small set of system calls that create, destroy, and manage processes. On UNIX/Linux these are fork(), exec(), wait(), and exit(). On Windows the equivalents are CreateProcess(), WaitForSingleObject(), and ExitProcess(). Every shell command, every double-clicked app goes through them.

Process Creation — The Parent/Child Tree

A process creates other processes. The creator is the parent; the created is the child. Every process (except init/systemd, PID 1) has exactly one parent, forming a tree. Run pstree on Linux to see it.

fork() — Cloning a Process

fork() creates an exact copy of the calling process. After the call, two processes exist: parent and child, both running the same code from the line just after fork. The only difference is the return value — the child gets 0, the parent gets the child's PID.

/* fork_demo.c — the classic Galvin example */
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>

int main() {
    pid_t pid = fork();       // clones this process

    if (pid < 0) {
        perror("fork failed");
        return 1;
    }
    else if (pid == 0) {
        // Child process — fork returned 0 here
        printf("Child: my PID is %d, parent is %d\n",
               getpid(), getppid());
    }
    else {
        // Parent process — fork returned the child's PID
        printf("Parent: my PID is %d, child is %d\n",
               getpid(), pid);
        wait(NULL);   // wait for child to finish
    }
    return 0;
}

exec() — Replacing the Program

fork() gives you a duplicate. To run a different program you follow it with exec(), which replaces the current process's memory image with a new executable while keeping the same PID. This is exactly how a shell runs commands.

/* shell.c — how "ls -l" runs from your terminal */
#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>

int main() {
    pid_t pid = fork();

    if (pid == 0) {
        // Child replaces itself with /bin/ls
        execlp("/bin/ls", "ls", "-l", NULL);
        perror("exec failed");   // only reached if exec fails
    }
    else {
        // Parent waits for the child to finish
        wait(NULL);
        printf("Child done. Shell prompt again.\n");
    }
    return 0;
}

wait() and exit() — Cleanup

When a process finishes, it calls exit(status). Its PCB is kept as a zombie until the parent calls wait() to collect the exit code. If a parent dies before its child, the child becomes an orphan and is re-parented to init (PID 1) which cleans it up.

Process Termination

Inter-Process Communication (IPC)

Processes are, by design, isolated — one process cannot read another's memory (that's what segmentation faults protect). But cooperating processes need to exchange data. IPC is the set of mechanisms the OS provides for that exchange.

Independent vs Cooperating Processes

The Two IPC Models

Comparing the Two Models

Producer–Consumer — The Classic IPC Problem

Galvin uses this problem to illustrate cooperating processes. A producer generates items (say, print jobs) and puts them in a shared buffer. A consumer takes items out and processes them (prints). Two problems arise: the buffer might be full when the producer wants to add, or empty when the consumer wants to remove.

/* Bounded-buffer producer / consumer using shared memory */
#define BUFFER_SIZE 10

typedef struct { int data; } item;

item  buffer[BUFFER_SIZE];
int   in  = 0;   // next free slot
int   out = 0;   // next full slot

/* Producer: add item to buffer */
while (((in + 1) % BUFFER_SIZE) == out)
    ;                       // buffer full — busy wait
buffer[in] = next_produced;
in = (in + 1) % BUFFER_SIZE;

/* Consumer: remove item from buffer */
while (in == out)
    ;                       // buffer empty — busy wait
next_consumed = buffer[out];
out = (out + 1) % BUFFER_SIZE;

IPC Mechanism 1 — Pipes

Pipes are the oldest UNIX IPC mechanism. A pipe is a one-way byte stream between two related processes — one writes, the other reads. This is exactly the | in shell commands.

/* pipe_demo.c — parent sends a message to child */
#include <stdio.h>
#include <unistd.h>
#include <string.h>

int main() {
    int fd[2];              // fd[0]=read end, fd[1]=write end
    pipe(fd);

    if (fork() == 0) {
        // Child — read from pipe
        close(fd[1]);          // no writing
        char buf[100];
        int n = read(fd[0], buf, sizeof(buf));
        buf[n] = '\0';
        printf("Child got: %s\n", buf);
    } else {
        // Parent — write to pipe
        close(fd[0]);          // no reading
        char *msg = "Hello, child!";
        write(fd[1], msg, strlen(msg));
    }
    return 0;
}

IPC Mechanism 2 — Message Queues, Shared Memory, Sockets

Shared Memory — Practical Example

/* Parent creates shared memory, child reads it */
#include <sys/mman.h>
#include <sys/wait.h>
#include <unistd.h>
#include <string.h>
#include <stdio.h>

int main() {
    // Anonymous shared memory — inherited by child
    char *shared = mmap(NULL, 4096,
        PROT_READ | PROT_WRITE,
        MAP_SHARED | MAP_ANONYMOUS, -1, 0);

    if (fork() == 0) {
        sleep(1);
        printf("Child reads: %s\n", shared);
    } else {
        strcpy(shared, "Message via shared memory");
        wait(NULL);
    }
    return 0;
}

Synchronous vs Asynchronous Messaging

Real-World IPC in Action

Common Pitfalls

Golden Rules