Process Management & Concurrency

Execution Primitives

• Process: An isolated instance of an executing program with a private Virtual Address Space, File Descriptor Table, and Environment block.
• Thread: A lightweight unit of CPU execution inside a process. Threads share the process code, heap, and static data, but maintain independent stacks and register sets.

Process Control Block (PCB):

The kernel maintains a PCB data structure for every active process:

• PID & PPID (Process & Parent IDs)
• CPU Program Counter (PC) & Register State
• Memory Management Information (Page Table Base Register)
• Open File Descriptor Table pointers

// C Multithreading vs Process Creation Example
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>

void* thread_function(void* arg) {
    printf("Executing Thread within PID: %d
", getpid());
    return NULL;
}

int main() {
    pid_t pid = fork(); // Creates child process (Separate PID & Memory)
    if (pid == 0) {
        pthread_t tid;
        pthread_create(&tid, NULL, thread_function, NULL); // Creates Thread
        pthread_join(tid, NULL);
    }
    return 0;
}

Preemptive vs Non-Preemptive Scheduling

The CPU Scheduler selects ready queue processes for CPU execution using specific performance goals (Minimizing Waiting Time & Maximizing Throughput):

Scheduling Algorithms:

1. First-Come, First-Served (FCFS): Non-preemptive. Suffers from the Convoy Effect (short tasks queued behind a long CPU-bound job).
2. Shortest Remaining Time First (SRTF): Preemptive version of SJF. Minimizes average waiting time but risks starving long processes.
3. Round Robin (RR): Preemptive scheduling using a fixed Time Quantum ($\tau$). Ensures interactive responsiveness.
4. Multilevel Feedback Queue (MLFQ): Dynamically adjusts process priorities based on historical CPU usage (demotes CPU-heavy processes, promotes I/O-bound jobs).

# Simulator metrics calculation for Round Robin
def calculate_turnaround_and_waiting(arrival_times, burst_times, quantum):
    # MLFQ / RR Scheduling Metric Evaluator
    pass

Race Conditions & The Critical Section Problem

When concurrent threads read and write shared memory, a Race Condition can corrupt data structures unless synchronized.

Critical Section Requirements:

1. Mutual Exclusion: Only one process can execute inside the critical section at any given moment.
2. Progress: Selection of the next process entering the critical section cannot be postponed indefinitely.
3. Bounded Waiting: A bound must exist on the number of times other processes enter the critical section before a waiting request is granted.

Synchronization Primitives:

• Mutex (Mutual Exclusion Lock): Ownership-based binary lock (lock(), unlock()).
• Counting Semaphore: Integer counter (wait() / P(), signal() / V()) regulating access to $N$ identical shared resources.

// POSIX Mutex Synchronization Example
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
int shared_counter = 0;

void* increment_counter(void* arg) {
    pthread_mutex_lock(&lock);
    // Critical Section
    shared_counter++;
    pthread_mutex_unlock(&lock);
    return NULL;
}

Coffman Conditions & Deadlock Handling

A Deadlock is a frozen state where two or more processes cannot make progress because each holds a resource requested by another.

The 4 Necessary Coffman Conditions:

1. Mutual Exclusion: Non-shareable resource allocation.
2. Hold and Wait: Process holds existing resources while requesting new ones.
3. No Preemption: Resources cannot be forcibly revoked from a process.
4. Circular Wait: Closed chain of dependencies ($P_0 \to P_1 \to P_2 \to P_0$).

Deadlock Strategies:

• Banker's Algorithm: Avoids deadlocks dynamically by evaluating whether granting a resource request leaves the system in a Safe State.

// Banker's Algorithm Safety Check Pseudocode
// Need[i][j] = Max[i][j] - Allocation[i][j]
bool isSafeState(int Work[], bool Finish[], int Alloc[][R], int Need[][R]) {
    // Computes safe execution sequence if Available >= Need
    return true;
}

Exchanging Messages Across Process Boundaries

Since processes run in isolated address spaces, they communicate via explicit kernel-provided IPC channels:

Common IPC Mechanisms:

• Pipes & Named Pipes (FIFOs): Unidirectional byte stream channels provided by the kernel.
• Shared Memory (shmget, mmap): Maps physical memory frames into multiple virtual address spaces (Fastest IPC, requires mutexes).
• Message Queues: Kernel-managed queues of structured messages.
• Sockets: Network-transparent IPC across localhost or remote TCP/IP networks.

# C Pipe IPC Example
int pipefds[2];
char buffer[30];
pipe(pipefds);

if (fork() == 0) {
    // Child Process: Write to Pipe
    write(pipefds[1], "IPC Communication", 17);
} else {
    // Parent Process: Read from Pipe
    read(pipefds[0], buffer, 17);
}