High-Performance Computer Architecture

I have no background in computer architecture not a computer science degree. I have exposure to OS and have been a professional SWE for 5 years. I found I had to catch up lots of hardware related topics that increased my weekly workload to 20 hours/week. Otherwise, it could be 10-15 hours/week.

The material is great. Top notch, equal to the CMU course on YouTube. However, and I cannot stress this enough, THE PROJECTS SUCK!

You spend 5-10 hours tweaking parameters and recording perf. The end result is learning something obvious like "more cores = more overhead" or that "out of order execution order saves time". Really obvious information from the lecture that doesn't need repetition. I would have LOVED to implement some hardcore structures like writing a cache coherence simulation or coding reorder buffer logic.

The most coding is ~50 lines of code to write LRU cache. This is a basic leetcode question. Not okay. I expected better. The course seriously needs a revamp here. I hope the professor reads this.

** Took this course in 2025 Fall, not summer**

This was an overall OK course, but did not meet my expectation. I also did not do well in this course, got C with 76/100. Due to busy work I did not put enough time in the course. But also harder than the average courses I've taken

** Course Content **

The course covered very wide range of computer architectures, but with less dive deep in the topics, making me have a strong feeling of loss in focus. I also did not see the focus of "high performance" as highlighted in the title.

In addition, compared with other course, the total course video length is much much loger than other courses I've taken.

** Coursework ** 4 projects. Each of them are just running some scripts and fill in experiment results in a word file. You need to modify some codes (100-200 lines each proj) in the processor simulator. Projects are not hard, not time consuming, but less relevant with course content.

TAs were really good. They do review your answers and codes. Grading on the projects were generous, even if your result is a bit off, you still get points if your code looks reasonable.

** Exam ** Two exams, both quite hard in my opinion.

** Overall ** It's not an easy course. Also peers who take this course choose a hard track. You really need to spend a lot time and effort to get A/B. There are no curves. You could learn a lot things, but overall I indeed regret a bit taking the course as it's a bit different from what I would expect to learn

I took a computer architecture course in my undergrad. I did a Copmutering engineering undergrad so we implemented a simplified (aka integer only) version of a risc-v CPU on a FPGA. I didn't learn a lot more in this class. It does teach about a re-order buffer which I didn't learn previously and helped me understand how a lot of modern processors and non-simple embedded processors work so I think the class was still well worth it. It also goes into locking mechanisms for atomic operations, mutexes, etc which I had seen other viewpoints for in AOS, but this had some additional information which was nice.

But in general if you have done an undergrad course before in general computer architecture this doesn't add much besides re-order buffers.

The bottom line: This course is well-taught and well-run, with some minor gripes that you can read about in other reviews. However, the course doesn't ask very much of you, and you'll want to go above and beyond (e.g. read the textbook) if you want a solid handle on computer architecture.

I am a full-time SWE with 4 years of experience and no CS degree, no architecture experience, minimal C++ experience. This was my first complete OMSCS class. I got a solid A in the course with what I consider to be mediocre effort.

Difficulty

The exams were fair and not too difficult, I got A's on both. There are "problem solving" questions involving calculation and logical thinking applied to the course material, and there are "pure factual recall" questions. I did worse in the latter category, even though the exams were open notes. The provided course notes are insufficient if you're not prepared for the exam.

The projects are not all that hard if you are an experienced programmer in any language. If you're not familiar with C++, you can mostly "code by analogy" based on the existing code. I googled things like "how to use a map in C++" as needed.

Time commitment

If you are not an experienced programmer, expect to spend significantly longer on the projects.

Project 0: 10 hours, mostly configuration (tricky on Apple Silicon) and a weirdly difficult question Project 1: 8 hours, a lot of it is just making sense of the codebase Project 2: 7 hours, getting in the groove Project 3: 6 hours, at this point I had the hang of it

Spent ~30 hours on the lectures, ~15 hours reading various bits from Hennessy and Patterson (I wish I had spent more time with this, but I had preordered the next edition of the textbook and it kept getting delayed!), and just 3 hours studying for exams.

Adding everything together, I spent about 90 hours on this course. I wish I had spent more time engaging with the material so that I understood it more deeply. I'm hoping to go back and read the textbook more thoroughly at some point in the future.

