Learning Objective Bundles

• X86 & CC (Lecture 2)
  • I can explain the use of the most common X86 registers: %EAX, %EBX, %ECX, %EDX, %EBP, %ESP, and %EIP
  • Given a memory dump of the stack, the value of %ESP and %EBP, and the assembly code for a function, I can identify the return address, the saved registers, the parameters, and the local variables.
  • I can describe which common X86 registers are maintained across C function calls and which are not (scratch registers and return value)
• GDB (Lecture 3)
  • I can use GDB to single-step through my program instruction by instruction (stepping into or over function calls)
  • I can use GDB to single-step through my program source-line by source-line (stepping into or over function calls)
  • I can use GDB to see my source code
  • I can use GDB to see my assembly instructions
  • I can use GDB to set a breakpoint at a function
  • I can use GDB to set a breakpoint at a source line
  • I can use GDB to list breakpoints
  • I can use GDB to remove breakpoints
  • I can use GDB to set a conditional breakpoint
  • I can use GDB to set a breakpoint at an assembly instruction
  • I can use GDB to display memory
  • I can use GDB to print a C expression
  • I can use GDB to see the values of registers
  • I can use GDB to see the stack trace of functions to this point, and explain the output
• Shell (Lecture 4)
  • I can demonstrate how a shell uses the fork and exec system calls to execute programs
  • I can demonstrate how a shell uses the close, open, fork and execv system calls to execute programs with redirection
  • I can demonstrate how a shell uses the pipe, close, fork, and execv system calls to implement pipes in a shell
  • I can explain how the pipe system call works.
• Isolation (lecture 4-5)
  • I can describe the four isolation mechanisms (User/kernel mode, address spaces, timeslicing, system call interface), how they are implemented, and what HW support is needed for each.
• Segment/page tables (Lecture 6, 7)
  • I can explain the elements of a of a segment table or page table
  • Given a virtual address, I can find a corresponding physical addresses using a segment table and page tables
  • I can describe and use Page Tables, Page Table Entries, Multi-level Page Tables, PTE bits (dirty, accessed, writable, present, user)
  • I can describe how to use paging hardware to implement:
    • Demand sbrk allocation
    • Demand stack allocation
    • A shared zero-filled page
    • Copy-on-write fork
    • Demand paging
    • Memory-mapped files
  • I can explain the TLB, how it works, and why it exists
  • I can describe circumstances when the TLB needs to be flushed, and what happens if that flush doesn't occur
• Virtual Memory (Lecture 7)
  • I can explain how virtual memory works, including:
    • How the Page Table is initialized
    • What the Page Fault Handler will do
    • How and when pages are evicted
• Interrupts, Exceptions, System calls (Lecture 8)
  • I can distinguish what events would be classified as an interrupt, exception, and system call.
  • I can explain the journey of an interrupt (how it is generated, handled by the CPU, dispatched to a ISR, and then ISR returns control)
  • I can explain advantages/disadvantages of interrupts vs. polling
  • I can identify what happens to the stack during an interrupt, and explain why it's an issue
  • I can describe nested interrupt handling, the tradeoffs, and the necessary hardware support
• Locks (Lecture 9)
  • I can explain when locks are needed and when they are not needed
  • I can explain what a race condition is and what a critical section is
  • I can describe deadlock
  • I can identify potential deadlock in code
  • I can describe ways of avoiding deadlock
  • I can explain how to implement locks on an x86
  • I can explain what a spin lock is and when it is appropriate to use.
• Process/threads (Lecture 10)
  • I can explain the difference between processes and threads
  • I can explain the differences between kernel threads and user threads
  • I can explain what is necessary to implement a user library for threading
  • I can describe a context switch and explain what is switched when:
    • Switching processes
    • Switching threads within a process
  • I can describe the unix system call for creating a process, and explain how it works
  • I can explain what the unix system calls wait and exit do, use them in code, and describe how they are implemented.
  • I can describe what a zombie process is in unix, and how and when zombies are destroyed.
• Scheduling (lecture 10)
  • I can describe various scheduling techniques and compare and contrast them:
    • Round-robin scheduling
    • Multi-level Feedback Queue scheduling
    • Lottery scheduling
  • I can describe the states a process can be in and describe what events cause a process to move between states
