Operating System Course for Computer Engineering-Updated2025

This lecture explores the fundamental process abstraction in operating systems, defining a process as a dynamic program in execution. To manage these tasks, the kernel utilizes a Process Control Block (PCB), which stores critical execution data such as CPU registers, memory addresses, and identification numbers like the PID. The text examines the complexities of process creation, specifically detailing the mechanics of the fork() and exec() system calls used in Unix environments. Efficiency is prioritised through modern techniques like copy-on-write, which defers memory duplication until it is strictly necessary for operation. Beyond basic execution, the sources cover inter-process communication methods, including pipes and signals, which allow isolated tasks to collaborate or respond to external events. Finally, it addresses system management concepts such as user privileges, shell operations, and the grouping of processes into jobs for collective control.

This lecture explores the fundamental distinction between processes and threads in modern operating systems, emphasizing how they facilitate concurrency and parallelism. While a process serves as a container for address spaces and resources, threads act as the actual units of execution that share those resources to improve efficiency. The text compares kernel-level threads, which the operating system manages directly, against user-level threads that operate via libraries for even greater speed. It highlights that while user-level threads offer superior performance, they face challenges like blocking I/O and lack of kernel awareness. To bridge these gaps, advanced concepts like scheduler activations are introduced to coordinate communication between the system and the application. Ultimately, the source illustrates how separating execution state from resource ownership allows for faster, more responsive software.

This lecture offers a detailed look at the evolution of concurrency management in operating systems, focusing on the trade-offs between processes and threads. Initially, the document establishes that the heavyweight nature of processes—due to high creation and context-switching costs—led to the development of threads as a lighter unit of execution. It then contrasts kernel-level threads, which offer robust control but suffer from performance-draining system call overhead, with user-level threads, which are fast but can cause the entire process to stall if one thread makes a blocking system call. Ultimately, the text introduces Scheduler Activations as a more sophisticated solution, proposing a cooperative communication model between the kernel and the user-level thread library to balance the need for performance, control, and complexity.

This lecture explores the fundamental differences between kernel threads and user-level threads within modern operating systems. While kernel-managed threads allow for better hardware utilisation, they are often slower due to the overhead of frequent system calls. Conversely, user-level threads offer superior performance for basic operations like creation and switching, yet they struggle when a single thread blocks the entire process during I/O tasks. To bridge this gap, the text introduces scheduler activations, a mechanism that enables the operating system and application to communicate via upcalls. This coordination allows the system to maintain the high speed of user-space management while effectively handling blocking operations and multiprocessor environments. Ultimately, the source highlights that while hybrid approaches provide significant efficiency, many modern systems are returning to refined kernel-level models for simplicity.

This lecture provides a practical guide to Inter-Process Communication (IPC), detailing the mechanisms operating systems use to allow isolated processes to coordinate and exchange data. The material is divided into two main parts, first explaining Pipes, which are presented as unidirectional data streams for chaining commands using concepts like I/O Redirection and File Descriptors. The second part addresses Signals, which are asynchronous notifications used as Urgent Alerts for events like user interrupts or a child process terminating. The slides illustrate how signals rely on Signal Handlers to override default behaviors and also warn about the critical pitfall that signals are not queued, requiring handlers to drain all pending events at once.

This lecture explores operating system scheduling, which is the policy-driven process of deciding which kernel threads or processes should access the CPU next. It categorizes schedulers into types like batch, interactive, and real-time, while defining key performance metrics such as throughput, utilization, and response time. The material examines foundational algorithms, including First-Come First-Served, Shortest Job First, and Round Robin, highlighting the trade-offs between efficiency and fairness. It further explains how modern systems like UNIX use Multi-Level Feedback Queues to dynamically adjust priorities based on a thread's execution history. Ultimately, the source emphasizes that scheduling is a complex balance of mathematical laws and heuristic-based art aimed at optimizing hardware resources.

This lecture introduces synchronization as a vital method for managing temporal relationships between threads in an operating system. It highlights the dangers of race conditions, where interleaved execution of code can lead to unpredictable or incorrect results, particularly when multiple threads access shared variables. To maintain system integrity, the text defines critical sections and explains the necessity of mutual exclusion, which ensures that only one thread can execute sensitive logic at a time. The source explores various implementation strategies, ranging from hardware-level atomic instructions like "compare and exchange" to software mechanisms like spinlocks and disabling interrupts. While these low-level tools are functional, the material notes their potential for wastefulness, setting the stage for more advanced, efficient synchronization constructs such as semaphores and monitors.

This lecture introduces synchronization within operating systems, focusing on how to manage temporal relations between concurrent threads. When multiple threads access shared variables, they can create race conditions that lead to unpredictable or incorrect results. To prevent this, developers define critical sections and enforce mutual exclusion, often through the use of locks. While low-level mechanisms like spinlocks and disabling interrupts rely on hardware support, they can be inefficient or restricted to the kernel. Consequently, the text suggests transitioning toward more sophisticated constructs like semaphores and monitors to ensure progress and performance. These tools establish a strict "happens-before" relationship to maintain data integrity across complex, multi-threaded environments.

