Operating Systems (15 hours CS Core)
An operating system is the collection of services needed to safely interface the hardware with applications. Core topics focus on the mechanisms and policies needed to virtualize computation, memory, and I/O. Overarching themes that are reused at many levels in computer systems are well illustrated in operating systems (e.g. polling vs interrupts, caching, flexibility costs overhead, similar scheduling approaches to processes, page replacement, etc).
A CS student needs to have a clear mental model of how a pipelined instruction executes to how data scope impacts memory location. Students can apply basic OS knowledge to domain-specific architectures (machine learning with GPUs or other parallelized systems, mobile devices, embedded systems, etc). Since all software must leverage operating systems services, students can reason about the efficiency, required overhead and the tradeoffs inherent to any application or code implementation. The study of basic OS algorithms and approaches provides a context against which students can evaluate more advanced approaches. Without an understanding of sandboxing, how programs are loaded into processes, and execution, students are at a disadvantage when understanding or evaluating vulnerabilities to vectors of attack.
The core of operating systems knowledge from CC2013 has been propagated from CC2013 to the updated knowledge area. Changes from CC2013 include moving of File systems knowledge (now called File Systems API and Implementation) and Device Management from elective to the core curriculum and Performance and Evaluation knowledge units to the Systems Fundamentals Knowledge area. The addition of persistent data storage and device I/O reflects the impact of file storage and device I/O limitations on the performance (e.g. parallel algorithms, etc). To accommodate File Systems API and Implementation and Device Management as a CS Core knowledge unit, more advanced topics were moved from CS Core to KA Core. The Performance and Evaluation knowledge unit moved to Systems Fundamentals with the idea that performance and evaluation approaches for operating systems are mirrored at other levels and are best presented in this context.
| CS Core | KA Core | Electives | |
| OS/Role and Purpose of Operating Systems | 2 | N | |
| OS/Principles of Operating System | 2 | N | |
| OS/Concurrency | 2 | N | |
| OS/Scheduling | 1 | N | |
| OS/Process Model | 1 | N | |
| OS/Memory Management | 2 | N | |
| OS/Protection and Safety | 2 | N | |
| OS/Device Management | 1 | N | |
| OS/File Systems API and Implementation | 2 | N | |
| OS/Virtualization | Y | ||
| OS/Real-time and Embedded Systems | Y | ||
| OS/Fault Tolerance | Y |
CS Core
OS/Role and purpose of the operating system [2 CS Core hours]
Topics
- Operating system as an abstract virtual machine via an API
- Universal operating system functions
- Extended and/or specialized operating system functions
- Design issues (e.g. efficiency, robustness, flexibility, portability, security, compatibility, power, safety)
- Influences of security, networking, multimedia, parallel and distributed computing
- Overarching concern of security/protection
Learning Outcomes:
- Explain the objectives and functions of modern operating systems
- Describe the design issues in different usage scenarios (e.g. real time OS, desktop, server, etc) ]
- Describe the functions of a contemporary operating system with respect to convenience, efficiency, and the ability to evolve
OS/Principles of operating systems [2 CS Core hours]
Topics
- Structuring methods (monolithic, layered, modular, micro-kernel models)
- Abstractions, processes, and resources
- Concepts of system calls and links to application program interfaces (APIs)
- The evolution of the link between hardware architecture and the operating system functions
- Leveraging Interrupts from hardware level: service routines and implementations
- Concept of user/system state and protection, transition to kernel mode using system calls
- Mechanism for invoking of system calls and corresponding context switch
Learning Outcomes:
- Application of software design approaches to operating systems design/implementation (e.g. layered, modular, etc)
- Categorize system calls by purpose
- Understand dynamics of invoking a system call (passing parameters, mode change, etc)
- Evaluate whether a function can be implemented in the application layer and which function can only be accomplished by system calls
- Apply OS techniques for isolation, protection and throughput apply across OS functions (e.g. starvation similarities in process scheduling, disk request scheduling, semaphores, etc) and beyond
- Describe how the separation into kernel and user mode affect safety and performance.
- Discuss the advantages and disadvantages of using interrupt processing in enabling multiprogramming
- Identify potential threats to operating systems and the security features designed to guard against them
OS/Concurrency [2 CS Core hours]
Topics
- Thread abstraction relative to concurrency
- States and state diagrams (cross-reference SF/State and State Machines)
- Structures (ready list, process control blocks, and so forth)
- The role of interrupts
- Managing atomic access to OS objects
- Implementing synchronization primitives (semaphores, mutex locks, cond vars)
- Race conditions, critical sections
- Multiprocessor issues (spin-locks, reentrancy) (cross-reference SF/Parallelism)
Learning Outcomes:
- Describe the advantages and disadvantages of concurrency within the framework of an operating system
- Describe how architecture level implementation results in concurrency problems including race conditions
- Summarize the range of mechanisms that can be employed at the operating system level to realize concurrent systems and describe the benefits of each
- Summarize techniques for achieving synchronization in an operating system (e.g., describe how a semaphore can be implemented using OS primitives)
- Accurately analyze code to identify race conditions and appropriate solutions for addressing race conditions
OS/Scheduling [1 CS Core hours]
Topics
- Preemptive and non-preemptive scheduling (cross-reference SF/Resource Allocation and • Scheduling, PD/Parallel Performance)
- Schedulers and policies (cross-reference SF/Resource Allocation and Scheduling, PD/Parallel Performance)
- Concepts of SMP/multiprocessor scheduling
- Subtopics of operating systems such as energy-aware scheduling and real-time scheduling
Learning Outcomes:
- Compare and contrast the common algorithms used for both preemptive and non-preemptive scheduling of tasks in operating systems, such as priority, performance comparison, and fair-share schemes
- Describe relationships between scheduling algorithms and application domains
- Discuss the types of processor scheduling such as short-term, medium-term, long-term, and I/O
- Describe the difference between processes and threads
- Discuss the need for preemption and deadline scheduling
- Identify ways that the logic embodied in scheduling algorithms are applicable to other domains, such as disk I/O, network scheduling, project scheduling, and problems beyond computing
OS/Process Model [1 CS Core hours]
Topics
- Processes and threads relative to virtualization (cross-reference SF/Computational paradigms)
- Memory footprint/segmentation (stack, heap, etc)
- Loading executables and shared libraries
- Dispatching and context switching
Learning Outcomes:
- Describe how processes and threads use concurrency features to virtualize control
- Describe reasons for using interrupts, dispatching, and context switching to support concurrency and virtualization in an operating system
- Explain the different states that a task may pass through and the data structures needed to support the management of many tasks
- Describe the building, loading and execution of processes by the operating system
- Explain the link between the operating system and linkers
- Defend the different ways of allocating memory to tasks, citing the relative merits of each
OS/Memory Management [2 CS Core hours]
Topics
- Review of physical memory, address translation and memory management hardware
- Impact of memory hierarchy including cache concept, cache lookup, etc on operating system mechanisms and policy (cross-reference AR/Memory System Organization and Architecture)
- Logical and physical addressing
- Concepts of paging, page replacement, thrashing and allocation of pages and frames
* Allocation/deallocation/storage techniques (algorithms and data structure) performance and flexibility
- Caching (cross-reference AR/Memory System Organization and Architecture)
- Virtual Memory: leveraging virtual memory hardware for OS services and efficiency
- Security mechanisms and concepts in memory mgmt including sandboxing, protection, isolation, vectors of attack
Learning Outcomes:
- Explain memory hierarchy and cost-performance trade-offs
- Summarize the principles of virtual memory as applied to caching and paging
- Evaluate the trade-offs in terms of memory size (main memory, cache memory, auxiliary memory) and processor speed
- Describe the reason for and use of cache memory (performance and proximity, how caches complicate isolation and VM abstraction)
- Code/Develop efficient programs that consider the effects of page replacement and frame allocation on the performance of a process and the system in which it executes
OS/Protection and Safety (Overlap with Security TBD) [2 CS Core hours]
Topics
- Overview of system security
- Policy/mechanism separation
- Security methods and devices
- Protection, access control, and authentication
- Backups
Learning Outcomes:
- Articulate the need for protection and security in an OS (cross reference IAS/Security Architecture and Systems Administration/Investigating Operating Systems Security for various systems)
- Summarize the features and limitations of an operating system used to provide protection and security (cross reference IAS/Security Architecture and Systems Administration)
- Explain the mechanisms available in an OS to control access to resources (cross reference IAS/Security Architecture and Systems Administration/Access Control/Configuring systems to operate securely as an IT system)
OS/Device management [1 CS Core hours]
Topics
- Buffering strategies
- DMA and Polled I/O, Memory-mapped I/O
- Persistent storage device management (magnetic, SSD, etc)
- Device interface abstractions
- Device driver purpose, abstraction and implementation
Learning Outcomes:
- Review architecture level device control implementation and link relevant operating system mechanisms and policy (e.g. Buffering strategies, Direct memory access, etc) (cross-reference AR/Interfacing and Communication)
- Describe OS device management layers and the architecture (device controller, device driver, device abstraction, etc)(cross-reference AR/Interfacing and Communication)
- Identify the relationship between the physical hardware and the virtual devices maintained by the operating system
- Explain buffering and describe strategies for implementing it
- Describe the advantages and disadvantages of direct memory access and discuss the circumstances in which its use is warranted
OS/File Systems: API and Implementation [2 CS Core hours]
Topics
- Files: data, metadata, operations, access-mode
- Directory structure
- File system mounting
- File access control
- File sharing
- File system structure
- File allocation methods
- Allocation/deallocation/storage techniques (algorithms and data structure) impact on performance and flexibility
- Free space management
- Implementation of Directories
Learning Outcomes:
- Describe the choices to be made in designing file systems
- Compare and contrast different approaches to file organization, recognizing the strengths and weaknesses of each
- Appropriately choose software elements given knowledge of the file system implementation
- Summarize how hardware developments have led to changes in the priorities for the design and the management of file systems
KA Core
OS/Advanced File systems
Topics
- File systems: partitioning, mount/unmount, virtual file systems
- In-depth implementation techniques
- Memory-mapped files
- Special-purpose file systems
- Naming, searching, access, backups
- Journaling and log-structured file systems
- Distributed file systems (e.g NAS, OSS, SAN, Cloud, etc) (cross-cutting w/ Networks/PDC)
- Encrypted file systems
Learning outcomes (in progress):
- Summarize how hardware developments have led to changes in the priorities for the design and the management of file systems
- Map file abstractions to a list of relevant devices and interfaces
- Identify and categorize different mount types
- List specific file systems requirements and the specialize file systems features that meet those requirements
- Summarize the use of journaling and how log-structured file systems enhance fault tolerance
OS/Virtualization
Topics
- Goal of virtualization and isolation: protection and predictable performance (cross-reference SF/Virtualization)
- Types of virtualization (including Hardware/Software, OS, Server, Service, Network)
- Advanced Paging and virtual memory
- Virtual file systems
- Hypervisors
- Portable virtualization; emulation vs. isolation
- Cost of virtualization
Learning Outcomes (in progress):
- Explain the concept of virtual memory and how it is realized in hardware and software
- Differentiate emulation and isolation
- Evaluate virtualization trade-offs
- Discuss hypervisors and the need for them in conjunction with different types of hypervisors
OS/Real-time/embedded
Topics
- Process and task scheduling
- Deadlines and real-time issues
- Memory/disk management requirements in a real-time environment
- Failures, risks, and recovery
- Special concerns in real-time systems (safety)
Learning Outcomes (in progress):
- Describe what makes a system a real-time system
- Explain the presence of and describe the characteristics of latency in real-time systems.
- Summarize special concerns that real-time systems present, including risk, and how these concerns are addressed
OS/Fault tolerance
Topics
- Fundamental concepts: reliable and available systems (cross-reference SF/Reliability through Redundancy)
- Software and hardware approaches to address tolerance (RAID)
- Spatial and temporal redundancy (cross-reference SF/Reliability through Redundancy)
- Methods used to implement fault tolerance
- File system consistency check and recovery
- Journaling and log-structured file systems
- Examples of OS mechanisms for detection, recovery, restart to implement fault tolerance, use of these techniques for the OS’s own services
Learning Outcomes (in progress):
- Explain the relevance of the terms fault tolerance, reliability, and availability
- Outline the range of methods for implementing fault tolerance in an operating system
- Explain how an operating system can continue functioning after a fault occurs