• File systems (lecture 11)
  • I can identify what parts of a file are metadata as opposed to file data
  • I can explain how unix hard links work, and the difference between hard links and symbolic links
  • I can identify what parts of a filesystem are filesystem metadata
  • I can explain what is contained in an open-file table and what the differences are between system-wide and per-process open-file tables
  • I can explain how i-nodes work
  • I understand the difference betwen direct and indirect blocks
  • Given an i-node, I can determine what block number contains a particular byte offset in a file
  • I can describe the important unix system calls used for files, and how they are used: open, close, read, write, seek.
  • I can describe how file descriptors are used and implemented.
  • I can describe the buffer cache, how it works, and why it is important
• File system journaling/logging (Lecture 16)
  • I can identify the main idea behind journaling and how journaling is implemented (at a high level)
  • I can compare and contrast xv6 logging and ext3 logging
  • I can explain how ext3 uses absorption and batching to improve performance
• ZFS (Lecture 17)
  • I can explain how what a ZFS pool is and how it differs from a traditional FS that can't span a volume
  • I can explain how ZFS uses checksums external to a block (and how it is similar to a Bitcoin blockchain)
  • I can explain why external checksums are necessary for end-to-end data integrity
  • I can explain what a data virtual address is, and how they are allocated and deallocated
  • I can explain how ZFS uses Copy-on-Write (COW) avoid many of the consistency issues of traditional filesystems
  • I can explain what the term resilvering is and how that applies to ZFS
• VM primitives for user programs (Lecture 18)
  • I can describe how mmap, mprotect, and munmap can be used to provide user-level access to memory mapping
  • I can describe why some programs might want to have access to (fast) paging hardware
  • I can describe what Baker's algorithm is and how virtual memory primitives can improve its speed
• Exokernel (Lecture 19)
  • I can describe the differences between a monolithic kernel, a microkernel, and an exokernel
  • I can describe user applications that would benefit from an exokernel interface
  • I can describe the exokernel interface for memory sharing
  • I can describe the exokernel interface for CPU sharing
• Scalable locks/Multicore caching (Lecture 21)
  • I can explain how cache coherence can be implemented with MSI states and invalidate/find messages
  • I can explain why test & set spinlocks take O(N^2) time if N cores are waiting
  • I can compare and contrast test&set spinlocks, ticket locks, and MCS locks
  • I can identify the key features of each locking mechanism and its interaction with the multicore cache
• Memory reordering (Lecture 22)
  • I can explain what read/write barriers are
  • I can identify circumstances in which read/write barrriers are necessary
  • I can add add read/write barriers to existing code as necessary to ensure correctness
• RCU (Lecture 22)
  • I can explain the RCU API used by readers
  • Given single-core code that handles a linked list, I can add RCU calls to make it safe to use with multi-cores
  • I can explain how synchronize_rcu is implemented
• Virtualization (Lecture 23)
  • I can explain what a VM is
  • I can describe the terms Guest OS, Virtual Machine, VMM, Hypervisor
  • I can identify privileged instructions and describe how trap-and-emulate works for those instructions
  • I can identify non-privileged instructions and explain how these instructions can be executed unchanged
  • I can describe why x86 isn't classicaly virtualizable
  • I can describe how a binary translator can dynamically translate basic blocks
  • I can explain what additional hardware is needed for x86 hardware virtualization
  • I can explain what extended page tables are and how they work in conjunction with traditional paging
  • I can explain what Intel VT-X is and the API it provides
• Dune: Safe user-level access to privileged CPU features
  • I can explain how Dune processes can run at CPL 0, and why that can be useful
  • I can explain how a Dune process can get fast page faults
  • I can explain how a Dune process can perform a Linux system call
  • I can explain at a high level how Dune processes are implemented
• IX System for high-performance networking
  • I can explain some of the bottlenecks in high-speed networking using Linux
  • I can explain how IX uses Dune to provide low-level access to Ethernet cards
  • I can explain how and why IX uses polling rather than interrupts for its Ethernet cards
  • I can explain why IX doesn't share data between cores
  • I can explain how IX uses batching to improve performance
  • I can explain the API used between applications and IX
  • I can explain how IX uses Dune to provide zero-copy for the data that is being transmitted