MIT 6.823 Computer System Architecture is MIT's graduate course on how processors and memory systems are built: instruction sets, pipelining, caches, virtual memory, out-of-order execution, branch prediction, multithreading, VLIW, vector machines and multiprocessors. This post lists the twenty Fall 2007 lecture notes as they were published, explains where the course lives today, and gives a short study guide to the main ideas in each lecture.
Key takeaways
- The Fall 2007 course had 20 lectures, from early computer history (L-01) to symmetric multiprocessors and memory consistency (L-20).
- The original 2007 handout links no longer open. The course page now redirects to the current offering, numbered 6.5900 [6.823].
- MIT OpenCourseWare publishes an earlier full offering of 6.823 (Fall 2005) with lecture notes.
- The lecture sequence is a good study plan for CPU architecture interviews: pipelines, caches and virtual memory first, then out-of-order and speculative execution.
Where the 6.823 lecture notes are now (checked November 1, 2026)
We checked every link in this post on November 1, 2026:
- The individual 2007 handout files (pdf and ppt) now return "not found", and we found no working archived copies of them in the Internet Archive. The lecture list in the deep dive below keeps the 2007 titles and dates as the original record, and points each lecture to the closest set of notes that is still online.
- The course page csg.csail.mit.edu/6.823 now redirects to the current offering, 6.5900 [6.823] Computer System Architecture, which at the time of checking showed the Fall 2026 term with its own lecture notes, syllabus and labs. MIT renumbered many EECS subjects, and 6.823 now carries the number 6.5900.
- MIT OpenCourseWare: 6.823 Computer System Architecture, Fall 2005, lecture notes are freely available and covers much the same ground as the 2007 list below.
What the course covers: a study guide by theme
The twenty lectures fall into six themes. The notes below summarize the core idea of each theme in our own words so that the page is useful even without the slides.
| Theme | Lectures | Core questions |
|---|---|---|
| Instruction sets and their history | L-01 to L-03 | Why did machines move from accumulator and stack designs to general-purpose registers and load-store ISAs? |
| Basic implementation | L-04 to L-06 | How is an ISA built as a single-cycle datapath, a pipeline, or a microprogrammed machine, and what hazards arise? |
| Memory hierarchy | L-07 to L-09, L-14 | How do caches, address translation, TLBs and advanced memory techniques hide memory latency? |
| Instruction-level parallelism | L-10 to L-13, L-16 | How do out-of-order issue, register renaming, branch prediction, speculation and VLIW scheduling run more instructions per cycle? |
| Other forms of parallelism | L-15, L-17, L-20 | When do multithreading, vector units and multiprocessors beat a faster single core, and what do synchronization and memory consistency require? |
| Systems topics | 1-Intro, L-18, L-19 | How do binary instrumentation (the Pin tool used in the labs), virtual machines, dynamic translation and reliability techniques fit in? |
How to use these notes for interviews
- Start with pipelining, hazards and caches. Most CPU architecture interviews begin there.
- Be ready to draw a five-stage pipeline and show where forwarding paths go.
- Practice cache arithmetic: given capacity, block size and associativity, work out the number of sets and the tag, index and offset bits.
- Explain register renaming and the reorder buffer in plain words before using the jargon.
Our top 50 CPU architecture interview questions with answers follows much the same order, and the interview question on CPU design is a good short exercise. For background on the profession, see who are the computer architects. Short definitions of out-of-order execution and cache are on The Semiconductor Hub glossary.
Deep dive: the numbers and details
This part holds the full 2007 lecture list, the core ideas of each theme with worked numbers, and a short FAQ. Skip it if the overview is all you need.
MIT 6.823 Fall 2007 lecture list (original post)
The twenty lectures and the Pin tutorial as published in Fall 2007. The third column is the original lecture date. The last column links to the matching lecture of the Fall 2005 offering on MIT OpenCourseWare, which covers the same material in a slightly different order.
| Lecture | Title | Date (2007) | Closest notes on MIT OpenCourseWare (Fall 2005) |
|---|---|---|---|
| L-01 | Computer System Architecture | 09/05/07 | 2005 L1 notes (PDF page) |
| 1-Intro | Introduction to Pin | 09/05/07 | No direct match |
| L-02 | Influence of Technology and Software on Instruction Sets: Up to the dawn of IBM 360 | 09/10/07 | 2005 L2 notes (PDF page) |
| L-03 | Instruction Set Evolution in the Sixties: GPR, Stack, and Load-Store Architectures | 09/12/07 | 2005 L3 notes (PDF page) |
| L-04 | Hardwired, Non-pipelined ISA Implementation | 09/17/07 | 2005 L5 notes (PDF page) |
| L-05 | Instruction Pipelining and Hazards | 09/19/07 | 2005 L6 notes (PDF page) |
| L-06 | Microprogramming | 09/26/07 | 2005 L4 notes (PDF page) |
| L-07 | Cache Organization | 10/01/07 | 2005 L7 notes (PDF page) |
| L-08 | Memory Management: From Absolute Addresses to Demand Paging | 10/03/07 | 2005 L9 notes (PDF page) |
| L-09 | Modern Virtual Memory Systems | 10/10/07 | 2005 L10 notes (PDF page) |
| L-10 | Complex Pipelining | 10/15/07 | 2005 L11 notes (PDF page) |
| L-11 | Complex Pipelining: Out of Order Execution and Register Renaming | 10/17/07 | 2005 L12 notes (PDF page) |
| L-12 | Branch Prediction | 10/22/07 | 2005 L13 notes (PDF page) |
| L-13 | Speculative Execution | 10/24/07 | 2005 L13 notes (PDF page) |
| L-14 | Advanced Memory | 10/29/07 | No direct match |
| L-15 | Multithreading | 10/31/07 | 2005 L23 notes (PDF page) |
| L-16 | VLIW/EPIC: Statically Scheduling ILP | 11/05/07 | 2005 L21 notes (PDF page) |
| L-17 | Vector Computers | 11/07/07 | 2005 L22 notes (PDF page) |
| L-18 | Virtual Machines and Dynamic Translation: Implementing ISA's in Software | 11/14/07 | 2005 L25 notes (PDF page) |
| L-19 | Reliable Architecture | 11/19/07 | 2005 L24 notes (PDF page) |
| L-20 | Symmetric Multiprocessors: Synchronization and Sequential Consistency | 11/26/07 | 2005 L16 notes (PDF page) |
Courtesy: MIT
Pipelining and hazards (L-05, L-10)
A pipeline overlaps the stages of successive instructions. Three hazards stop it from issuing one instruction per cycle: structural hazards (two instructions need the same hardware), data hazards (an instruction needs a result that is not yet written) and control hazards (the next instruction address is not yet known after a branch). Forwarding, interlocks (stalls) and branch prediction are the standard fixes.
Caches and virtual memory (L-07 to L-09)
A cache is described by its capacity, block size and associativity. Misses are usually grouped as compulsory, capacity and conflict misses. Virtual memory maps virtual pages to physical frames through page tables, and a TLB caches recent translations so that most loads and stores do not walk the page table.
Out-of-order and speculative execution (L-11 to L-13)
Register renaming removes false dependences (write-after-read and write-after-write), so instructions can run as soon as their true inputs are ready. A reorder buffer retires results in program order, which keeps exceptions precise and lets the machine discard work after a mispredicted branch.
Multiprocessors (L-20)
Once several cores share memory, the hardware must keep caches coherent and define a memory consistency model. Sequential consistency is the simplest model to reason about: the result is as if all memory operations ran in some single order that respects each core's program order.
Worked example: cache address breakdown
Take a 32 KB, 8-way set-associative cache with 64-byte blocks and 32-bit addresses.
- Number of blocks: 32,768 / 64 = 512.
- Number of sets: 512 / 8 ways = 64.
- Offset bits: log2(64) = 6 (to pick a byte in the block).
- Index bits: log2(64 sets) = 6.
- Tag bits: 32 - 6 - 6 = 20.
This is the arithmetic interviewers expect you to do in your head, and it is the core of L-07.
Worked example: average memory access time
Average memory access time (AMAT) = hit time + miss rate x miss penalty. With a 1-cycle hit, a 5 percent miss rate and a 100-cycle penalty, AMAT = 1 + 0.05 x 100 = 6 cycles. Halving the miss rate to 2.5 percent gives 3.5 cycles. Reducing misses and hiding their latency are the themes of L-07, L-09 and L-14.
Worked example: what hazards cost a pipeline
An ideal five-stage pipeline completes one instruction per cycle (CPI = 1). Suppose 20 percent of instructions are branches, branches are resolved one stage late so a wrong guess costs 2 bubble cycles, and the predictor is right 90 percent of the time. The added CPI is 0.20 x 0.10 x 2 = 0.04, so CPI = 1.04. With no prediction (always stall 2 cycles on every branch) the CPI would be 1 + 0.20 x 2 = 1.4. That difference is the subject of L-12 and L-13.
Frequently asked questions
Is MIT 6.823 still taught?
Yes. As of November 1, 2026 the old course address redirects to 6.5900 [6.823] Computer System Architecture, which showed a Fall 2026 term.
Where can I get the 6.823 lecture notes for free?
MIT OpenCourseWare hosts the Fall 2005 offering of 6.823 with lecture notes. The current course site also lists its own lecture notes. The 2007 files no longer open.
What are the prerequisites for 6.823?
The current course page lists 6.004 (MIT's undergraduate computation structures course) or equivalent. In practice you need digital logic, basic assembly language and a simple pipelined processor.
Which textbook pairs well with 6.823?
Hennessy and Patterson's Computer Architecture: A Quantitative Approach (Morgan Kaufmann) covers the same topics in depth and is widely used alongside graduate architecture courses.


Your comments will be moderated before it appears here.