Schedule

See below for the tentative class schedule!

CPUs: Pipelines, virtual memory, and interrupts

• Lecture 1 (January 26): Course introduction and overview of processor architecture

• "Guide to x86-64" from Stanford's CS 107 class
• "Notes on x86-64 programming" by Jean-Christophe Filliâtre
• "Stack frame layout on x86-64" by Eli Bendersky
• "Classic RISC Pipeline" at the Wikipedia

• Lecture 2 (January 28): x86-64 page tables

• "Virtual memory" from CS 61's documentation
• "Page tables" from CS 61's documentation
• "Memory layout" from the CS 1610's documentation

• Lecture 3 (February 2): Multitasking and preemption

• "Chapter 3: Traps, interrupts, and drivers" from the textbook on MIT's xv6 teaching OS---read pages 39 and 40 up to but not including "X86 protection." The entire book is quite interesting; you might enjoy comparing xv6's design with that of Chickadee. Note that the linked-to textbook refers to an older version of xv6 which runs on x86 hardware. The most recent version of xv6 runs on RISC-V hardware.
• CS 1610's documentation about contexts: Read up to and including "System calls: voluntary user context switch."

• Lecture 4 (February 4): Interrupts

• CS 1610's Lecture 2 discussion of TLBs: Slides 36 through 41.
• CS 1610's documentation about contexts: Start at the discussion "Kernel yields: voluntary kernel context switch."

Synchronization: Ensuring correctness on single-core and multi-core machines

• Section 1 (Week of February 9): Kernel extensions
• Lecture 5 (February 9): Multithreading and synchronization

• Review Lecture 3's discussion of user-level stacks, kernel-level stacks, and context state.
• CS 61's documentation about threading
• CS 1610's documentation about spinlocks
• CS 1610's documentation about synchronization invariants: Read up to and including "Scheduling invariants," and also read "Page table invariants."

• Lecture 6 (February 11): Interrupts, concurrency, and synchronization

• Andi Kleen's discussion of how Linux was changed to work on multi-core machines: Read up to and including Section 6 ("History of Linux kernel scalability"). This document was written in 2009, but it provides a very readable discussion of the benefits and challenges of writing concurrent software in general (and concurrent OSes in particular).
• Chapter 7 ("Locking") in the xv6 textbook: Read up to and including Section 7.1 ("Races"), and read Sections 7.3 ("Code: Using locks"), 7.4 ("Deadlock and lock ordering"), and 7.8 ("Real world"). xv6 is MIT's teaching OS; xv6 has a different codebase than Chickadee, but the basic ideas are all the same!

• NO CLASS: PRESIDENTS DAY (February 16)
• MIDTERM 1: IN CLASS (February 18)
• Section 2 (Week of February 23): The microkernel debate
• Lecture 7 (February 23): Wait queues

• ops-class.org's discussion of synchronization: These lecture notes provide a high-level overview of various synchronization topics like critical sections, locks, and condition variables. If you want to understand Chickadee-style wait queues, you should first understand classic condition variables.
• Chickadee's documentation on wait queues: In pset2, you'll need to write the code which implements the Chickadee wait queue interface!

Interacting with hardware devices: Storage devices, file systems, DMA, memory-mapped IO

• Lecture 8 (February 25): Swapping and memory maps

• ops-class.org's discussion of swapping: Note that ops-class.org's assignments use the teaching operating system OS/161, which was created at Harvard and was used in the older version of the Harvard class that is now called CS 1610! OS/161 runs on an emulated MIPS processor that uses a software-managed TLB: in other words, when a TLB miss happens, the OS decides how the TLB should be updated. In contrast, Chickadee runs on x86-64 chips that use hardware-managed TLBs: when a TLB miss occurs, the processor automatically walks the page table to try to locate the relevant TLB entry.
• "Reconsidering swapping" by Jonathan Corbet: An older but still relevant article which discusses the difference between anonymous pages (which hold dynamic run-time data like stack pages) and file-backed memory pages (like chunks of executable code that are backed by equivalent on-disk blocks in a program's executable binary). A nice follow-up read is Chris Down's discussion of swapping.

• Lecture 9 (March 2): VFS
• Lecture 10 (March 4): Storage devices and data layout
• Section 3 (Week of March 9): Optimizing context switches
• Lecture 11 (March 9): Journaling
• Lecture 12 (March 11): Device interactions
• NO CLASS: SPRING BREAK (March 16)
• NO CLASS: SPRING BREAK (March 18)
• Section 4 (Week of March 23): TBD
• Lecture 13 (March 23): Log-structured file systems
• Lecture 14 (March 25): Synchronization and memory ordering

Security, Resource Isolation, and Advanced Systems Programming

• Lecture 15 (March 30): DAC, MAC, and iOS
• Lecture 16 (April 1): Writing kernels in high-level languages
• Section 5 (Week of April 6): TBD
• Lecture 17 (April 6): Scheduling
• NO CLASS: HACKING DAY (April 8)
• Lecture 18 (April 13): Virtualization
• Lecture 19 (April 15): Networking
• Lecture 20 (April 20): EthiCS
• Lecture 21 (April 22): GPUs
• Lecture 22 (April 27): Security
• MIDTERM 2: IN CLASS (April 29)