Fundamentals of Operating Systems

Lesson 1 • OS Architecture Overview

Introduces monolithic, microkernel, and hybrid kernel designs. Prepares students to evaluate trade-offs discussed in later chapters.

Lesson 2 • Historical Evolution of Operating Systems

Traces OS development from batch systems to modern multicore environments. Contextualizes design decisions made in later chapters.

Lesson 3 • Definition and Purpose of an OS

Defines an OS as a resource manager and user interface layer. Establishes the conceptual baseline for all subsequent chapters.

Lesson 4 • Major OS Types and Examples

Surveys general-purpose, real-time, embedded, and mobile OS categories. Helps students match OS type to deployment context.

Lesson 1 • Inter-Process Communication Basics

Introduces pipes, message queues, and shared memory as IPC mechanisms. Sets the stage for synchronization and concurrency chapters.

Lesson 2 • Process Creation and Termination

Covers fork/exec patterns and process hierarchy trees. Explains how parent-child relationships affect resource inheritance.

Lesson 3 • Process Concept and Structure

Defines a process as a program in execution with its own address space. Anchors all scheduling and synchronization topics that follow.

Lesson 4 • Context Switching Mechanics

Details how the OS saves and restores CPU state during a switch. Quantifies the overhead cost relevant to scheduling decisions.

Lesson 1 • Preemptive Scheduling Algorithms

Examines Round Robin, SRTF, and priority scheduling with preemption. Connects preemption to responsiveness and starvation risks.

Lesson 2 • Multilevel Queue Scheduling

Structures processes into fixed queues with separate scheduling policies. Extends single-queue models to heterogeneous workloads.

Lesson 3 • Non-Preemptive Scheduling Algorithms

Covers FCFS and SJF as baseline non-preemptive policies. Demonstrates convoy effect and optimal burst-time scheduling.

Lesson 4 • Multiprocessor and Real-Time Scheduling

Addresses load balancing, processor affinity, and deadline-driven scheduling. Prepares students for modern multicore and embedded system contexts.

Lesson 1 • Thread Libraries and APIs

Surveys POSIX Pthreads and Java thread APIs for practical implementation. Bridges conceptual thread models to real programming interfaces.

Lesson 2 • Synchronization Primitives

Introduces mutexes, semaphores, and monitors as synchronization tools. Prepares students for deadlock analysis in the next chapter.

Lesson 3 • Thread Concept and Benefits

Defines threads as execution flows sharing a process address space. Motivates multithreading through responsiveness and resource efficiency.

Lesson 4 • Race Conditions and Critical Sections

Identifies race conditions arising from unsynchronized shared data access. Defines the critical section problem and its three required properties.

Lesson 1 • Deadlock Conditions and Modeling

Presents the four necessary conditions for deadlock using resource allocation graphs. Provides the formal model used in all deadlock strategies.

Lesson 2 • Deadlock Detection and Recovery

Detects deadlock after it occurs and recovers through termination or preemption. Compares detection overhead against prevention and avoidance costs.

Lesson 3 • Deadlock Avoidance and Banker's Algorithm

Maintains a safe state by granting resources only when safety is provable. Implements the Banker's Algorithm for multi-resource environments.

Lesson 4 • Resource Allocation Graph Analysis

Uses directed graphs to detect deadlock cycles in single-instance resources. Extends to multi-instance resources with wait-for graphs.

Lesson 1 • Multilevel and Inverted Page Tables

Reduces page table memory overhead using hierarchical and inverted designs. Addresses scalability challenges in 64-bit address spaces.

Lesson 2 • Paging and Page Tables

Eliminates external fragmentation by mapping fixed-size pages to frames. Explains page table structure, TLB operation, and effective access time.

Lesson 3 • Contiguous Memory Allocation

Covers fixed and variable partition allocation with first-fit, best-fit, and worst-fit strategies. Introduces internal and external fragmentation problems.

Lesson 4 • Memory Hierarchy and Address Binding

Describes the memory hierarchy from registers to secondary storage. Explains compile-time, load-time, and execution-time address binding.

Lesson 1 • Thrashing and Working Set Model

Diagnoses thrashing as excessive paging due to insufficient frames. Applies the working set model to maintain locality and prevent thrashing.

Lesson 2 • Virtual Memory Concepts

Defines virtual memory as the separation of logical from physical address space. Enables programs larger than physical RAM to execute efficiently.

Lesson 3 • Page Fault Handling

Traces the OS steps from page fault detection to page loading. Quantifies effective access time with page fault rate.

Lesson 4 • Page Replacement Algorithms

Compares FIFO, Optimal, LRU, and Clock algorithms for frame selection. Evaluates each algorithm against Belady's anomaly and hit rate.

Lesson 1 • Free Space Management

Tracks unallocated disk blocks using bit vectors, linked lists, and grouping. Connects free space efficiency to overall file system performance.

Lesson 2 • Disk Scheduling Algorithms

Minimizes disk head movement using FCFS, SSTF, SCAN, and C-SCAN policies. Selects appropriate algorithms based on workload access patterns.

Lesson 3 • Disk Space Allocation Methods

Compares contiguous, linked, and indexed allocation for file block storage. Evaluates each method for sequential and random access performance.

Lesson 4 • File System Implementation

Explains on-disk structures including boot blocks, superblocks, and inodes. Covers open-file tables and file descriptor management in memory.