My time commitment was pretty clumpy. There were weeks where I spent the whole weekend and a couple hours a day working to get ahead, and there was a stretch of four weeks where I spent a total of 5 hours on the class. IMO this is a great course to take if you plan on traveling or otherwise taking a week or two off.

HPCA was a very interesting class about computer architecture. The kind of effort required to succeed is very different compared other OMSCS courses that I have taken. Most of the time I spent was on closely following along with the lectures rather than doing the assignments. There is just a ton of content that you need to understand to do well on the exams, and that understanding has to be pretty deep.

The projects were not my favorite of any class in the program, but they were relevant to the material and made me think, so I guess I can't complain about them too much. I'm not sure how you could really improve on them given the subject matter of the course.

Although the tests were hard, they were super relevant to the material you are learning, and not full of stupid trivia or gotcha questions. As some other reviews on here have mentioned, the grading felt extremely fair.

Dr. Prvulovic actually showed up at all of the office hours that I attended, which is really unusual for a professor in this program. It was awesome getting to ask him not just about the lectures and assignments, but all kinds of crazy questions about computer architecture. He is clearly really passionate about the subject he is teaching, and definitely got me excited about learning more in the future.

As many have mentioned before, Nolan is an excellent TA, and all of the TA support for the tests and assignments was comprehensive and well organized.

Overall, I am really glad that I took this class despite it having been more difficult and time consuming than I had anticipated. I definitely learned a ton about an important layer of the computing stack that I was not previously familiar with.

The course material was very interesting and the professor presented topics in a way that was easy to understand. The course teaches you about how CPUs are designed to optimize processing capabilities using things like parallelism, pipelining and cache levels. The course also helps students to understand how programming and compilers can affect performance.

One thing that was really great about this course when compared to other courses is that the projects overlapped each other, which made it much more flexible for non-full-time students.

Most of the assignments involved using a simulator that simulates a CPU with pipelining, parallelism and cache features. The assignments were interesting, although I felt that some of the coding exercises were given to engage students in coding, but were loosely tied to the course material. It might have been more interesting to have students directly implement the implementation logic for some of the subjects covered.

The tests did a good job of evaluating understanding of the course material. Everything was open notes, but you still needed to prepare and study to be successful. The nice thing was that students did not have to spend time memorizing trivial minutia to prepare for the test.

I had a tougher time than expected in the course. I was able to pair it with an easier course and get A's in both.

The lectures are extremely well put together. At the beginning I was a bit lost, but to prep for the midterm I rewatched them and everything clicked for me the second time around.

Speaking of the midterm, exams they are critical to get an A in the course. Do any sample exams. Review lecture quizzes before the exam. If something does not make sense in the lecture quizzes, really dig into it. Understand every step of the problem. If you do this and take great notes, you should do quite well, but you must take the exams seriously.

For projects, partner up and make sure one or both of you has a good command of C++. The projects were interesting to me, but I found myself trial and erroring through some portions. Be sure to be thorough on the open response to maximize credit, and be sure to compare your results to ALL result spreadsheets for the respective project.

The only reason the course is not a 5/5 for me is the long wait times for project grades, which causes a lot of stress near the end, though it was understandable. I wish I could give the course a 4.5/5.

Oh, and Nolan is the GOAT. Grateful to Nolan, the TA team, and the Professor for their work in creating and providing this course.

SUMMARY

• Lectures good. Make up your own notes to reference for the exams.
• Projects are mostly good and at worst annoying. Make extensive use of the FAQ on Ed.
• Exams are fair and test your understanding. If you want to do well on the exams, understand the material well.
• The book is difficult and superfluous. It is also your highest-yield item after you've done the lectures and projects.
• Nolan very good.

LECTURES

Lectures good. Based on a reference to the then-current CPU generations, they were recorded between Haswell (2013) and Skylake (2015), and sometimes show their age (maybe 5% of the time was on spinning rust with SSDs as an afterthought), but for the most part, the constraints that silicon presents hasn't changed so much in 10 years that the underlying ideas are stale.

