Nine lectures, connected ideas

What happens when a program runs?

First half: OS responsibilities; user and kernel modes; interrupts and system calls; programs and processes.

Second half: Process states, context switching, threads, shared resources and basic interprocess communication.

How should processors be shared, and what changes when deadlines matter?

First half: Multiprogramming; scheduling criteria; FCFS, SJF, round robin and priorities; worked timelines.

Second half: Multicore considerations; starvation; hard and soft real time; deadlines; introductory rate-monotonic and EDF examples.

How can concurrent activities cooperate without corrupting shared state?

First half: Race conditions, interleavings, critical sections, atomic operations and mutexes.

Second half: Semaphores, condition variables and monitors; producer–consumer and dining philosophers.

When can processes wait forever, and what can we do about it?

First half: Necessary conditions; resource-allocation and wait-for graphs; deadlock, starvation and livelock.

Second half: Prevention, avoidance, detection and recovery; a safe-state example; practical lock ordering.

How does a process get its own view of memory?

First half: Address spaces, allocation, fragmentation, segmentation in context and paging.

Second half: Page tables, address-translation exercises, TLBs, multilevel tables and memory protection.

What happens when the pages a program needs are not in physical memory?

First half: Demand paging, page-fault handling, lazy allocation and copy-on-write.

Second half: Replacement policies, locality, working sets, thrashing and integrated examples.

No class this week. The midterm contributes 30% of the course grade. Exact date and coverage will be announced.

How do applications access devices and keep data beyond execution?

First half: Device interaction, interrupts and DMA, buffering and caching, storage characteristics.

Second half: Files, directories, allocation and metadata; persistence; introductory crash consistency and journaling.

How can systems share hardware while protecting their boundaries?

First half: Hypervisors, guest and host relationships, CPU and memory virtualization, VMs versus containers.

Second half: Protection boundaries, privileges, permissions, least privilege, isolation failures and resource limits.

What changes when cooperating processes run on different machines?

First half: Messages and RPC, latency, timeouts and partial failure.

Second half: Ordering and coordination; replication and consistency fundamentals; a distributed-storage example and paper-analysis preparation.

Research-paper presentations in English, 15 minutes per student. Paper allocations and individual speaking slots will be announced.

Research-paper presentations in English, 15 minutes per student. Paper allocations and individual speaking slots will be announced.

Research-paper presentations in English, 15 minutes per student. Paper allocations and individual speaking slots will be announced.

Research-paper presentations in English, 15 minutes per student. Paper allocations and individual speaking slots will be announced.