Operating Systems Three Easy Pieces (Remzi H. Arpaci-Dusseau etc.)（Z-Library）

【One-Line Pitch】 A modern, engaging introduction to operating systems that breaks the subject into three core ideas—virtualization, concurrency, and persistence—ideal for students, self-taught programmers, and professionals who want a practical yet rigorous foundation in how OSes really work. 【Book Arc】 - **Opening (~0%–10%)**: Sets the stage with the book's philosophy—OS as a "resource manager" for CPU, memory, and storage—and introduces the three pillars (virtualization, concurrency, persistence). Includes early code examples (e.g., a multi-threaded counter) to show real problems, plus a nod to the xv6 teaching OS used in labs. - **Early (~10%–30%)**: Dives into process abstraction: states (ready, running, blocked), the process API (fork, exec, wait), and the mechanics of context switching via traps and interrupts. Explains how the OS saves/restores register state and uses kernel stacks, laying the groundwork for scheduling. - **Middle (~30%–50%)**: Covers CPU scheduling policies in depth—from simple FIFO/SJF to preemptive STCF and the MLFQ—and introduces advanced topics like lottery scheduling (tickets, currency, transfer, inflation) and multiprocessor cache coherence. Uses dialogues (Professor/Student) to debate trade-offs like turnaround vs. response time. - **Late (~50%–75%)**: Shifts to memory virtualization: address translation, paging, and segmentation, with a focus on how hardware and OS cooperate. Then moves to concurrency: locks, condition variables, and semaphores, using the earlier counter example to motivate synchronization. - **Ending (~75%–100%)**: Tackles persistence: disks, RAID levels (striping, mirroring, parity), file system implementation (inodes, directories, free space), journaling for crash consistency, and a brief look at distributed systems (NFS vs. AFS). Wraps with practical homework and references for deeper study. 【Key Takeaways】 - **OS as resource manager** (Opening): The core job is to virtualize CPU, memory, and storage, making each appear dedicated to processes. This framing helps you predict why OS features exist. - **Process states are the backbone of scheduling** (Early): Ready, running, and blocked states, plus context switching via traps, explain how the OS juggles multiple tasks. Understanding this makes later scheduling policies intuitive. - **Preemptive schedulers dominate modern OSes** (Early): Timer interrupts allow the OS to stop a running process, enabling fairness and responsiveness. Non-preemptive (batch) schedulers are historical relics. - **Scheduling is a trade-off, not a solved problem** (Middle): Metrics like turnaround and response time conflict; MLFQ tries to blend SJF and Round-Robin, but no single policy wins. This pragmatism is key to systems design. - **Lottery scheduling offers flexible control** (Middle): Tickets, currency, transfer, and inflation give users and processes a way to express priority, useful in trusted environments like client/server setups. - **Cache coherence is a hardware problem** (Middle): Multiprocessor scheduling hits issues like stale caches; bus snooping and invalidation are basic solutions. This shows OS and architecture are intertwined. - **File systems are about structure and recovery** (Late): Inodes, directories, and free-space management are the building blocks; journaling (data vs. metadata) is critical for surviving crashes without corruption. - **RAID is a reliability/performance trade-off** (Late): Striping (RAID-0), mirroring (RAID-1), and parity (RAID-4/5) each balance capacity, speed, and fault tolerance—choose based on workload needs. 【Reading Tips】 - **Skim the dialogues**: The Professor/Student conversations (e.g., in scheduling chapters) summarize key debates; read them for intuition, but skip if you're short on time—they're not essential for code. - **Deep-read the mechanism chapters**: Context switching (Early) and file system implementation (Late) are dense but crucial; trace the code examples (fork, exec, inode access) to solidify understanding. - **Use the homework**: Each chapter ends with simulation-based exercises (e.g., scheduling, RAID); run them to see policies in action—this is where the book shines for self-learners. - **Watch for xv6 references**: The book uses xv6 (a teaching OS) for labs; if you're not doing labs, treat these as optional but useful for seeing real kernel structures. - **Don't get stuck on advanced topics**: Multiprocessor scheduling and distributed systems (Late) are "advanced" interludes; skim for awareness, not mastery, unless you're specializing. 【Coverage Limits】 This guide synthesizes the provided excerpts, which cover the book's structure, early process/scheduling concepts, and some file system/RAID topics. It does not detail memory paging algorithms, lock implementations, or specific homework solutions—those require reading the full text.