This lecture examines essential synchronisation primitives used in operating systems to manage concurrent threads and shared resources. It explores semaphores, which utilise atomic P and V operations to block or signal threads, and distinguishes between binary and counting versions. The text also explains condition variables and their role in solving complex coordination challenges like the bounded buffer and readers-writers problems. Furthermore, it introduces monitors as a high-level language construct that automates mutual exclusion through compiler-inserted logic. Finally, the source compares different synchronisation models, such as Hoare and Mesa monitors, while providing real-world context through Java's implementation of intrinsic locks.

This lecture outlines the concept of system deadlocks, which occur when processes become blocked while holding resources and waiting for others to be released. The materials explain the four simultaneous conditions required for a deadlock to happen and introduce Resource Allocation Graphs as a visual tool for diagnosing the problem, noting that cycles within these graphs indicate a potential or actual deadlock. Furthermore, the source details three primary strategic solutions for managing deadlocks: Prevention, which aims to architect a system where deadlocks are structurally impossible; Avoidance, which uses algorithms like the Banker's Algorithm to maintain a "safe state" during resource allocation; and Detection & Recovery, which involves identifying and then resolving deadlocks, often by terminating processes or preempting resources, acknowledging that most modern systems like UNIX often simply ignore the problem due to performance costs.

This presentation provides a technical overview of deadlock, a state in which threads are permanently stalled because they are waiting for events that cannot occur. It identifies four essential conditions—mutual exclusion, hold and wait, no preemption, and circular wait—that must coexist for such a failure to happen. To manage these risks, the material outlines strategies for prevention, avoidance, and detection, including the use of resource allocation graphs and the Banker’s Algorithm. Beyond theoretical models, the text explores real-world complexities within the Windows kernel, noting that strict lock ordering is often difficult to maintain in integrated systems. Ultimately, the sources emphasize that while deadlocks are persistent once they occur, they can be resolved by identifying ownership cycles and carefully restructuring resource requests.

