Operating Systems Principles
Learning Objectives

The reading, quizzes, lectures, exams, and labs for this course are all designed around a set of learning objectives:

These learning objectives can be sub-divided into a few basic categories:

Lect/Lab Subject Concept Issue Approach Skill
1 Introduction to Course and Operating Systems why study OS
mechanism/policy separation
interface vs implementation
interface contracts
modularity/information hiding
powerful abstractions
appropriate abstraction
indirection/deferred binding
cohesion
opaque encapsulation
thinking data structures
OS types/history
layered/hierarchical structure
dynamic equilibrium
2 Operating Systems and Services what is OS
basic OS services
higher level OS services
layers of services
APIs and ABIs
service protocols
why functionality implmented in OS
OS goals
subroutines vs system calls
3 Processes private resource
objects and operations
abstracted resources
serially reusable resources
partitioned resource
sharable resource
programs and processes
process address space
process state (elements of)
process resources
user-mode, supervisor-mode
fork vs exec
process implementation
copy-on-write
process operations
4 Client-Facing Interfaces upwards compatability
stacks/linkage conventions
traps (exceptions)
interrupts (async events)
traps (syscalls)
limited direct execution
linkage editing - resolution
linkage editing - loading and relocation
syscalls vs procedure calls
versioned interfaces
context save/restore
static libraries
shared libraries
dynamically loadable libraries
Procedure Linkage Table
signals (exceptions)
dlopen(), dlsym()
P1A I/O and IPC file APIs
5 Scheduling metrics: completion time
metrics: throughput
metrics: response time
service level agreement
non-preemptive scheduling
time sharing
time slice
scheduling goals
starvation
convoy
cost of context switch
optimal time slice
end-to-end performance
graceful degradation
First In First Out
Shortest Job First
priority scheduling
real time scheduling
preemptive scheduling
round-robin
multi-levelfeedback queues
dynamic equilibrium
mechanism/policy separation
6 Memory Management physical address space
virtual address space
text segment
data segment
stack segment
shared library segments
protected memory access
memory management goals
internal fragmentation
external fragmentation
common errors
address space layout
stack vs heap allocation
variable size allocation
malloc vs sbrk
memory allocation life cycle
coalescing
free list design
first fit
best fit
worst fit
next fit
diagnostic free lists
garbage collection
7 Swapping and Relocation execution state model
process state (model)
swap space
paged address space
page table entry
relocation problem
pool rebalancing
base/limit relocation
segment addressing
pool/slab allocation
memory compaction
swapping
paging MMU
translation look-aside buffer
8 Demand Paging page replacement
Temporal Locality
Spatial Locality
Least Recently Used
working set
clean/dirty pages
thrashing
paging and segmentation
demand paging
page fault process
Belady's Optimal Algorigthm
LRU clock algorithm
working set clock algorithm
page stealing
copy on write
proactive page laundering
9 Threads and Inter-Process Communication thread
thread state
IPC purpose
thread motivations
IPC goals
flow control
thread stacks
user mode implementations
stream IPC
message IPC
shared memory IPC
synchronous vs asynchronous IPC
10 Mutual Exclusion non-deterministic execution
race condition
indeterminate results
critical section
parallelism scenarios
locking goals
correct mutual exclusion
mutual exclusion
atomicity
spinning
types of locks
interrupt disables
spin locks
P2A Mutual Exclusion thread API
recognize critical sections
pthread_mutex operations
pthread_cond operations
protect critical section
11 Lock Contention and Performance reasonable spinning
costs of contention
granularity
convoy
common synchronization errors
compare and swap
contention reduction
file level locking
advisory locking
12 Performance performance metrics
goals and challenges
performance principles
typical causes of performance problems
common measurement errors
load generation
traces/logs
internal instrumentation
end-to-end measurement
load characterization
analysis techniques
P2B Complex Critical Sections (contd) malloc APIs
profiling
13 asynchronous completion condition variables
locking & event completion
correct order
who to wake up
sleep/wakeup races
spurrious wakeup
synchronous requests
asynchronous completion
asynchronous events
waiting lists
14 Higher Level Synchronization Problems Semaphores
bounded buffer problem
producer/consumer problem
binary semaphores
using semaphores
condition variables
using condition variables
semaphore implementation
CV implementation
monitors
java synchronization
where to serialize
P2B Complex Critical Sections (contd) malloc APIs
profiling
15 Deadlocks Dining Philosophers problem
necessary conditions
livelock
deadlock
priority inversion
avoidance
reservations
prevention
detection and recovery
16 I/O Mechanisms I/O bus
Device Controller
disk geometry
importance of disks
disk performance
polled I/O
DMA
completion interrupts
initiating I/O operations
write-back cache
write-through cache
17 I/O performance and Programming random vs sequential I/O
transfer size
chain scheduling
buffered I/O
scatter/gather
intelligent I/O devices
read/write striping
write mirroring
parity/erasure coding
asynchronous parallel I/O
polling for asynchronous completions
non-blocking I/O
asynchronous event notifications
18 Files and File Systems file semantics
file types and attributes
data base semantics
object semantics
key-value semantics
read after write consistancy
goals of file representation
goals of free space representation
BSD file system organization
FAT file system organization
indexed data extents (I-nodes)
linked data extents (FAT)
linked free lists (Unix V5)
contiguous allocation
bit-map free lists (BSD)
FAT free list
19 File Name Spaces file namespace
file name conventions
copies vs links
symbolic vs hard links
goals of namespace representation
BSD directory entries
FAT file descriptors
20 File System Performance disks and file system design
block size & internal fragmentation
the mount operation
file access layers of abstratction
dynamically loadable file systems
user mode file systems
read cache
write-through
general/special purpose caches
how to beat LRU
delayed writes
write-back cache
defrragmentation
21 File System Robustness causes of file system damage
detection and repair
journaling and recovery
meta-data-journaling
copy-on-write file systems
log structured file systems
checksums and scrubbing
22 Operatigng System Security confidentiality
integrity
controlled sharing
object, agent, principal
mediated access
revocability
trusted computing platform
principles of secure design
authentication
authorization
access control lists
Linux file protection (ACLS)
capabilities
unforgeability
Linux file descriptors (capabilties)
principle of least privilege
Role Based Access Control
Trojan horses
challenges
cryptographic hashes
challenge/response authentication
Linux principals
Linux authentication
Linux setuid
23 Introduction to Distributed Systems goals
RPC
RPC stub
RPC skeleton
RESTful interface principles
Marshal/unmarshal
challenges
Deutsch's 7 Falacies
RPC interoperability
man in the middle attacks
RPC tool chain
XDR
reliable communication
distributed locks
leases
distributed transactions
24 Encryption and Secure Sessions cryptographic hash
unforgeable capabilities
key security
at rest encryption
symmetric encryption
asymmetric encryption
public key encryption
cryptographic privacy
digital signatures
public key certificates
secure sessions
25 Remote FIle Systems local vs cloud
client/server model
distributed file systems
remote file system goals
remote file transfer
remote file access
peer-to-peer security
work tickets
distributed authentication/authorization
26 Remote File Systems Performance & Robustness immutability
reliability
availability
stateless server protocols
idempotent operations
ACID Consistency
Read-After-Write Consistency
Close-Open Consistency
graceful degradation
write latency
replication and recovery
distributed data striping
direct client-server communication
27 Multi-Processor and Tightly Compled Systems quorum
classes of distributed systems
Single System Image
Non-Uniform Memory Architecture
tightly coupled
cluster membership
split-brain
cache consistency
APIs -> protocols
distributed consensus
scalable distributed systems
client-side caching
Symmetric Multi-Processor
Clustered
heart beating
partitioned responsibility
28 Loosely Coupled and Cloud Models loosely coupled
unit of deployment
unit of failure/replacement
Geographic Disaster Recovery
availability zones
Single Point of Failure
Eventual Consistency
BASE semantics
CAP Theorem
Horizontally Scaled
WAN-scale replication
WAN-scale consistency models

Last updated: 11/15/2023