My Knowledge Base

01 Introduction

Operating System Fundamentals

The foundation of modern computing relies on the Von Neumann model, where a processor repeatedly fetches an instruction from memory, decodes it, and executes it sequentially until program completion. An operating system (OS) is the layer of software that facilitates this execution, managing hardware interaction, memory sharing, and device communication.

  • Virtual Machine: The OS transforms physical hardware resources into generalized, powerful, and accessible virtual forms.
  • Standard Library: Applications interact with the OS through Application Programming Interfaces (APIs), commonly implemented as system calls.
  • Resource Manager: The OS continuously manages and allocates shared resources, including the CPU, memory, and disk drives, ensuring fair and efficient operation.

To provide this baseline ease of use, the OS relies fundamentally on transforming raw hardware into accessible abstractions, a process known as virtualization.

Virtualization

Virtualization abstracts the physical hardware away from running applications, providing each program with the illusion of dedicated resources.

  • CPU Virtualization
    • Transforms a single physical CPU (or small set) into a seemingly infinite number of virtual CPUs.
    • Enables multiple programs to run concurrently, executing independent instruction streams.
    • Relies on OS policies—decision-making algorithms that determine which specific program should be granted execution time at any given moment.
  • Memory Virtualization
    • Physical memory operates as a flat array of bytes, accessed via explicit read and write addresses.
    • The OS provides each running process with a private, independent virtual address space.
    • The OS maps these virtual address spaces to shared physical memory, establishing strict isolation so that memory operations in one process cannot alter the state of another.

Managing these virtualized CPU and memory resources across multiple overlapping processes inherently introduces complex synchronization challenges, shifting the focus from isolated execution to concurrency.

Concurrency

Concurrency refers to the behavior and complications that arise when a system handles many tasks simultaneously. Originally a challenge confined strictly to OS resource management, concurrency is now a primary concern in multi-threaded application development.

  • Threads: Active execution units running simultaneously within the same shared memory space.
  • Execution Interleaving: When multiple threads increment a shared counter loops of times, the expected final output is .
  • Non-Atomic Operations: In reality, high execution counts often result in non-deterministic and incorrect values.
    • A single high-level increment operation requires three distinct machine instructions: load from memory to a register, increment the register, and store back to memory.
    • Because these instructions do not execute atomically, context switching between threads mid-operation corrupts shared data state.

While concurrency manages volatile data structures across multiple active threads, systems must also ensure data survives power loss and hardware crashes, necessitating persistent storage mechanisms.

Persistence

System memory (DRAM) is volatile, meaning all state is lost upon power failure or system crash. Persistence ensures long-term data survival via hardware devices and OS software management.

  • Hardware layer: Non-volatile input/output (I/O) devices, primarily hard disk drives and solid-state drives (SSDs).
  • Software layer (File System): The OS subsystem responsible for storing files reliably and efficiently.
    • Provides standard APIs, mapping high-level calls like open(), write(), and close() to low-level device drivers.
    • Delays and batches write operations to maximize I/O performance.
    • Implements crash recovery protocols, such as journaling and copy-on-write, to maintain data integrity during write failures.
    • Utilizes complex internal data structures, including lists and b-trees, for rapid data retrieval.
  • Resource Sharing: Unlike CPU and memory virtualization—which strictly isolate processes—persistent files are explicitly designed to be shared across multiple independent programs.

Balancing the complex, competing demands of virtualization, concurrency, and shared persistence requires strict adherence to core architectural objectives.

System Design Goals

The mechanisms used to build an OS are heavily driven by specific performance and safety constraints.

  • Abstraction: Decomposing complex hardware interfaces into small, high-level, understandable components.
  • High Performance: Minimizing the processing overhead (extra instruction cycles) and space overhead (memory footprint) introduced by OS operations.
  • Protection and Isolation: Preventing applications from maliciously or accidentally modifying OS state or the isolated memory spaces of other applications.
  • Reliability: Maintaining non-stop operation, as an OS fault cascades into a total failure of all running applications.
  • Secondary Objectives: Energy efficiency for green computing, strict security against malicious networks, and mobility for smaller devices.

These modern design goals did not emerge immediately, but evolved through successive generations of computing hardware and software architecture.

Historical Evolution of Operating Systems

Operating systems developed iteratively, adopting distinct features as hardware constraints and usage paradigms shifted.

  • Early Systems (Batch Processing)
    • Early mainframes executed one program at a time, governed by human operators.
    • The “OS” was merely a library of commonly used API functions to standardize I/O handling.
  • The Protection Era
    • File sharing introduced the need for data privacy, meaning the OS could no longer operate as a simple, universally accessible library.
    • System Calls: Invented during the Atlas project to strictly control execution transfers into the OS.
    • Hardware Privilege Levels:
      • User mode: Hardware restricts application access (e.g., prevents direct memory or disk I/O).
      • Kernel mode: Unrestricted hardware access granted to the OS.
    • Traps: Special hardware instructions initiate a system call, jumping to a pre-defined trap handler while simultaneously escalating privileges to kernel mode. A return-from-trap instruction reverses this upon completion.
  • The Multiprogramming Era
    • Minicomputers lowered hardware costs, increasing concurrent users.
    • CPU Utilization: To prevent the CPU from idling during slow I/O operations, the OS loaded multiple jobs into memory and switched between them rapidly.
    • This era established the modern need for memory protection boundaries and concurrency management.
    • UNIX: Introduced small, modular programs, pipeline primitives, and the C programming language, establishing open distribution models.
  • The Modern Era
    • Early personal computers (PCs) initially regressed, shipping operating systems (like DOS and early Mac OS) without multiprogramming scheduling or memory protection.
    • Modern PC architectures eventually reintegrated minicomputer-era advancements (e.g., Windows NT, Mac OS X utilizing a UNIX core, and Linux), establishing the robust, protected, and concurrent environments standard in devices today.

Would you like me to create a set of flashcards covering these operating system definitions and historical eras to help you review the material?