The quizzes in between the lectures are pretty good. They test your understanding and push you to apply that understanding. Sometimes the solution requires some galaxy-brain thinking or big simplifying assumptions, but spending 5-10 minutes banging your head against an intractable/poorly-characterized problem is instructive.

You can download all the lecture videos, put them into a playlist on your favorite video player, and then just do the quizzes online to save yourself a lot of annoying page loading.

Before the exams, I'd suggest going through the quiz questions as a review and an indicator of where you need to focus your test prep.

I found I spent around 1.5x the video time to consume a module: this included watching the lecture at increased speed, rewinding, pausing to take notes, and working out problems on scratch paper. This did not include making Anki cards from the notes (I find I make better Anki cards if I give the material a sleep cycle to marinate) or reviewing the Anki cards. This also doesn't include time LaTeXing up notes for me to bring into the exams, which is something I regret not doing.

Lectures get a 4.5/5.

PROJECTS

Every complaint you've heard about projects are true. You'll be hacking on an extremely jank codebase. The rules in the project doc are more like guidelines; I have trouble seeing how you do well on the projects without relying extensively on the ED discussion; is it really that infeasible to take the FAQ and incorporate it into the doc?

And yet: I kind of liked the projects. If you don't enjoy tweaking parameters of a CPU you're simulating and seeing how it affects the performance of a benchmark program, what are you even doing in a CS Master's program? The projects are where the concepts from the lectures became concrete.

Don't stop at reading the FAQ on Ed. If you run into a problem or ambiguity, depending on how much you've procrastinated, either someone has had the same issue or you can make an Ed post with enough time to get everything nicely resolved. Staying on top of Ed is, unfortunately, a big part in ensuring high scores on the projects. But put another way, if you stay on top of the Ed posts, you are very likely to get perfect or near-perfect scores on the projects.

You run the projects in virtual machines. You're supposed to revert the changes you made to the configuration files in between projects. Having put several hours of fruitless debugging from a failure to properly revert changes, I suggest loading up a new VM. It's faster and less error-prone than trying to revert a bunch of changes manually.

Projects get a 3.5/5.

EXAMS

Exams were fair. If you did poorly on the exams I took, I have trouble believing you had a strong grasp on the material. (This goes for me, too: there was at least one module I knew I had a tenuous grasp on going into the final and, lo and behold, I struggled in that section.)

Every discussion of the exams talks about time pressure and I don't know what these people are talking about. In both the midterm and final, I double checked every answer, including redoing the computational problems from scratch, and finished both in ~75 minutes (out of 120 and 180).

Exams are open book and open notes. As usual, this will be of little help if you go into the 2–3-hour exam not understanding 15–30 hours' of material. I assume the point of being open notes is so you're not overly penalized for forgetting some detail in a course that is not curved; consider bringing in notes that reflect that.

Exams get a 5/5.

THE BOOK

Not enough people talk about the book.

It is absolutely true that all the material you need to get an A is contained in the lectures. However, perhaps you would like to be a little overprepared for the high-stakes low-margin-of-error exam. Perhaps you, a Master's student at a top-10 university, would like to go beyond the bare minimum. If so, the book is for you.

The suggested textbook is by Patterson and Hennessy. If you take a gander at their Wikipedia pages, you will see they won a Turing award for their work on RISC. They assume a rudimentary background in computer architecture (such as you would find in "Computer Organization and Design" by the same authors) and write for an audience they assume is as smart and as interested in the subject as they are. It is not easy reading. It is also one of the best things I did in this course.

And you know how some of the lecture material is getting a bit long in the tooth? The next edition is coming out in just time for the summer 2025 term.

In my opinion: the lectures still come first: that's the material you'll actually be tested on. Next come the projects, which you can and should get ~full points on given enough attention to the Ed posts. But once you've done the lectures and maxed out your projects and want to increase your expected score in the class, the book is where it's at.

The book gets 5/5.

NOLAN

Nolan was the head TA my semester. Everything I've written (particularly the bits about the projects) assumes you will also have Nolan making the necessary Ed posts. When I lost points on the projects, the feedback I got was very good and helped me get perfect scores on the last two projects. Every good thing you've read about him in other reviews is true, as is the complete absence of bad things. Even the negative reviews only have good things to say about Nolan!

Nolan gets a 5/5, which is frankly insultingly low.