CPU Scheduling Case Study: FCFS vs SJF for a Five-Process Workload

The article shows how to write a C program that uses fork() to illustrate the parent‑child relationship of processes, their return values, IDs, concurrent execution, and proper synchronization.

• fork() returns 0 in the child, the child’s PID in the parent, and -1 on error.
• getpid() and getppid() reveal each process’s own and parent IDs; output order can vary because the two processes run concurrently.
• The parent must call waitpid() (or wait()) to reap the child, prevent zombies, and decode its exit status with WIFEXITED/WEXITSTATUS.
• Changing a variable (e.g., x) in the child demonstrates separate writable address spaces, thanks to copy‑on‑write.
• Avoid placing fork() in an uncontrolled loop, as each successful fork doubles the process count from $1$ to $2$, then to $2^n$, quickly exhausting system resources.

The material introduces best‑case, worst‑case, and average‑case complexity as three distinct functions describing an algorithm’s running time on inputs of size $n$, explains how they are formally defined, and shows why worst‑case analysis is usually preferred.

• Best case: $T_{\text{best}}(n)=\min_{I\in\mathcal I_n} T(I)$, the minimum time over all inputs of size $n$.
• Worst case: $T_{\text{worst}}(n)=\max_{I\in\mathcal I_n} T(I)$, giving a guaranteed upper bound.
• Average case: $T_{\text{avg}}(n)=\sum_{I\in\mathcal I_n}P(I)\,T(I)$, requiring an explicit input probability model.
• Linear search illustrates the three cases: $\Theta(1)$ best, $\Theta(n)$ worst, and $\Theta(n)$ average (expected $\frac{n+1}{2}$ comparisons).
• Worst‑case analysis is favored because it needs no probabilistic assumptions and ensures reliability for all inputs, especially in real‑time or safety‑critical systems.

The course walks through a full Banker's‑algorithm safety analysis for processes $P_0$–$P_4$, computing the Need matrix and using the work‑vector test to verify a safe state and a valid completion order.

• Need matrix: $P_0\;(0,0,0,0)$, $P_1\;(0,7,5,0)$, $P_2\;(1,0,0,2)$, $P_3\;(0,0,2,0)$, $P_4\;(0,6,4,2)$.
• Starting work $Work = Available = (1,5,2,0)$; each step selects a process with $Need \le Work$, releases its allocation, and updates $Work$.
• All processes finish, yielding a safe sequence $\langle P_0, P_2, P_1, P_3, P_4\rangle$.
• A safe state requires only one such sequence; it does not mean every immediate allocation is safe.
• Exam tip: test processes with minimal or zero Need first to unlock the rest.