The lecture is a strategic guide to system deadlocks, explaining this phenomenon where processes are stuck in a circular wait for resources. It formally defines a deadlock and identifies the four required conditions for one to occur, including mutual exclusion and circular wait. The text also introduces Resource Allocation Graphs as a visual tool to diagnose potential deadlocks by looking for cycles. Finally, the guide outlines three major strategies for managing deadlocks—Prevention, Avoidance (using algorithms like the Banker's), and Detection & Recovery—while acknowledging that many modern systems like UNIX often ignore the problem due to performance overhead.

Operating systems manage a complex I/O subsystem designed to bridge the gap between various hardware devices and user applications. Because hardware ranges from human-readable tools like keyboards to machine-readable disks, the system categorizes them into block, character, and network devices to standardize interactions. Communication is handled through polling, where the CPU checks device status, or interrupts, which notify the processor when a task is finished to increase efficiency. To maintain high performance, the kernel utilizes buffering, caching, and scheduling to manage data flow and resolve speed discrepancies. Programmers interact with these systems using blocking, non-blocking, or asynchronous calls, depending on whether the process needs to wait for data. Ultimately, the goal is to minimize CPU overhead and data copying to ensure the computer remains responsive despite the high demands of input and output operations.

This text explores the fundamental architecture and management of Input/Output (I/O) hardware within an operating system. Because devices vary greatly in data rates and transfer methods, the OS uses a layered subsystem to provide virtualized interfaces and categorize hardware into classes like block, character, and network devices. The documentation details different communication strategies, contrasting the CPU-intensive nature of polled mode I/O with the more efficient, signal-based interrupt-driven I/O. It further examines how buffering and caching mitigate performance mismatches between the processor and external hardware. Finally, the source outlines various programming interfaces, such as blocking and asynchronous calls, while highlighting that minimizing data copying and context switches remains a primary challenge for system efficiency.

The lecture focuses on the I/O System and Secondary Storage components of a computer. It outlines the structure and role of the I/O system, which serves as the "glue" connecting various hardware components like block and character devices through device controllers and different bus architectures. A significant portion of the text discusses secondary storage, specifically comparing and contrasting Hard Disk Drives (HDD) and Solid-State Drives (SSD), highlighting their characteristics, performance issues, and evolution within the computing ecosystem. The text also illustrates the memory hierarchy and storage latency using analogies to physical distance, emphasizing the performance differences between storage levels, and concludes by setting up the transition to discussing the File System.

The lecture discusses spinning hard disk drives and the disruptive technology of solid state drives (SSDs). The text first breaks down the physical structure and performance characteristics of traditional magnetic disks, including how the operating system minimizes expensive operations like seek time and rotation latency through layout, caching, and various disk scheduling algorithms such as FCFS, SSTF, and C-SCAN. It then shifts focus to SSDs, highlighting their structure based on NAND flash memory and their superior performance metrics for reads compared to hard drives. Finally, the text explains the complexities of SSD writes, which involve erasures and impact the drive's lifespan, and discusses strategies like wear-leveling and log-structured filesystems used to manage these issues.

This lecture examines the complexities of Windows memory management, specifically focusing on how the operating system handles paging and kernel heap allocations. Through a series of detailed diagrams, the text illustrates the state transitions of page frames, including various categories like free, standby, and modified pages. A significant portion of the module presents a computational experiment that uses varying access patterns to demonstrate how hardware and software interact to impact performance. By analyzing how different memory strides affect execution time, the source explores the limitations of CPU caches and the role of Translation Lookaside Buffers (TLB). Finally, the material introduces page coloring as a strategy used by the memory manager to prevent different virtual addresses from competing for the same physical cache lines.

This lecture introduces the concept of virtual memory and its critical role in modern computing. It explains how this system simplifies programming by giving each process its own private address space while optimizing physical RAM as a high-speed cache for data stored on disk. The sources detail the process of address translation, where a Memory Management Unit uses page tables to convert virtual locations into physical ones. Key operational scenarios are explored, including page hits and page faults, the latter of which requires the operating system to swap data between memory and disk. Furthermore, the text highlights how virtual memory ensures system security by isolating different processes and enforcing specific access permissions. Finally, it addresses performance issues like thrashing, which occurs when insufficient RAM causes continuous, inefficient data swapping.

The lecture details the technical mechanisms behind virtual memory address translation, specifically focusing on how systems convert virtual addresses into physical ones. To mitigate the latency of accessing page tables in main memory, the text introduces the Translation Lookaside Buffer (TLB), a specialized hardware cache that accelerates this mapping process. The sources outline the step-by-step procedures for TLB hits and misses, explaining how the system handles page faults by retrieving data from a disk. Additionally, the materials address context switching, noting that while CPU registers and TLB entries must be updated or invalidated, physical memory and general caches can often remain unchanged. Finally, the slides define the mathematical parameters of address spaces and briefly mention hardware-level security vulnerabilities like the DRAMMER attack.

This lecture overview explores virtual memory, a mechanism that creates the illusion of a massive address space by leveraging the principle of locality. By partitioning memory into pages, the system can efficiently manage data transfers between fast physical RAM and larger, slower secondary storage. Key hardware components like the Page Table and Translation Lookaside Buffer (TLB) are detailed as essential tools for mapping virtual addresses to physical locations while minimizing latency. The text also examines critical design challenges, including page replacement algorithms, protection protocols, and the trade-offs involved in selecting an optimal page size. Ultimately, these systems ensure that expensive physical memory is fully utilized while simplifying memory management for programmers.

The lecture offers a detailed overview of file systems in operating systems, explaining their fundamental mission to abstract secondary storage into organized files and directories. It explores the relationship between applications, the operating system, and hardware devices, noting that file systems handle block I/O for storage. The majority of the material compares and contrasts three major file systems: the simplicity and limitations of Microsoft's FAT (File Allocation Table), the historical structure and consistency checks of Unix's file system using i-nodes, and the advanced features of NTFS (New Technology File System). A significant section is dedicated to journaling file systems, emphasizing their role in providing fast crash recovery by using a transaction log to maintain data consistency. Finally, the text details the design constraints, on-disk structures, access methods, and various directory organizations used by these different systems.

The provided documents offer a comprehensive technical overview of ZFS, a modern file system designed to simplify storage administration while enhancing data integrity. Unlike traditional systems constrained by physical disk boundaries, ZFS utilizes pooled storage, allowing file systems to share a common resource and scale dynamically as hardware is added. The sources highlight advanced features such as RAID-Z, which prevents data corruption through a copy-on-write mechanism, and disk scrubbing, which proactively identifies latent errors. Additionally, the text explains the efficiency of snapshots and clones, which provide near-instantaneous, space-saving methods for capturing and replicating data states. Performance is further optimized through pipelined I/O and dynamic striping, ensuring that data is distributed effectively across all available devices. Overall, ZFS is presented as a robust solution that merges the roles of a file system and a logical volume manager.

This presentation explores the architecture and evolution of distributed systems, which range from loosely-coupled independent networks to tightly-coupled multiprocessors. It highlights critical design challenges such as scalability, reliability, and transparency while providing historical and modern implementation examples. The text details the Grapevine mail service and Google’s search infrastructure, explaining how the latter utilizes MapReduce and massive parallelism to handle enormous data volumes. Furthermore, it examines volunteer computing initiatives like BOINC and the concept of human computation, where human cognitive strengths are integrated with machine processing. Ultimately, the source emphasizes that robust software frameworks are essential for making complex, distributed hardware appear as a single, dependable unit to the user.

This lecture provides a comprehensive overview of Distributed File Systems (DFS), which allow users to access remote data as if it were stored on a local machine. The text examines fundamental design challenges, including naming conventions, replication for reliability, and the critical trade-off between system performance and data consistency. It compares several historical and modern implementations, such as NFS for general Unix sharing, AFS for scalability through local disk caching, and the Sprite system for diskless workstations. Finally, the material highlights the Google File System (GFS), explaining how it manages massive datasets by optimizing for append-only operations and high-bandwidth sequential reads. These sources demonstrate that there is no single ideal architecture, as different systems prioritize different workloads and environmental needs.