OS tricks that make processes click

Process states: New Ready Running Waiting Terminated

NewBeing created

ReadyWaiting for CPU

RunningExecuting on CPU

WaitingBlocked on I/O

TerminatedFinished

Deadlock requires all 4: Mutual exclusion, Hold-and-wait, No preemption, Circular wait

MMutual exclusion

HHold and wait

NNo preemption

CCircular wait

Virtual memory: OS swaps pages to disk — programs see more RAM than exists

Virtual Memory — OS uses disk as overflow when RAM fills up. Programs see a large contiguous address space. Page fault: needed page not in RAM → load from disk (slow). Paging: fixed-size blocks.

CPU Scheduling: FCFS (First Come First Served), SJF (Shortest Job First), Round Robin (fixed time quantum), Priority (highest priority runs first)

Scheduling Algorithms — FCFS: first come first serve — simple, long jobs block short ones. SJF: shortest job first — minimizes wait, needs job-length prediction. Round Robin: each gets a fixed time slice — fair. Priority: highest priority runs first.

Thrashing: too many processes → constant page swapping → CPU spends all time on I/O, none on work

Thrashing — Occurs when the total working set of all processes exceeds available RAM. OS spends more time swapping pages than running processes. Solution: reduce multiprogramming degree or add RAM.

File systems: FAT32 (File Allocation Table 32-bit, simple and compatible), NTFS (New Technology File System, Windows journaling), ext4 (Linux), APFS (Apple File System) (Apple)

File Systems — File system: organizes data on storage devices. FAT32: simple, max 4GB file size, universal compatibility. NTFS: Windows, journaling (recovers from crashes), large files, permissions. ext4: Linux standard, journaling, large file support. Hierarchical structure: root → directories → files. Inodes: metadata about files (not content).

Memory hierarchy: registers → cache (L1/L2/L3) → RAM → SSD → HDD. Faster = smaller and more expensive.

Memory Hierarchy — Registers: fastest, inside CPU, tiny (bytes). L1 cache: ~32KB per core, ~1ns. L2 cache: ~256KB, ~4ns. L3 cache: shared, ~8MB, ~40ns. RAM: ~16GB typical, ~100ns. SSD: ~1TB, ~100μs. HDD: ~4TB, ~10ms. OS and hardware move data up the hierarchy (caching) to match speed with usage patterns.

Context switch: OS saves current process state, loads another process state — enables multitasking

Context Switching — When CPU switches from one process to another: save current process's registers, program counter, and state to PCB (Process Control Block). Load next process's saved state. Context switches are expensive (~microseconds) — too many degrade performance. Threads have lighter context switches than processes.

Semaphore: integer variable for synchronization. Mutex (Mutual Exclusion lock, binary semaphore). P() = wait. V() = signal.

Semaphores and Synchronization — Semaphore: integer variable — P() decrements (wait if 0), V() increments (signal). Binary semaphore (mutex): 0 or 1, implements mutual exclusion. Counting semaphore: tracks available resources. Dining philosophers problem: classic deadlock scenario. Monitor: higher-level synchronization construct.

Paging: divide memory into fixed-size pages. Page table maps virtual to physical addresses.

Paging — Page: fixed-size block of virtual memory (typically 4KB). Frame: corresponding physical memory block. Page table: maps virtual page numbers to physical frame numbers. Page fault: accessing page not in RAM → OS loads from disk → slow. Working set: set of pages process needs — keep in RAM to minimize page faults.

I/O (Input/Output) management: buffering (temporary storage), spooling (queue for slow devices), interrupts (device signals CPU)

I/O Management — Busy waiting (polling): CPU repeatedly checks if I/O is done — wastes CPU cycles. Interrupts: device signals CPU when I/O complete — CPU does other work meanwhile. DMA (Direct Memory Access): device transfers data directly to memory without CPU involvement. Buffering: temporary storage to handle speed mismatch.

Shell: command-line interface to OS. Script: sequence of commands in a file. Pipe: output of one command as input to next.

Shell and Scripting — Shell: program that interprets commands — bash, zsh, PowerShell. Pipe (|): chain commands, output of one → input of next. cat file | grep 'error' | wc -l. Redirection: > (output to file), < (input from file), >> (append). Shell scripts: automate repetitive tasks. Environment variables: KEY=value, PATH determines where programs are found.