Frequently Asked Questions

1. What is computer architecture?

   Computer architecture is the study of how computer systems are designed, built, and organized.¹

2. Why is it important?

   Faster, smaller, more power-efficient, and more domain-specific computing is a necessity in almost every field. Consider: mobile phones, wearable electronics, architectures for ML, scientific computing, low-latency networking, or simply running a web browser — all these are cases where building progressively "better" computer systems is critical.

3. Why is it interesting?

   It's a complete answer to the question: "What's really inside your computer, and how does it work?"²

4. What are the current challenges in computer architecture?

   In past years, the industry relied on Moore's law for improvement in computer speeds.³ Unfortunately, we're fast approaching the theoretical limit of transistor size, meaning we must rethink the architecture of computers to better utilize the resources we have available.

5. I'm interested in computer architecture, where should I start learning?

   A great place to start is coming to SIGARCH meetings! Outside SIGARCH, there are various routes you can take.

   1. Classes: The ECE and CS departments at UIUC both offer classes in computer architecture and related topics:

      Class	Content	Comments
      ECE 120	Digital logic, basic computer organization, assembly programming. Uses LC-3.	As a first course in computer architecture, covers extremely important fundamental concepts (critical paths, logic minimization, FSMs).
      CS 233	Basic Verilog4, basic computer organization, assembly programming and optimization. Uses MIPS.	Lots of MIPS programming and learning how C compiles down. The honors section lets you build a project with FPGAs5 at the end.
      ECE 220	Interrupts and privilege. Mostly a programming class outside the first two weeks.	Not really an architecture class outside what's mentioned. Though C is useful to know.
      ECE 385	SystemVerilog and FPGA class. One lab implements a subset of LC-3 on an FPGA.	Class is being reworked as of SP23 to use Xilinx. Does not cover SystemVerilog in enough detail to do modern RTL design/verification.
      CS 433	Performance evaluation, ILP, caches, parallelism, multi-core. Some advanced topics on pipeline and cache optimization.	No MPs, the class is homework and exam based. There are projects and presentations for both the undergraduate and graduate sections.
      ECE 411	Modern computer architecture: performance evaluation, caches, pipelining, memory systems, types of I/O, parallel processing, some advanced concepts. Uses RISC-V.	Requires ECE 3916 (and you'll need to know SystemVerilog for the MPs). The final project is an excellent opportunity to build something ambitious.

      Outside these, there are various graduate courses offered each semester.

   2. Self-study: There are two parallel tracks to follow: learning theory and writing actual implementations. We'll elaborate on both of these:

      Theory: Here are some book recommendations:

      • If you're in ECE, you've taken (or are going to take) courses based on Patt and Patel's book: Introduction to Computing Systems: From Bits and Gates to C and Beyond. This book covers the LC-3 architecture.
      • Another good (but slightly unorthodox) book that goes top-down (instead of the bottom-up approach Patt and Patel uses) is Bryant and O'Hallaron's Computer Systems: A Programmer's Perspective. Here's more on the philosophy behind the book.
      • For basic architecture knowledge, we recommend Patterson and Hennessy's book, Computer Organization and Design. Try to get the RISC-V edition.
      • For more advanced topics, see Hennessy and Patterson's book Computer Architecture: A Quantitative Approach, which covers memory hierarchies, out of order and superscalar execution, and parallelism.
      • The Synthesis Lectures on Computer Architecture cover a single topic in great detail, and are a good read for more advanced students.

      Projects/Implementation: Resources here are a bit more scarce:

      • An excellent route is to learn some Verilog. Try HDLBits while starting out. Unfortunately, the really hard part of RTL design is verification, which isn't well-covered.
      • Once you know Verilog, try implementing a basic processor (like LC-3), and running some basic programs in simulation.⁷ Synthesize your core to an FPGA, and run a similar set of programs there.
      • Continuing — pipeline your processor, implement a memory system, (caches). Make your cache more efficient (is it write-back? pipelined? lockup-free?). Add branch prediction. Add prefetching. Make it out-of-order. Is it superscalar? Instantiate multiple cores and solve coherence problems using snooping/directories. Add an MMU and TLBs. Try booting a real OS on your core (xv6, Linux, etc.). Implement a paper.

      We know, projects are hard and need resources that aren't always available. This is where SIGARCH's workshops come in: we provide hardware and guidance, and you get to implement something cool over a couple of days!