Berkeley CS 61C: Great Ideas of Computer Architecture (Machine Structures)
CS 61C completes Berkeley's 61 series, going below the abstraction line: C programming, RISC-V assembly, CPU datapaths and pipelining, caches, virtual memory, and parallelism. It's required for the CS and EECS majors and is the course where software students finally see what the hardware is doing.
Fennie is independent and not affiliated with UC Berkeley. This is an unofficial study guide.
Build my CS 61C study planWhat makes it hard
The course stacks several unfamiliar layers — C's manual memory management, assembly, then hardware design — and each project lives at a different layer. Exam questions on number representation, cache behavior, and pipeline hazards are calculation-heavy and unforgiving of small slips, which is why past-exam practice matters so much here.
What you'll cover
- • C and manual memory management
- • RISC-V assembly and calling conventions
- • CPU datapaths and pipelining
- • Caches and memory hierarchy
- • Virtual memory
- • Parallelism: SIMD, threads, and MapReduce ideas
The CS 61C study guide
How to study for Berkeley CS 61C, step by step.
- 1
Get rigorous about C and pointers immediately
Coming from 61A/61B, C's manual memory model is the first wall. Draw memory diagrams for every pointer exercise and learn to use a debugger early — segfault archaeology eats project time otherwise.
- 2
Do cache and number-representation drills weekly
Two's complement, floating point, and cache hit/miss calculations are mechanical but error-prone, and they're guaranteed exam real estate. Short weekly drills make them reliable points instead of slip hazards.
- 3
Trace the datapath by hand
For pipelining and hazards, draw the pipeline diagram and walk instructions through it cycle by cycle. The exams test whether you can reason about what the hardware does, not whether you memorized the picture.
- 4
Start the projects at release and budget for debugging
Assembly and hardware-level projects fail in opaque ways, and the office-hours queue swells near deadlines. Early starts buy you the calm debugging time these projects actually require.
- 5
Work the TBP/HKN archives before every exam
61C exams are calculation-heavy with well-established question genres — caches, pipelines, floating point. Timed past-exam practice from Berkeley's archives is the highest-yield prep available.
- 6
Keep every layer on schedule with Fennie
Upload the CS 61C schedule and Fennie's Daily Plans pace labs, projects, and exam prep across all the abstraction layers, with cache and number-representation drills generated from your actual course materials. Free to start.
Start my CS 61C plan free
How Fennie helps with CS 61C
Upload the CS 61C schedule and Fennie's Daily Plans pace projects and exam prep across the course's many layers — C, assembly, hardware — so no unit gets crammed. Chat through pipeline hazards or cache behavior step by step, and drill generated number-representation and cache-calculation quizzes until the mechanical questions are reliable points.
FAQ
Is CS 61C hard?
It's considered the most content-dense course in the 61 series — not conceptually deeper than 61B, but broader, with C, assembly, and hardware design all new. Students who keep up weekly and drill the calculation-style questions find it very manageable.
Do I need CS 61B before CS 61C?
61A and 61B (or equivalent) are the expected preparation. 61C assumes you can program comfortably; what it adds is everything below the language — memory, assembly, and hardware — so programming fluency matters more than any specific data structure.
How do I study for CS 61C exams?
Drill the mechanical question genres — two's complement, floating point, cache hits and misses, pipeline hazards — until they're fast and accurate, then work timed past exams from the TBP/HKN archives. Most lost points are calculation slips, not conceptual gaps.
Pass CS 61C with a plan, not a cram
Upload your CS 61C materials and Fennie generates a Daily Plan paced to your deadline — plus chat, flashcards, and quizzes built from the actual course content.
Get started freeMore Berkeley courses
CS 61A — The Structure and Interpretation of Computer Programs
CS 61A is Berkeley's legendary intro CS course, taught primarily in Python with excursions into Scheme and SQL. It emphasizes abstraction — higher-order functions, recursion, object-oriented programming, and interpreters — and it's the first course in the CS 61 series that every CS and Data Science student takes.
CS 61B — Data Structures
CS 61B is Berkeley's data structures course, taught in Java, covering lists, trees, hashing, graphs, sorting, and asymptotic analysis. It's the second course in the 61 series and the one most cited in industry-interview prep — its projects, including the famous build-your-own-world and Gitlet (build a mini Git), are substantial software engineering exercises.
CS 70 — Discrete Mathematics and Probability Theory
CS 70 is Berkeley's discrete math and probability course, required for the CS major, covering proofs, graph theory, modular arithmetic, RSA, polynomials, counting, and a substantial probability unit. It's the theory gateway — and by reputation, the hardest lower-division course in the major.
CS 161 — Computer Security
CS 161 is Berkeley's upper-division security course, covering memory-safety attacks and defenses, cryptography, web security, and network security. Its centerpiece is a substantial project sequence, including a famous secure file-sharing system built in Go that students design and defend themselves.