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.

Taking this as part of the computing systems specialization. I really enjoyed it, but keep in mind that I:

• (barely) made an A in my final grade,
• enjoyed the course material,
• did my undergraduate in computer science (but did not retain anything from my computer organization / architecture course, I had a very flawed CS undergrad experience)

Criticisms: the second half of this course's lectures were extremely unhelpful. I feel like they provided a lot more trivia than real learning. There is also a stark dearth of practice material for the final, and the quizzes for the second half of the course's lectures did not help with understanding the concepts that the final tested us on.

Whereas this is usually a huge disadvantage for most classes, it's not quite as detrimental to HPCA, since concepts such as Cache Coherence, Memory Consistency, and Synchronization are decades-old problems with heaps of resources to study from. I highly suggest using Onur Mutlu's computer architecture course--both his lectures (provided for free on youtube) and his assigned readings--to develop a stronger conceptual understanding of the subjects covered in the second half of the course.

Positives: A lot of this course material is revisited in the first half of AOS. It's possible to take AOS before HPCA, but I think that taking HPCA before AOS (and putting out the extra effort to understand the concepts in the second half of the course more deeply) actually balances out the rigor of AOS a lot more. In short, if you expend more effort on the second half of the course to understand the material more deeply, it will pay off in dividends.

The exams are fair, but difficult to prepare for, especially as they tend to differ from the practice exams offered to us. They are luckily open book. I printed out all of my notes--yes, all of them--and a number of collected articles + textbook references in preparation for the final exam and I did very well for it as a result. This came out to be several hundred papers, so be careful. The projects aren't difficult if you have taken GIOS, but without a stronger background in C++ you will struggle more. You will want Github user awpala's HPCA setup and debugger repository, which will help IMMENSELY with debugging your projects. DO NOT use ARM architecture if you want to be able to debug your coursework.

I really appreciated that the midterm adhered closely tot he first half of the course's material, I found that very fair. I also appreciated that there was about two weeks of preparation time for the final exam given to us after project 3's submission date. In this way HPCA is a slightly easier course than other OMSCS classes which may have more exams, and more overlapping due dates.

In general, I really enjoyed the structure of this course and I really liked the assignments. The TA team is very consistent, though due to the nature of the projects, you won't know your project grades until after you take the final (so most of your grade is in the dark). That being said, the TA team is very receptive to private discussions and helpful with coding problems if you raise them in the discussion forum. My qualms with the course is just the drop in quality with the lectures after the midterm content and very little in the way of additional resources to reinforce our understanding of the material. Success for this class will rely on how willing you are to dig around for practice materials and references, especially if you haven't encountered this information before. Expect to set out a lot of time preparing for the exams--I spent two weeks, roughly 2-3 hours each day after work and 5 hours on weekends, in order to prep for them.

Great class, it's one of the few I've taken that's relatively light with work but still rewarding. Grading is slow (which is annoying) but overall this class is a great experience.

High points of his class

• Great lecture videos. Milos is an awesome presenter and you can tell he had fun recording the lectures.
• Very well organized, class with clear requirements. Nolan is awesome and he this class running on rails.
• I genuinely think the TA staff is reasonable and respect the students. I am pretty active on Ed and left every interaction with TAs feeling positively. There are not too many rules and everything just feels reasonable and accommodating. Very few classes are that way.
• Grading on the exams is generous. Overall you are given the benefit of the doubt, if you strongly implied something but didn't say it you got points. So even though grading is slow, it was high quality. That's why I can forgive the slow grading. The class would be much harder if grading weren't so understanding.
• From a schedule perspective the class is very flexible. There are 4 projects and 2 exams. Projects are pretty light IMO. Most of the time you spend in the class is watching lectures. I was able to go on a 1 week vacation without even thinking about class which was awesome.

Low Points

• Grading is slow. It doesn't really make sense because a few days after the exam 2 projects and the exam got released. Meanwhile in the months before the exam only 2 projects and the midterm were graded. It's annoying, but FWIW the grades on the projects are very high (median 99 for 3rd and 95 for 4th)
• TAs generally respond most questions on Ed but it's not going to be immediate. That said the pace of the class is pretty slow, so eh, not a big deal IMO.

Misc Some people don't like the projects, but I didn't mind them. You modify the SESC codebase which models how a processor runs to essentially add features or change the behavior of the processor. I personally thought the projects made me think about the lecture content. I also thought that the supplemental FAQ posted on Ed made it pretty straightforward to do well on the projects. Just follow that you'll do great. Also while SESC isn't a good codebase, I'd generally say it's unremarkable, average or slightly below. As a developer I think assignments that give you a big, imperfect codebase and require you to understand it enough to add features, is an an excellent exercise. So on a lot of levels I thought the projects were useful.

This is my first time feeling compelled to write a review for a class. For context, this is my 10th OMSCS class. Given all the cutting-edge advancements in computer architecture, I was eager to explore modern innovations and how they shape today’s technology landscape. Unfortunately, this course fell far short of those expectations. Much of the material is rooted in the past, with minimal discussion of contemporary topics, which was a major letdown. Compounding the disappointment, this is by far the worst-run class I’ve experienced, both in and outside of OMSCS.

As I write this, we turned in the final exam earlier this week, yet 65% of the overall grade remains ungraded. Projects submitted over two months ago are still ungraded, with no feedback provided in Ed Discussion. Whenever students ask about grading timelines or updates, those inquiries go completely ignored. The lack of transparency, coupled with the disjointed nature of the course—where the projects feel entirely disconnected from the exams—makes it difficult to get meaningful feedback or gauge your performance.

Lectures: (4/5) The lectures are packed with information and are well-structured. If you have the time to sit through hours of these, you’ll likely find them valuable. However, the content is heavily focused on older concepts in computer architecture, leaving little room to discuss cutting-edge developments. This gap was particularly disappointing, as I expected a course in this area to connect past fundamentals to today’s rapidly evolving technological landscape

Projects: (1/5) The projects, unfortunately, are a major weak point. As mentioned earlier, don’t expect feedback or a robust learning experience. The projects are straightforward but uninspired, and most of your time will be spent tweaking code. For those who learn best through hands-on activities and rely on feedback to improve, this will be a letdown. The lack of connection between the projects and the rest of the course, especially the exams, adds to the sense of detachment.

Exams: (2/5) The exams are difficult and account for 50% of your grade. My main issue here is that the exams have little correlation with what you’re doing in the projects. Despite the availability of sample exams and practice problems, they don’t prepare you well for what you’ll encounter. That said, the exams are open-note, so if you take extremely detailed notes on every lecture, you’ll be in a better position. Even with thorough notes, I found some questions unnecessarily challenging and they are graded pretty harshly.

Overall (1.5/5) While this course has potential, the material, lack of transparency, and disjointed structure severely detract from the experience. Unless significant changes are made, I wouldn’t recommend this course to others. There are plenty of other amazing courses offered in OMSCS that would be more worthy of your time.

I have mixed opinions about this course.

I come from a cloud/software background so I'm not used to dealing with hardware concepts, low level, bits/etc so it was really useful to learn about this stuff so I can better understand how computers actually work. I also do think it can be helpful supplementary knowledge for most tech jobs.

However, most of the time you're not going to directly apply any knowledge you learn here. If you're really interested in computer architecture, I would highly recommend this course. Otherwise, it's probably best to skip it - you can learn the high level concepts on your own and at your own pace. Unless you're working in CPU/GPU design or something like that, you don't need all the details that you're forced to learn here.

The assignments themselves aren't difficult from a conceptual standpoint, but actually making the correct code modifications to get the expected results in the reports is somewhat tedious and requires a lot of guess-and-check. Where exactly you put one or two lines (though the change would make no difference from a logical standpoint) can drastically impact the results. This was mainly a problem for the last 2 assignments. Having a background in C is helpful, but not required, as I didn't think the code adjustments required having specialized knowledge in C.

Make sure to try to do well on the assignments as possible, because the tests are difficult, and they are 50% of the total grade. Grading on the free response questions for the assignments is pretty strict, so make sure to provide detailed answers.

There is a LOT of material to cover in this course, and a LOT of detail. The lectures are well-organized, and informative, but pretty dry and it's frankly hard to pay attention. I also found the sample problem walkthroughs and quizzes in the lessons hard to learn from, as the professor will pull out random numbers from nowhere and make up assumptions about the system to solve the problem.

I found the midterm to be pretty hard, and the final is comprehensive, but felt easier, mainly due to having an extra hour to answer the same number of questions.

Make sure to take good and detailed notes, as the exams are open book and open notes but you can't use the internet.

Overall it's a fairly difficult course but it does provide good knowledge on architecture concepts. But I think for most people it's probably a better idea to learn the high level concepts covered here on your own and at your own pace, and opt to take another course that's easier or more directly applicable to your day job.

tl;dr: This course is excellent. The lectures are actually interesting and easy to get through (I hate lectures normally). The content is complex, but the project workload is pretty light.

First of all, this is an excellent course. Normally I hate going through lectures, but these lectures are interesting and pretty easy to get through. Many other courses have quizzes that are total wastes of time (either irrelevant or obvious), but the quizzes that are sprinkled throughout the modules in this class actually add to the learning experience.

The content spans a pretty wide range of topics that all center around the topic of how a modern computer processor works. Some of it will be review if you've done an undergrad computer architecture course or an OS course (like pipelining and caching), but the content in this course goes a bit deeper and covers optimizations and strategies that real processors use rather than the very basic toy processors taught in more basic courses. Compared to AOS, which contained a lot of history lessons and theoretical research concepts, all of the concepts taught in HPCA are actually used in practice.

In my opinion this is not really a hard course IF you have some background in computer architecture. In terms of how advanced/complex the concepts being taught are, this course might land at a 4/5 in difficulty, but the main mitigating factor is that the workload for this course is very light. There are only 4 assignments and 2 of them can be done with a partner. The assignments involve making some light code changes (not even close to the level of GIOS, for example) to a low-level simulator and then gathering stats and filling in tables, and writing some brief justifications for why some behavior happens. Basically every 3-4 weeks you'll have 1 assignment which may take ~8-12 hours of work.

Decent class where you do learn some concepts well, but I regret taking it and this is my first time compelled to write a review.

As someone who prefers "hands on" learning, this is course is extremely difficult to focus and learn. It predominately consists of watching dozens of several hour length lectures at a snail pace and doing little practice problems. The problems are like on paper theoretical representations of caches, etc. Some may enjoy this, but I dreaded having to sit and watch them and found it very difficult to pay attention (maybe that's just me). I'd recommend watching the coursera videos/videos on youtube and deciding whether that's your type of thing.

The projects aren't enjoyable, hours and hours of just trying to tweak some code. And the final is so heavily weighted and unlike the practice exams that going from an A to C from the final is not unlikely. The TA is very helpful throughout the course, but don't expect any help on regrades.

If you are someone who has a full time job, and are taking these courses to casually learn on the side--I would stay away. If you do take it...well, take good notes on paper since you can use those on exams.

Exams are challenging with a ton of information. Did alright on the midterm but got destroyed on final (much different than the practice finals). Assignments were also time consuming and did not contribute much to my learning. Left me frustrated and confused more than anything. Lectures are also long and heavy. Ed discussion board and head TA was active so I'll give this course props for that. Overall, I would not willingly take this course. I only took it for my core course requirement.

Video version: https://m.youtube.com/watch?v=ZYL1fKduJJU

This is a fantastic course, one of my favorites in the program. The lectures are extremely comprehensive, definitely the best set of lectures of any course I took in OMSCS. They cover a wide variety of techniques used in modern processors for executing tasks and optimizing performance. Each lecture goes very in depth, and overall they really feel like they come from a graduate-level computer architecture class.

The midterm and final emphasize problem solving, and while they are difficult because of the sheer quantity of material, the lectures provide all the material you need in order to do well.

The projects utilize the open source SESC simulator, written in C++. They are a combination of calculation, changing configuration variables, free response questions and modifying functions in the simulator code. They tie in closely to the lecture material. Because you work within an existing simulator, it's important that you feel comfortable working within a large codebase. You don't actually write much C++, but understanding the architecture of the simulator and what functions call other functions is very useful. The only downside of these projects is that they must be submitted by filling out a template Word document, which had the occasional formatting issue and obviously didn't have any auto-grading capabilities.

Nolan, the head TA, is extremely active in the forums and is one of the best TAs I've had in OMSCS. The professor also holds weekly office hours.

This course is great, and in my opinion is a fantastic course to prepare to GIOS or other systems courses that work at higher levels of abstraction.

I loved this course. Milos holds office hours every week, and is very enthusiastic about the subject. The lectures are some of the best in the entire program. I wish the quizzes were a bit better, but I imagine it's hard for them to do incremental updates.

• Exams They are somewhat difficult, but overall fair. The provided sample exams could be better. They were copied over from in-person version of the course. Some of the things didn't apply at all to the online version, or were unnecessarily tedious. This added to the overall stress I had before the exams.

• Projects A lot has been said about this previously. If you follow Nolan's instructions carefully and ask questions, you'll be fine.

For me personally, it's a 5-rated course. I wanted to learn about some low level things such as pipelining, reservation stations, etc. and I got to learn about them. But I deduct a point solely because of the projects. Even if you set aside the idiosyncrasies of the simulator, the actual tasks could be improved.

The assignments can be completed without watching the videos but Mid and final need to watech all the videos and undertand them thoroughly. Mid foucus on some calculations and final focus on theory problems.

Advice, understand C++ has a huge advance, otherwise, you will struggle with all the assignments. The idea and coding for the assignments are simple, but need to write codes on notepad without IDE help and without debugger and it needs to amend function blocks in a whole C++ system project.

C++ is a must basis for this course. lecture video are easy to understand and learn. Mid and final are not so hard after watching all the videos(80% guarnatee). with all 100% assignments, A is not hard to get.

Overall a great class. Some of the best lectures I’ve seen so far in the program. You will get a solid understanding of how processors work, instruction scheduling, memory, and caches from a functional and a performance lens.

Exams were fair and actually tested application of class concepts as opposed to memorization (thought some of that was still present)

Assignments were interesting but different from most I’ve taken in the program so far. You run certain programs on a simulated processor and gather statistics from them. Those are then used to fill a word document. The later assignments require you to change the processor code base to gather statistics needed to answer the questions. The code base is hard to understand and it is hard to get to the exact numbers that some of your peers might be getting.

Overall would recommend

I've have a lot of good things to say about this course. Apart from the fact that Nolan is the best TA, I also enjoyed the lectures and content. This was my first course where i got to understand how instructions are scheduled and executed at the processor level. It was both new and enriching for me. The professor is punctual with grading exams, and if you attend the office hours he is very eager to explain the concepts to you, you can even ask beyond what's covered in lectures.

Pros:

• Nolan
• Assignments are pretty interesting and supplements the material
• Lectures are very clear
• Grading is fair

Cons:

• Too much content. You may find yourself short on time to cover everything for the final exams.
• You need to score 90+ to get an A. This leaves a thin margin of error for exams and projects.

There are no books or research papers required for this course. Lectures suffice. For projects, make sure to follow the instructions/FAQs given by Nolan. Most times you may feel that completing projects is almost like following the given instructions to the T, but given the time constraints i feel it is fine. Anything more, and you will be struggling to manage other things.

I'm not sure if I have too much to say about this course beyond the fact that Nolan is the best TA in the program, the professor is punctual with grading exams, and the lectures are pretty good.

Pros:

• Nolan
• I think the assignments -- while different than most classes -- were pretty interesting and supplemented the material
• The content that was taught was taught clearly
• The grading was fair

Cons:

• Mentioned before, but you don't know half your grade until the semester is done.
• The exams will bring your grades down. They account for 50% of your grade, and their heavy weighting is the reason for why I think the A/B ratio is relatively lower (around half -- sometimes less -- of those who don't drop get an A, compared to 60-70% found in GIOS or AOS).

Aside: On a personal note and the main reason why I thought this class was OK and not great was because I felt that the content was alright. Maybe it's unfair to rate a class based on how much I liked the content, but everything just felt... underwhelming? There are a couple of topics or concepts (VLIW, how storage works) that I found interesting, but overall the content is very much felt like a "solved" domain - as opposed to other classes, like advanced operating systems or compilers, this class helped me understand how computers work, but didn't get me excited to learn more - things were just taught with a notion of "this is how a computer works because this is what we've found works best," something akin to an introductory operating systems course with little mention to where this content can be (and has been) taken and with little talk on modern research and discussion that the name "high performance computer architecture" may indicate.

Projects: Thanks to TA Nolan the projects in this class were quite easy. If you start early and ask questions you should be able to get near perfect scores.

Lectures: Very dense, but engaging with ungraded quizzes that reinforce what you watched. Milos does a very good job explaining the content, the issue is that there is so much content!

Exams: This is what makes or breaks your A. I had 99,100,100, and 95 on the projects and still got a B because of the midterm and final. The midterm moves quick I ran out of time and scored a 66. Final is cumulative, but much easier than the midterm because you get 3 hours instead of 2.

Advise: Prior to starting this class learn how load and store instructions work. This will make the lectures click so much quicker (wish I did this). If you want an A put more effort into the exams than projects because their difficulty will define your grade.

This is my 6/7th class in OMSCS (AI4R, ML4T, GIOS, HPC, VGD, IIS) and is probably one of my favorite so far.

Things that are great:

• Video lectures are some of the highest quality in the program IMO
• A really nice syllabus covering a wide range of topics in sufficient depth. CPU pipelining, branch prediction, compiler ILP optimization, virtual memory, caches, memory, fault tolerance, coherence, synchronization hw support, multicore systems, etc.
• Legitimately made me interested in chip design. I now understand product announcements from AMD, Intel, Nvidia.
• Midterm was difficult but fair.
• Nolan the TA is amazing and shares a lot of good tips and insights for projects.
• The classmates I have are great, we share awesome editor, gdb config, tips on assignments. Feels like a real classroom.

Things that are okay

• The projects did not take as much time for me compared to GIOS or HPC. But as other reviews have stated, it is on a pretty old, somewhat messy codebase that PHD students clearly hacked on. Following ed discussions and tips from TA is KEY.
• The projects do an okay job at reenforcing some concepts learnt but they don't really make you reflect on the experiments in a meaningful way that expands your understanding. The assignments mostly require you to run some simulation, change and add a few lines of code, and run the simulation again and write down the numbers.
• With that said, I am not super sure what the alternative could be, it is really difficult to deterministically program optimizations for specific hardware in a remote learning environment without developing on a shared cluster, so the superscalar CPU simulator we hack on is kind of the best compromise.
• A lot of the topics are on innovations at least 2 decades ago. Would be cool to learn a bit more about some modern topics like chiplet design, stack cache, APUs, and System on chip designs, etc.

Things that kind of sucks

• Not getting back most of your grades until the end does feel bad
• The projects require you to write your answer in a pretty awkward word document with a ton of spacing issues. NGL it is pretty annoying.

I regret taking this class. I'm probably going to get a C at best, which means I'll need to take another class in the Core Courses for the Computing Systems Specialization. I have spent a considerable amount of money and time working on this, and I don't think the academic return is there. Besides this potential C, I have gotten straight As in this program (six classes so far), including some classes which are considered at least somewhat challenging. I have years of experience as a professional software developer.

Apparently, a full 65% of the final grade will not be revealed until the final week of class. This makes no sense. Learning is supposed to be an interactive, feedback driven process. If the feedback arrives too late, it is worthless. Another instructor in this program, in a different class, actually admitted that learning outcomes improve when grading feedback is released as soon as possible. That phenomenon is not present in HPCA.

I found the grading on the midterm to be capricious. I closely reviewed the lecture material leading up to the midterm and in my opinion the grading on the midterm was unusually harsh compared to the quality of the instruction that was given in the lectures.

 I have watched every lecture leading up to the final twice, taking copious notes on the second pass. I have taken every lecture quiz multiple times. I have asked questions on Ed. These are all actions taken at the advice of the TAs to score highly on the final and midterm. Yet, despite this, I'm still scoring low on the sample final.

I don't know how other students in the class are doing so well (the TAs publish class grade statistics). Perhaps the other students have more experience with hardware than me.

I thought the expectations on two of the four projects were unreasonable, as well. Based on the last project, a full ten percent of the final grade involved finding a workaround to some janky code in the hardware simulator. I thought the grading on one of the projects (the second one) was unreasonable.

Well, it will all be over soon. I'm never going to use this material in my life. So long and thanks for all the fish.

If you're coming from a non-CS background this class is a great one to take. It covers all the minutiae of how CPU's work, and you'll leave this class capable of understanding things like those CPU architecture diagrams you always see for new Intel chips.

The exams were reasonable, and actually quite a bit easier than the practice exams we were provided. Just do the practice exams, review all the lecture quizzes, and print out all your notes (tests are open book but paper only) and you'll be good on the tests.

The projects were actually very difficult for me as a C/C++ novice. They don't require you to write too many lines of code - they require you to figure out how a HUGE CPU simulation C++ codebase works and tweak small components of it or set it up to output performance metrics to describe what the CPU is doing. The documentation (as usual) is pretty terrible and scattered, but Nolan (the TA) was extremely helpful.

The class is well run, the lectures are very clear, the TA provides very helpful information

Personally I found the class kind of dry. The way they want assignments to be done is annoyingly specific (type X into the docx, it must be red underlined, give 4 points of decimal precision, copy and paste this directly from docx into shell). It feels at times like the assignments are just testing your ability to follow instructions to a T

The tests are open book but very stressful. Assignments are an easy A, but the tests are what distinguish who gets what grade

I definitely think I got a lot out of this class, but it was harder than what I was expecting. The final is cumulative, make sure to take plenty of notes for it

I learned a lot in this course. The lectures are high-quality, organized and have quizzes that test your knowledge and force you to understand the material.

Pros: Learned a lot about computer architecture, got experience thinking about how processors are designed and learned a ton about caching. Lectures are enjoyable, head TA is there to fill in the gaps with the lectures, projects and anything related to exams/quizzes. Professor offers weekly office hours for you to ask any questions.

Cons: Project descriptions questions can be vague or confusing. SESC simulator can be challenging to navigate or understand. Problem sets deviate from the style of questions asked by the exams. Practice exams contain typos or broken characters. Fortunately, the head TA mitigates these issues with the FAQs which are a must-read.

Tips: Get a partner so you can compare your answers for your projects. Make sure you read the FAQs thoroughly and answer the question that's being asked. Work through any sample exams and related quizzes. There is more of a time crunch for the midterm vs. the final.

Just note that coming into this class, you might experience some painpoints navigating some of the course materials. If you can get over the painpoints, the course has a lot to offer and the professor and head TA are available to assist you! Can't say that about every class.

I took an undergrad level computer architecture class in the past but it wasn't very good or comprehensive. I learned a lot from the lectures and overall I'm glad I took it even if by my best estimates I am looking at a B in the course (final grades are not out yet).

I said I learned a lot from the lectures and not that I learned a lot from the projects because the projects are not very useful. They feel trivial and can be completed in a single weekend or two. But the trivial-ness is also good because it is fairly easy to get 90+ on them to buffer your midterm grade (you'll need it).

The TAs really pull this course into being a decent class. They collect common questions and preemptively answer them in an FAQs for each projects. They're also fairly responsive if you need personalized help.

I took this class alongside IIS and found that the workload was pretty reasonable while paired. It's difficult to say how much time I actually spent on the course. The projects can be completed by taking a whole weekend or two and you have an excess of time to work on them but the midterm and final required a lot of review and studying. The midterm is known for being one of the hardest in the program even with notes and it's easy to accidentally lose a lot of points. Don't underestimate it and try to cram all your review in the week before the test.

Overall I would recommend this class to someone in the systems specialization who wants a decent core class, mostly because the TAs go out of their way to make this class as painless as possible.

I recently finished an undergraduate course in Computer Architecture, so many of the concepts are fresh in my mind, so I don't spend much time on the lecture. I take about 4-6 hours on weekend to finish each project. The course material presented are nice, what can be expected of Computer Architecture course. I'm not a big fan of the project, where you learn how to use and make modification to SESC simulator. I think it's not very useful as you learn more about SESC internal instead of actual Computer Architecture.

The lectures by Prof. Milos are outstanding and might be one of the best set of lectures I have ever attended. As other reviews mentioned, the course mostly focuses on hardware implementation details of computer architecture and parallel computing. I found it interesting and essential nonetheless. The topics covered are something I always would read about in informal way out of interest and I found that the formal and structured nature of the course helped me understand the basics.

The projects are fairly easy IMO and do not require much time to complete. I completed all of them within one weekend. They require some understanding of C++ but not in too much detail. Knowledge in C like language elements is sufficient. The subjective questions if the project docx are also interesting and greatly enhance understanding of the project topic. Also, Nolan posts a great FAQ page and basically gives away the directions to find the answers. Read them thoroughly and carefully.

However, I assigned a 15 hr/week workload to this course because of the exams. There are a ton of videos that you need to understand and follow for each exam, especially the final exam. I took a week off from work to prepare for each exam. There isn't enough practice material and few questions on the exam will be a surprise. In the final, there were some topics that I thought would never be asked because they are so obscure, but half of the exam was filled with those topics. Many questions have a "gotcha" format in them so read questions extra carefully. 

Lastly, there is an unsettling feeling in the end because 70% of the final grade is not known until the last week of the course and 45% of grade is still not known after the final exam deadline. The grading is generous and considerate, but something to be aware of.

In summary, I would highly recommend taking this course for someone in the Computing Systems specialization, even if it seems hardware related. If you can knock out the videos as the weeks go by and try to remember them by going over videos again and again, you might end up with shorter preparation time for the exam weeks than me. Just try to score full points in projects and A should be very easy to achieve

Some background: bachelor and master degree of math, learned several CS foundation courses online by myself like mit6s081,CSAPP. Working as a software engineer for 2 years. This is my first OMCSC course.

Workload: I only took one course this semester so overall it’s pretty chill. For weeks that no project ddl, I spent around 1~2 hours for watching the course video, for weeks has project ddl or before exams probably spent 6 hours. I believe if you have some CS background and learned some sort of OS before, it should be easy to follow this course.otherwise maybe need to spend more time on it.There is no curve for the grade but from the stats there are about 50% students get an A in the end.

Course material: it’s great! I learned a lot. It gives you view from a perspective of computer hardware that how programs runs and how it can be optimized. It includes lots of low level computer architecture knowledge and it’s really interesting. You will learn it from low to high, from processor pipline,branch prediction to some high level stuff like cache, memory management for multi cores. I would definitely recommend this course to everyone who is interested in computer architecture and want to deep dive to how programs runs in the low level.

Project: it’s not coding heavy. I would say only around 150 lines of code for all 4 projects. But you need to read a lot of c codes and truly understand the course material so that you can actually implement the solution. Generally it’s good, it helps you to review what you learned in the course and deepen the understanding of it. But for someone who wants to do a lot of coding on projects maybe be disappointed. Exam: it’s OK. Midterm and final are both open book, but still need to practice and memorize a lot of stuff. Exams is 50% of final grades so need to prepare it carefully. There are lots of true and false questions focus on some details which is not easy to prepare.

In the end, the head TA Nolan is awesome! Really responsive on the ED discussion and willing to help students for any questions.

Some background: coming from so-so non-US CS undergrad program; professionally, had been working as a software engineer for 3 years, previously working in a software product management role and various IT related roles.

Based on my initial research from OMS Central, I am prepared to spend around 15 hours per week for this course. At the end of the course, I logged 189 hours over 16 weeks, or around 12 hours per week. One of the week I spend up to 27 hours.

I am on my fourth semester, and so far the lecture and the quizzes are the best compared to other courses. It also connects well with the midterm and the final.

Cons:

• Some instruction in the project is unclear, and requires back and forth discussion with the TA on Ed.
• The projects is still distributed with MS Word with terrible formatting.
• The sample exam documents have an awful lot of formatting error.

Be sure to check the projects early and verify any doubt/inconsistencies on Ed ASAP.

This course is not essential, but it is fascinating!

Many topics are covered by other courses. Virtual Memory, Cache Coherence, Storage, Fault Tolerance, Multi-Processing, Memory Consistency, and Synchronization are things you learn in GIOS and AOS. But while you may get a working knowledge of these technologies elsewhere, you will not get the bit-by-bit depth you do in this one. And there are other technologies you may only learn about here: Branch Prediction, Predication (which is different), Pipelining, Instruction-Level Scheduling, Out-of-Order Execution, and VLIW.

I personally loved the way projects were run. Instead of letting students struggle with the same questions each semester, Nolan packages up all the FAQs into a single post. It's long, but everything is in there. The projects start early and run late, so there is always a project you can be working on. And there are often two projects running simultaneously. This means you can finish all your lectures and projects early, and still have a month before the final exam. Very helpful if you are juggling several courses.

A whopping 50% of your final grade comes from exams. I hate exam-heavy courses and, for that reason alone, I hesitated taking this course. But the professor puts a lot of care into exam preparation, and offers a thoughtful range of both fundamental and challenging questions. You can count on the exams being very fair.

This CS-6290 HPC-Architecture course is one of two High Performance Computing courses that can be paired together. The other is the CSE-6220 HPC-Algorithms course. If you are sure you want to do both, then do this course first as will give you a deeper background into the insides of a processor. This will help you excel in the Algorithms course. If you only want to do one of the courses, then take the Algorithms course instead of this one. The Algorithms course is more useful as you learn the programming you need for high-performance. But it's no big deal. I did both in reverse order and had no problem!

Fantastic and not too challenging course! A great course to pair with something more time-consuming. The instructor takes your hand and gradually walks you through how modern processors work. The lectures are extremely enjoyable with lots of drawings to help students build the right mental model. The course had 4 big multi-week projects that tested how I understood the material well, yet they were a breeze to go through as the professor and TAs did an outstanding job setting the expectations and answering FAQs beforehand. The exams are well-structured, and the grading is generous. Absolutely loved the course!

Lectures are great. Projects are OKAY. Exams are bad. The midterm and final both had curveball true and false questions that are meant to cover topics that aren't even mentioned in the lectures or anywhere in the material. It's almost as if they were pulled out of a magic hat because really, the things the true and false were asking about are NEVER mentioned in lectures or ANYWHERE in the course material despite me having 50+ pages of notes and review organized in a binder of mine. On the final these questions were worth THIRTY POINTS out of a hundred. I don't know whose idea it was to put in tricky true and false questions but it was a terrible idea. It's like they don't want you to do well. Missing some of these on the final led to me getting a B instead of a A in the course. Throughout the materials they give you there are several typos and mistakes that just add to the overall confusion, this can be seen in lectures, projects, and exams. Despite making these mistakes and throwing curveballs at you, there is NO CURVE. Some courses don't cut you any slack and this is one of those courses so you have to be on your A game. Overall, I did like the course but there are some major flaws that push me the wrong way. Nolan is amazing though. If you can skip this course, I would try to do so because there are areas that clearly need to be refined and polished. I think the lectures should be redone, pdfs need to be checked for errors that make them unreadable, exams have typos in them, and project instructions have errors in them. So literally every part of the course falls short because of minor flaws and errors that they don't correct despite the professor saying that he's been teaching for 10 years. Projects aren't bad just start as soon as possible and you will be fine.

Lecture: The quality is fantastic. It is very well-designed, and I was surprised several times by how good the lecture quiz is. Even though there are some interesting updates in this field after this course was recorded, it provides a good foundation to catch up on new things on your own

Projects: I hear negative feedback regarding the project design once a while. But surprisingly, I do love it. The project is not about heavy coding but testing your understanding of the course content. It helps me think through the concepts. For each project, I spent roughly 15 - 20 hours finishing it. Time varies mainly from debugging.

Exam: The exam preparation was stressful, especially the final covering all semester's contents. So plan well. The tests are fair and open-book.

Office Hour and TA: I didn't attend any office hours due to time conflict. Office hour is not recorded. So I don't know what they are talking about there. As for TA, Nolan is great and helps me with my questions.

Time and grade: I spent 252 hours with an above 90 score

The lectures are great - They are easy to follow and do generally explain the concepts very well.

The exams are OK. Expect to know some equations and algorithms as presented in lectures and practice quizzes. Details matter. But the exams are fair.

The projects were disappointing. They were not particularly hard, but they won't teach you anything useful about computer architecture. Basically you will modify the statistical collection code in a piece of software (written in C++) that simulates processors. Then you will run the modified code to collect some statistics about the processor as it executes some benchmarks. In nearly all cases, you will not actually change anything about how the processor is simulated, you will merely add code to collect data.

The material was interesting and I took this with HPC so there was a lot of overlap. I found the projects to be very boring and frustrating at times because it usually involved running simulations or modifying code rather than writing your own code.

Prereqs

• Have some knowledge of Assembly. Extensive experience isn't required, and you won't write Assembly by hand, but you'll encounter it frequently enough that being able to understand it will prove important throughout the course.
• For the projects, have working knowledge of a C-style language (C, C++, Java, etc.). At a minimum, you may be able to get by w/sufficient knowledge of OO and data structures. Just be prepared to read through a C++ code base and make necessary changes to satisfy project requirements.
• A prior OS course can slightly help or enrich your experience with this course, due to overlapping topics, but isn't required. E.g. GIOS covers threading, but from a software standpoint. This course also covers threading, but from a hardware standpoint. So while having studied threads prior in GIOS wasn't required, it helped me relate to them more deeply now that I've had courses that cover them from different points of view.

Pros

• Excellent choice of course material w/superb lectures. As a compliment to the instructional staff, I definitely found myself becoming more interested in the material as the course progressed. The course covers a lot of material, but the lectures (and time management!) really do set you up for success.
• Lectures and sample exams are excellent study aids for exams.
• Nolan is an exemplary TA. His replies were always timely, and his pointers will prove to be a big help, so stay on top of his replies to any questions asked.

Cons

• As many other reviews have stated, assignments are still filled with high amounts of errata and require a lot of corrective or supporting explanations. And, they've apparently been this way since around 2019 (based on other reviews on this site), so their state may not change anytime soon.
• The course projects could also be more interesting. They do relate to the material, but there's something about stressing through an obscure C++ codebase that feels more like a distraction than a learning aid.
• Grading was very slow.

Summary

Despite some glaring issues, this course proved challenging, but rewarding. To credit the instructional staff, course material and lectures start off excellent and keep you engaged throughout the semester.

But there's definitely room for improvement, primarily wrt the projects. Being filled with errata and requiring long corrective/supplementary posts reveals assignment quality just isn't a priority to the instructional staff. Hopefully they'll eventually find time to improve them, or come up with new ones all together.

My one bit of advice for this class that isn't (I don't think) repeated elsewhere in the other reviews here is this: Professor Prvulovic is unique (in my OMSCS experience thus far; this was class 7 for me) in this one particular way: Whereas all other Professors I've taken classes from will use the many little interstitial quizzes larded throughout the lectures to simply drill / reinforce what was just taught, Prof P will do this as well but also attempt, actually, to extend your knowledge of the subject matter.

This is pedagogically a very interesting approach and, in my experience anyway, quite effective! But, seeing as it's not exactly announced at the beginning of the semester, it can be a bit of a jarring experience to come to terms with it. I initially was plauged with my seeming inability to get the right answer on these little quizzes, whereas in all previous classes I can typically nail them with very high percentages on the first guess. It took me longer than I care to admit to realize that my brain was in fact working, and I probably was grokking the material, it's just that Prof P (apparently) almost never wants to just give us the answer without also leveraging the opportunity to demonstrate to us another facet of it. In addition to potentially puncturing the confidence of the unwary student, or further destabilizing those predisposed to self-doubt, the major drawbacks to this approach are that it makes concision in notetaking more difficult and leads one (well, me, anyway) to sometimes feel like I didn't just have the obvious right answer for a thing written down in one place -- it was instead a never-ending series of expansions / clarifications, but maybe that's apt for the subject matter. Anyway, perhaps this heads up will help someone who approaches these things similarly to me to be mentally prepared.

Regarding the notoriously lengthy Project FAQs that the famously saintly and helpful head TA Nolan maintains / reposts every semetser, I really went out of my way this semester to lobby Milos to please overhaul them asap for a number of good reasons, and he seemed on board, so fingers crossed / you're welcome! Now we just need to get the project docs out of Microsoft Word.. 😐

Oh! One last thing: the exams being worth 50% is no joke; it means you really have to know your stuff. I have an unorthodox (read: non-tech) background, but crushed the projects 100/100/96/100 and still only pulled a high B in the class overall because I just couldn't bring myself to care enough about the material at the level of detail needed to do well on the exams, and I really enjoyed this class content! It's a testament to how the amount of detail you need to have in your head for these tests is just wonderfully ridiculous.

Overall, this is a good one! just a bit rough around the edges still...

Pros

Interesting overview from processor pipeline basics to caching. Covers a lot of ground, and the lectures are reasonably fun and easy to follow. Exams were open notes and book (and the book came in handy for the exams), and while some questions felt just like trivia, most of the early material required problem solving and thinking, which was good.

Cons

The project errata is 2-3x the length of the actual project descriptions, and while a realistic depiction of lower level systems programming byzantine code, is an unpleasant introduction that could honestly be so much better with a rewrite of the project instructions and some small tweaks to the code base they use as their project kick off point.

General Note

The first half of the course is way way more intense pace wise than the second. Up until the project due right until the exam, I was working more like 15-18 hours/week, and then afterwards it was closer to 3-5 hours, chipping away at the last project.

HPCA is the class that every developer should take. Although much of the content of the course will not be applicable to your day to day job activities, it is my belief that the topics discussed are important nonetheless. If you haven't taken a computer architecture course before, don't let the prerequisite that you should have taken one in undergrad scare you away. As long as you satisfy the other requirements, you should be fine. The lecture material will go over the design of modern computer processors, as well as some of the tradeoffs of optimization techniques. This includes pipelining, branch prediction, caches, and coherence. There is some overlap with GIOS, so if you have taken that, you will be somewhat familiar with some of the topics.

The lectures in this course are among some of the best that I have seen in OMSCS. Some lectures are fairly lengthy, but Milos does a great job of explaining complex subjects and walks through examples in great detail. This helped make the exams more manageable because you were really familiar with how to work through problems. The problem sets that are included with the course are somewhat of a mixed bag. They were not written by the professor and are only somewhat helpful in preparing for the exams. I did the problem sets for all units before the midterm, but not after, and it did not impact my performance on the final. However, the in lecture quizzes were pretty helpful for what to expect on the exams. Since notes are allowed for the midterm and final, I recommend working out the lecture quizzes on pen and paper so that you can reference them. This helped me on the midterm for sure.

The projects are informative, but were probably some of my least favorite in terms of OMSCS. You will modify a processor simulator to count certain metrics related to branch prediction and cache eviction. Overall, they were not bad, but in relation to other projects in the program, they could be spruced up. Each one took me roughly 15-25 hours. Be sure to compare your results to other students with the other benchmark programs since that is the easiest way to verify that you have implemented the task successfully. Projects 2 and 3 allow you to work with a partner, which I recommend since you can freely discuss the project. At the very least, you can make sure your assumptions line up with your partner's. The only negative thing I can say about the class is related to the turnaround time for grades, which was pretty slow. It took on average a month to get a grade for an assignment. We did get grades for the first two projects and the midterm before the withdrawal deadline.

The exams are stressful, but the lectures do a good job of preparing you for them as long as you pay attention. You are allowed notes, but don't use that as an excuse to not know your stuff going into the exam. The midterm is limited to two hours, and requires a lot of thought. It is really easy to get something wrong if you are not paying attention to every detail. I think I had ten minutes to spare before I turned it in. The final is limited to three hours, and I finished with plenty of time left on the clock. The final was more conceptual than calculation heavy, so be sure you understand the various cache protocols and what states caches transition to after various accesses.

One other thing that bears mentioning is the pace of the class. It is possible to finish the first three projects before the midterm, which if you are pairing courses is kind of nice. This did make the class feel somewhat front loaded in terms of work, but a majority of your grade (65%) will not be known until after the midterm.

Finally, the interaction with the teaching staff was very good. Milos had a weekly office hour, but unfortunately it was not recorded and was in the middle of my work day, so I missed most all of them. The one I did attend showed me that Milos is enthusiastic about the subject that he teaches. The things you have heard about the head TA Nolan are all true.

I can't recommend this class enough, especially if you are on the Computing Systems track.

BG: Non-CS background and barely code with C++ before, but I've watched all videos of CS61C before taking this course.

PS: Suggest anyone who has no CS background to watch videos of CS61C which can prepare you well for this course.

Pros: Lecture videos are of great quality, and extremely helpful. Almost the best in the whole OMSCS program.

Cons:

1. So-called projects are more like assignments which barely require any kind of creativity. The course will be greatly improved if the projects can give more hands-on coding experience instead of filling blanks in a doc file.
2. Midterm and final exams focus too much on minor details which makes you exhausted when reviewing.

Time: Each project takes at most 20 hours and they are due every two to three weeks. Plus videos, I spend about 10-15 hours per week on this course.

2nd / 3rd class (taken with IIS)

I honestly feel that this is the worst class I've ever taken including my whole undergraduate classes. I mean it's not that bad but why would you bother if you have way better classes you can take than this mediocre class.

TLDR; If you think that the subject looks interesting, I would recommend you to just watch his lectures on Udacity and study by yourselves. It’s not worth wasting your time on the messy and unorganized class.

• Professor Milos doesn’t really care about how to improve the class or student learning. The class itself is what it is. It’s known for errors, outdated lectures and unproductive assignment formats, and so on.
• The projects are designed to make you annoyed rather than teaching you something. The practice problem sets poorly put together, most exam questions are unnecessarily elusive. Ambiguity in exam questions.
• I feel that there is a lack of communication between TA and Milos since most of the time I needed to ask back and forth to get simple answers.
• Nolan head TA is really slow. I guess he is responsive and helpful as other reviews say but that wasn’t the case for me.

Overall, it was the worst experience.

Overall I found this to be an enjoyable course with interesting material, marred slightly by disorganization.

Pros:

• Milos's lectures are succinct, clear, and to the point. In terms of content and his ability to explain the material, they're some of the best I've encountered in the program.
• I feel like I came away from this course with a solid understanding of how a CPU works, and what considerations affect its performance.

Cons:

• Some of the assignments seem poorly timed, resulting in peaks and valleys in terms of workload. It would be nice if the due dates could be tweaked to distribute the workload more evenly.
• My semester was the first after the transition from udacity to canvas, and the lecture quizzes were in bad shape. I gave up reporting errors after a while, as there were so many.
• The assignments all involve running and making changes to a cpu simulator. I ended up learning a lot about how the cpu simulator worked, but I'm not convinced this did much to further my understanding of how a cpu works.
• The assignment submission process needs work. Written portions require filling in text boxes in a word document file, and each assignment is accompanied by a big FAQ post on piazza explaining all the issues with said file. For example, sometimes formatting issues mean the text boxes disappear!
• TAs also took a long time to grade assignments. I suspect this is related to the awkward assignment format, which doesn't lend itself to automated evaluation.

This was a very good class! It was my first class in OMSCS.

I have an undergraduate degree in CS and a few years of experience out of school, so I did not have any trouble with the actual programming. The hardest part of the projects was working in a VERY research-oriented codebase that is very difficult to read due to very, very little documentation and a lot of dead code.

However, the lectures are fantastic and the professor (Milos) was entertaining and very good. The head TA (Nolan) also provides fantastic help.

This is an interesting subject and I learned a lot from it. That being said, there are a lot of "know errors" which could have been fixed but are not done. The projects are impossible to complete without the Piazza posts. The coursework leading up to the midterm is very hectic. If you do not have prior knowledge about the subject (like me), it will be a bumpy ride. The silver lining, if you want to see one, is that corporate life is like this in most places. The requirements are unclear and you have to run around people to understand what is it that you are supposed to do and often how to do it. The head instructor Nolan was active and responsive on Piazza and made it survivable. If you have taken the course and struggling, read my detailed experience and tips to survive. OMSCS Journey - HPCA

[PS: I got a poor score in the final, but with the good project and midterm grades, I pulled off an A]

If you need to consult the TA for every little thing to get through the projects, there is something wrong with that course. Grading is very very slow.

Coming from an HPC background, I really wanted to take this course.

This was my 2nd course in the programme, having just come off a very tight A (by 0.23%) in CS6200.

I was very bad with the C++ coding (hadn't done C++ in 20 years) but the team assignments helped me survive (I needed the help for sure).

The lecture content was incredibly interesting for me especially being an HPC Technologist, however, I would recommend anyone serious about understanding code or how CPU/cache/compilers interact should take this course.

I became aware of this course because of its overlap on some subjects with CS6200 - so when I was preparing for exams in CS6200 I used some of CS6290 to complement my studying then decided that I wanted to take this course!

The exams in CS6290 are very challenging, but they're made potentially easier by being open-book. I say "potentially" because they're still very challenging and you need to be very well prepared beforehand.

Where I fell down on the assignments, I made up for in the exams - where I averaged over 90% on both. One piece of advice that I can give is USE GRAPH PAPER AND A PENCIL - going through every CPU cycle with was incredibly interesting, but also incredibly tricky.

There are some really long lecture chapters in this course but fortunately the lecturer's style of talking makes it possible to play the videos back at 1.5x or faster.

I had a really tricky time of the course, having to write assignments in hotel rooms, or studying on long trans-continental flights (and writing my final exam in Chicago, 8513 miles / 13700 kilometers away from my home). Nonetheless, I again sneaked out an A by 0.39% and I felt it was a justified reward for my efforts.

SUMMARY: +-10 hours a week on lectures +-6 hours a week on assignments +-20 to 30 hours of prep per exam Tons of things learned.

My study-buddy / team-mate also became a really good friend, albeit 8000+ miles away. If you are lucky enough to find a good team mate, that will just take this course to a new level of rewarding.

Highly recommend this course, especially for anyone involved in HPC technologies.

Positives:

• Nolan head TA was amazing

Negatives:

• Known errors in assignments and problem sets (test study material) but do nothing to fix them. Instead of fixing the problems in the assignments they are listed in a FAQ post for the assignment...
• Lectures out dated
• Quizzes if taken through canvas often grade your answer incorrectly
• Projects require a lot of manual entry of data which is present in generated files which we submit. Not sure why this is necessary. I get they want us to see trends with the numbers but often those trends are asked about in a written response question. So what is the point of even asking us to input data from a file we submit and trends are asked about?
• They say the book in unnecessary but Midterm/Final are open book so makes you feel like you are at a disadvantage if you don't have it
• Midterm/Final are supposed to be graded with the idea that you get points back if you made a mistake which lead to more mistakes in a question but I wouldn't bank on that
• slow turn around on answering piazza posts sometimes
• grading is super slow
• Final is cumulative which is a first for me out of 5 classes.

Pros:

• Projects are quite easy, just horribly explained
• Head TA (Nolan) is very helpful (without him, I doubt more than 10% of students would have a hope of passing)

Cons:

• Project instructions are full of errors. The Errata Piazza page is longer and more detailed than the actual project instructions. Why do they not just fix the project instructions!?
• The projects themselves either consist of rigidly following a sequence of instructions or making some changes (<100 LoC) to a very large and messy program. The Project FAQs on Piazza are absolutely required to have any chance of making the right code changes, as the FAQs list all of the misleading / incorrect parts of the code that you need to watch out for.
• Problem sets (post-lecture questions) and lecture quizzes are also full of errors. There is about a 50% chance that the given solution for a problem has a typo or just a plain incorrect answer, making it very hard to prepare for the exams.
• Exams are 50% of the course grade, and are quite difficult to prepare for (particularly the final exam) given the previous point.

I strongly recommend to only take this subject if you have a lot of pre-existing knowledge of computer architecture (specifically caches), or if you are willing to pore through other text books and material to understand the content, as the lecture do a very poor job in providing practical examples.

Final note: I really cannot comprehend how the course material remains in the state it is in, there is just an unbelievable amount of errata (both acknowledged and ignored by the TAs). The course content is quite interesting, if the professor and/or the TAs spent a couple of weeks updating the content to fix some of the errors and misleading information, this would be a great course that I could recommend.

The course was extremely detail oriented. Will need to do computations which pretty much the processor does for various functionalities it provides( for example, finding the # of cache misses and cache hits for a given cache design and pattern of memory accesses ) . So it requires a lot of attention, being able to keep some of the design aspects in mind ( the exams are offline open book but they are so demanding in terms of time, its not easy to refer the book and answer the questions ) and diligence to do step-wise calculations leading to a final answer. One mistake in one of the steps very easily leads to wrong answer to all following steps. The professor tries to provide partial points in those cases but still very easy to lose points in the exams due to oversight.

Knowing C/C++ and a basic understanding how processor works will be very helpful. The assignments involve reading through several thousand lines of code and making minor modifications to get the required results. So easy to get daunted to begin with but the head TA does a good job of helping out the students.

Pros :

• The course syllabus covers a wide range of topics that are applicable to processor design. So it gives a fundamental understanding which can be used for further work on a related topic.

• The quizzes in the course videos are not superficial and tests out if the topic is thoroughly understood. So going through all the quizzes will help to gauge one's understanding of the topic.

• Head TA ( Nolan ) is very helpful. I pretty much got answers for every single question with detailed explanations.

Cons:

• Requires a lot of time and effort. The course content is dense. There is a lot of technical points that need to be understood in a thorough manner which is quite time consuming. If the lecture video running time is X, it is likely one has to spend 2X to 3X time to get a complete understanding. It is hard more due to the time demand than complexity of the subject.

• Insufficient data / ambiguity in exam questions : This is quite a heart-burn when a detailed question lacks required info and one has to guess what the person who set the question had in his mind. In the summer 2020 mid-term there were a couple of such questions and students had to keep pushing to get those questions re-graded ( which eventually happened ). Some of the questions in the exams tend to be like a trivia than actually testing the knowledge. One has to literally 'read' through each of the words in the question. Very easy to rush through the question ( by auto-completing in the mind ) and end up losing points.

• Office hours/Professor presence : Office hours are not recorded and students who can't make it due to the time zone are at disadvantage.. Professor's presence is rarely felt in Piazza and other forums.

Summary:

If understanding of low level processor internals interests you, its a good one to take regardless of the cons. You would walk away knowing a lot. If such low level topics aren't of interest, it may not be pleasant experience.

The class is very poorly designed in my opinion.

To name a few things I don't like, a good amount of detail is skipped in the lecture. The project is very loosely, if any, connected to the content of the class. All of them are more like a C++ practice that happens to be working the section that this class touches, but not using anything you learned here to solve the problem. The essay question in the project sometime asks for answer which is not mentioned in the class at all.

The fact that TA is very responsive and helpful doesn't change the fact how bad the class is put together. It only proves the class is worse without the TA.

The class is more tricky than difficult. Average score of the class is ~87% in my term.

With all the mentioned above, I basically have to go through the same class from other university before the final to fully understand the content, which makes a good amount of the time that I had spent on this class totally meaningless.If you really want to take this, just be prepared that this may not be hard, but could be an very unpleasant experience.

This was my first course! Really enjoyed it and learned a lot

PROS:

The course videos are well made. Each concept is clearly explained and often accompanied by a concrete example.

The stuff are fun. Learning how things work is always satisfying.

There are lots of things to learn. So if you were like me, who do not have a CS undergraduate education, then I would suggest to take detailed notes and come back to put the materials that you have learned together every now and then.

The projects are not so bad if you are good at C/C++ AND you understand the concepts in the videos.

The exams are hard but fair. Paper notes are allowed, but you may not have time to use them, especially during the midterm.

The head-TA Nolan is of great help!

CONS:

I found some of the questions in the projects are unnecessarily elusive and do not really help us learn the concepts.

Some questions (although the potion is just 10-15%) in the exams are either too tricky or too irrelevant.

The grading for the projects 2 and 3 were slow.

Overall:

With no background in neither C/C++ nor computer architecture, IMO this is a pretty difficult yet rewarding course. I managed to get an A and would recommend anyone who were interested in computer architecture to take the class.

This class is interesting, and the workload is reasonable for a summer class. Just hope that Nolan, the head TA, is still around when you take the class.

Pros:

• The lectures were very good.
• The head TA (Nolan) was very polite and helpful. He resolved most of our queries at an impressive turnaround time.
• Quizzes tested our understanding of the material - They are essential to get a gist of what to expect in the finals/midterms.
• Projects weren't hard.

Cons:

• The projects require us to introduce a snippet in a very large and a messy code - As other reviews suggest, they consumed time and did not facilitate learning.
• It was quite easy to lose points in the exams. There were a lot of questions that would depend on the previous answers. Although the instructor made sure that we do not lose a lot of points because of the domino effect and offered partial credit, It is quite easy to make a silly mistake and lose 3-5 points.
• Project evaluations were strict - you either get the full credit or 0. Make sure you dump in all your analysis while also making it concise.

The exams were proctored and open book. You are not allowed to make use of online resources for the tests. Please make sure you have handwritten notes, with quizzes documented so that you can readily refer to them when needed.

The content of this class is really really interesting, and teaches about the inner workings of computers.

It was incredibly hard for me because I never coded in CPP before (and never knew what a pointer was before...). Definitely do not take this as a first course with CPP, take something with less CPP in it (I just took Software testing and it has a great primer for cpp that I wish I had taken before this class).

**Should you take this course?: **

This course is all about processor design, and optimization. None of the content is very applicable unless you work directly with the processor. However, I found the course to be rather enjoyable, because it really challenged my soft skills (problem solving, attention to detail, etc.)

The lectures are great. The lecturer has an accent, but I never found it to be a problem (annotations are also helpful). The content is well organized, and there are even class notes provided.

**What makes up the course?: **

There are four projects that add up to 50%, and the midterm and final which add up to the other 50%. The projects are built on top of each other. So it'd be stupid to miss a project, as you'd be implementing what you didn't on the next.

The projects require knowledge of c++, makefiles, and bash. I knew these already, but I'd say the level of skill needed is between basic to intermediate, so you can definitely learn as you go.

The course also has other prerequisites like MIPS assembly and knowledge in binary. The course has a good prerequisites section to refresh on these topics.

**Information/Tips on the projects: **

For the projects, the short answers are strict; be prepare to fully support your answer. However, some of the data entry (prj2 & prj3 in particular) are more lenient. For example, due to incorrect implementation in prj2, I was getting incorrect numbers. Expecting 50%, I got 85% because of partial credit (the numbers were off but were within the ballpark).

Of course, I knew my numbers were off because we were allowed to validated our data against other students' using common benchmarks, which was extremely helpful.

The projects weren't trivial because it was a large, messy codebase. It was less about writing code, than it was knowing where to write code, and how to write it. Some key insights were required for this. Nolan (our TA) was really helpful in clearing up any questions people had. Without his help, I wouldn't have came to a few key insights for prj3.

GDB is very helpful for tracing. As well as reading all the FAQs for the projects, and student/TA questions, helps paint a fuller picture as to how to approach the projects.

**Information/Tips on the exams: **

The exams are open book. I hardly used my notes for the midterm (but I did for the final). The most important thing would be to do the lecture quizzes, and sample exams. There's also a lot of problem sets, which are optional, that would refine your understanding of the material. I'd focus on these after the sample tests and lecture quizzes.

The final is cumulative. As a result, expect at least one question on the final, that's from the midterm material.

**General Information/Tips: **

The pace was very streaky. There seemed to be a lot of content coming into prj2, then there was a brief period of relaxation, before the final and prj3. Because I procrastinated (and didn't pace myself correctly), during a week or two before a project/exam, the workload would become almost unmanageable (catching up on lectures and working on the project). Had I had a second class, or were work more demanding, then it might've been tough for me to pass this course.

I was running an below 80 average (80 on the first two projects which is not good because the mean was 90+, and a 79 midterm score). I was expecting a 50 prj2 (I had implemented a solution but it wasn't the right one). But there was hope. Prj3 was actually a bit easier than prj2 (even though it did require some insights from prj2), so I was able to do well on that one. The final wasn't easy, but it was fair. Prj2 came back an 85 so I'm expecting a B for this course (A if I'm lucky).

As the professor states in one of his introductory lectures, this is a course that teaches how modern processors work. If this topic does not sound interesting, then this class might not be for you. The lectures are dense but highly informative. If you put in the effort, you will learn a ton. This was my 8th course in the program and quite possibly my favorite.

Workload: As others have stated, there are 4 projects, a midterm and a final. Each project is progressively more difficult than the previous. They try to scare you by saying that the final project takes 80 hours, but practically everyone I knew finished in under 30. They also allow you to work with a partner on the final 2 projects.

Tips: The projects require you to write C++ code but I would not say that you need to know C++ to get a good grade. A working knowledge of C and how iterators, hash maps, and classes work in C++ will be adequate.

Conclusion: While a B is readily attainable, an A is difficult to achieve. A great course and I highly recommend it!

All of the criticisms of this class is fair. This projects are more annoying than educational, the tests are stressful, the pacing in the class is poor, the practice problem sets from the course developer are poorly put together, and the amount of errata is unnecessary and annoying. If it were not for the TA staff, the class would be awful.

That being said, thankfully the TAs make suffering the organizational aspects of the class bearable, and the lecture material is great. I disagree with the prerequisites for the course - I think it's perfect (even a must-take) for anyone who has not taken a computer organization class before. You will learn a lot and really walk away understanding computer architecture. Frankly, the class is tough but fair. All of the extremely negative reviews are an unfair skew by students who were disappointed by their grades.

Knowing the organizational gotchas of the class will go a long way to alleviate you from what otherwise can quickly turn into an exceptionally frustrating semester, so I've written some practical tips here

This is one of my second-half OMSCS courses. To be direct, if it were not for the head TA this course probably would not function well. He answered many if not all of the piazza questions, and without his FAQ and feedback for the projects I think I would have been toast. I learned a lot, but I can't say that I enjoyed the process, it is in fact a "slog" over the summer.

This is the best course I've taken in OMSCS, and at the time of writing this review I've completed 9 courses - pretty much seen most of the courses. I took this course as a refresher (my undergrad covered Computer Organization and Architecture - but was years ago). I definitely recommend this course; it should probably be made a course that cannot be avoided like GA for most specializations as the concepts learnt from this course are so essential for any CS program - without which the CS education would remain incomplete.

The course is very well organized in terms of the lectures. This course is definitely one of those courses which showcase the teaching standards of a GT level professor - Prof. Prvulovic enjoys teaching - his sense of humor pops up in between the lessons :), knows the subject very well and also knows to explain the concepts in a very succinct and clear manner. The reason I specifically want to mention that is because - in the current term (summer term, while I am writing this review) I am in fact, enrolled in a course which is taught by a non GT professor (an adjunct), where the core concepts of the lessons get hand-waved and get presented as "mathemagic" - which is a stark contrast in the approach vs Prof. Prvulovic's teachings - which speaks a lot. HPCA is yet another core system course, where the professor regularly holds Office Hours. I've seen that happen only in very few courses.

Here's the pre-requisite course prescribed HPCA0: https://classroom.udacity.com/courses/ud219. If someone doesn't have a CS/CE background, it might be good to go through it.

HPCA covers the following topics: The first part:

• Branches
• Pipelining
• Predication, Instruction Scheduling, ReOrder Buffer, Memory Reordering
• Instruction Level Parallelism & a bit on VLIW compilers

The second part mainly focuses on Caches & Cache Coherence. The other topics that come up in this part are:

• Memory, Storage, Fault Tolerance
• Multi-Processing, Synchronization, Memory Consistency & Many Cores. The Synchronization part gets covered better in the AOS/GIOS lectures (which is as expected, as this course is mainly to focus on the hardware aspect of it).

The Exams are 50% of the grades with midterm: 20% and a cumulative final: 30% worth of the grades. From the point of view of the exams, it is especially important to understand all the quizzes from the lessons very well. The problem sets, do help, but I found that - understanding and working out the lesson quizzes and also working out all the questions from the sample exams very helpful to prepare for the exams. On the mid-term (2-hr exam), I felt a time crunch. I scored a 96 on it. On the cumulative final (3-hr exam), I scored a 92. Both exams were fair and were open book ( printed notes or hand-written notes were allowed).

During my term, I remember most people did not do well on the midterm, but they upped their game - and were able to score a 90+ overall or a very high B grade, by performing very well on the final (things like working out the sample exams, lesson quizzes, problem sets helped). Midterm required middle school math reasoning & a thorough understanding of the lessons. I was a bit surprised by the difference in the type of questions between the mid-term vs the final.

There are four projects (50% of the grades overall - the last two projects can be done in a group of 2 or individually). The projects were based on SESC simulator, used C++, where some specific features - were explored in each project. If someone is not very familiar in C++ too, they can work on the projects without too much of a problem. My C++ was quite rusty when I started this class. The focus of the projects, was more to understand the features/concepts (and were in line with the lessons), rather than to design these features – most projects just needed around 30 LOC modifications. The essay questions in these projects needed a lot of thinking and exploring, and this is where the superstar TA Nolan comes into picture - his guidance and pointers are very much appreciated. These questions helped me in understanding the concepts of the lessons better (the extra googling & reading of some relevant papers, though not really necessary as part of the curriculum, to understand and analyze the observations of the projects, really helped in drilling down the concepts - I am very happy that I worked that extra mile as I benefited a lot from it). Nolan used to create a FAQs post per project, I used to wait for his posts to start working on the project ;)

• Project 0: 5% - This was a kind of get your feet wet kind of prelim project, which just verifies that the VM is setup correctly and the intention is also to make us look at & analyze some assembly code.
• Project 1: 10% - This project was on Branch Prediction
• Project 2: 15% - This project was on Cache Replacement Policies and the type of Cache Misses
• Project 3: 20% - This project was on Cache Coherence

It's difficult to always score 100 on the projects ( easy to get a 90+), due to the essay questions, but in terms of learning and take-away they do help a lot. The grades were returned fairly quickly too ( considering there were essay questions).

The recommended textbook is not essential, but it is good to glance through the topics corresponding to the lectures.

My term had a very active, helpful slack too in addition to the very responsive piazza - which helped during the exam preparations. I enjoyed the course very much and the term too :). A course that is very well run!!

Do not take this course unless you love computer architecture. If you interested in software development or anything analytical avoid this course. I will probably finish this course with a B, so its not like I am failing. I dread signing into this course,. The lectures have a lot of magic numbers that do not add up with no real explanations about where they come from or why the are split the way they are. The projects have to a FAQ that point out whats wrong with the instructions you are given in the assignment. The entire time you making modifications to source code that has misnamed, poorly named, or not even spelled right variables and methods which makes the code hard to understand. I will not in recommend this course to anyone. OMSCentral has lied with how great this course is. Overall opinion is to avoid this course.

I just withdrew from this course. It is my 5th OMSCS course. I've never seen a course grading so strict on short answer questions. I mean I answered with on my best understanding of the questions. Me and some members in the discussion group all had complained about getting 0 point / extremely low score on this kind of questions. The video doesn't help answering these questions, and there is no example teaching you how to answer "exactly" as the TA wants. Seriously, here "exactly" means a must hit on the correct answers, which is extremely difficult for short answer kind questions. Let me give a similar example: You are asked to read Shakespeare's essay, and you were asked what the feeling he is trying to express? Well, you may guess somewhat, but how do you know the exact "correct" answer? However, there is no flexibility at all. I don't know what exactly they are expecting. BTW, in one question I was taken all the points off just because I didn't keep two decimals, I thought #of cycle should be rounded up to an integer. There is no argue to keep at least half of the points. Finally, the TA did send an email to remind students the withdraw deadline. This course is a big blow on your confidence to complete the degree.

Not sure why this course got such high rating. The lectures are very detail-oriented, but a lot of assumptions are not made clearly in the quiz and problem set, which is really a pain because you need more to figure out how to get the answer displayed in solution. Course is very tight, especially in summer, midterm and project 1 are due in the same week. Grading on the homework is very STRICT! Overall, if other choice available, I highly discourage taking this course unless really interested in how computer architecture works behind the code.

OMSCentral you have led me astray. At the time of writing, this course is rated as high as some excellent OMSCS courses. This course has tons of errata that seemingly carries over from the semester to semester. A FAQ for each assignment because the assignments themselves are unclear.

The content of this course is interesting but this course needs some love from its instructor. Not enough workable practice problems. The course is halfway migrated from Udacity to Canvas, but there's content missing in Canvas. Multiple incorrect quizzes in Canvas. All of the above contribute to making difficult subject matter that much more difficult to learn. Could be a great course but is not.

Nolan is great at reacting to situations but I don't think he has enough time to really fix things. Or maybe he's not able to fix things, I don't know. If you see him missing from the TA list you'll be in for a rough ride.

The midterm will try to catch you out, be careful.

The head TA Nolan is super strict on grading and so on. Midterm counts 20%, Average score of the class is 79. No curve. Final is cumulative and counts 30%, takes 3 hrs to finish a bunch of calculations (These questions are connected to each other - If you made mistake on one, you will get 0 points on all related questions there after.) There are 4 projects. The means are mostly <90, e.g. project 1 mean=84. Withdraw rate of this course is 33-40.2% in the past 5 years. Don't be cheated by the high rating here. If you made any mistake or haven't got any background knowledge before, YES, you will get a D, for sure. The TA tried to show you there are students who can get A in projects and exams and their percentages, but look at the withdraw rate first, no wonder the remaining students are those on the very top, and they gave misleadingly high rating here. Yes, smaller denominator gives higher A percentage. Make sure you read my comments before you take this class, if you still care about your tuition fee.

I really enjoyed taking a computer architecture class in undergrad, but it has been a number of years. Having a good baseline familiarity with a lot of the topics and even MIPs probably reduced the learning curve significant. It was pleasant to refresh up on this topic and learn some new things that I didn't see in my undergrad course. The projects are of decent quality, the TAs ran the course very well, and the slack channel was super helpful to bounce ideas off of others.

I choose this course because of its past high rating, but I don't feel the same way when I take it myself. The recorded video is made by a professor with strong accent. I can't understand in many places - Even the subtitle can't translate it correctly due to his accent, which adds a lot more difficulties to its already hard content. I couldn't download a correct pdf version of the video, unlike other courses. Proj 0 was graded on submission deadline of Proj 1, which is not so quick. The grading is extremely strict - for reasoning questions, if you didn't answer the correct point, you will get 0 point for that question even if you tried hard to answer. I haven't taken the midterm yet, but I bet it is hard. According to students taken this course in the past, there was no curving. So be CAUTION if you choose this course - If you don't have any pre-required knowledge of HPCA, you might risk your self with a C or withdraw.

This is a rather broad course covering various topics, including performance evaluation and profiling, processing and execution, branch prediction, pipelining, out-of-order details, caches and coherency, memories and storage, fault tolerance, multiprocessing and memory consistency models. The lectures by Dr. Prvulovic are very well structured and clearly presented. Very useful course, even for someone with a background/experience in the field.

The office hours with the professor are held on a weekly basis, but unfortunately not officially recorded.

There are four projects (I would call them homeworks) - mostly around dealing with C++ code of a processor simulator (the SESC simulator - not the exemplary quality of code, but all right). That involves profiling, answering questions related to the course material and related common sense, as well as modifying the simulator code and evaluating the results. Overall, those were not too difficult and didn't taking as much time as some substantial projects would, but they do require thinking and experimenting. The big help was the ability for students to share and compare the changed simulator results on some benchmark (other than the one required for submission profiling). There was a decent degree of occasional inaccuracies in the project instructions, so Nolan, the head TA (which has provided an amazing support during the semester - worth special mentioning) was posting a string of clarifications / FAQs on Piazza on the projects (both proactively and on an ongoing basis). Also, the Word format of the assignment, including occasional tendency of some answer placeholders to disappear (again, Nolan was proactive with warnings), is a great candidate for overhaul, thank you.

The midterm and final exam were not too easy, but overall very manageable and I found those mostly very fair. We were provided with a few examples of practice tests, which were very useful for preparation. There were also problem sets available, but some of those lacked in quality and had inaccuracies - the quality of the problem sets is begging to be improved, very poor quality.

The course had a rather high average, no curve was given as a result.

I'm leaning towards giving this course an "easy" mark as the material and the assignments are very, very manageable. I do have a background in computer architecture, so probably someone who is new to this field could find it more difficult - however, the material is presented in a very clear and straightforward way.

All in all, a great course, learned a great deal, excellent staff, well presented material. Loved it, recommend it.

Additional edit, following some of the following reviews mid-summer semester. Generally everyone is entitled to any opinion, but here I think some comments are in order. I do give those reviews the benefit of a doubt that those were genuine reviews from different people with similar opinions.

• On being interested in the topic: yes, surely, don't take a course if you are not interested or don't like the topic - this or any other course in this program

• "Strong" accent in the lectures by the professor: I believe it's a rather subjective view, as myself and many others didn't have any issue with it

• I don't remember any "magic numbers" in the lectures, the examples were well taken and described

• Unless the grading has changed dramatically for the summer term (which I don't believe was the case), I never experienced or heard about a situation where a full credit for a question was taken off with the answer being partially correct; those were not Shakespeare assays, but rather supposed to be concise answers, either quantitative or with design reasoning; I personally had points taken off several times on homework (projects), sometimes it could be argued as strict, but never unreasonable; yes, one would need to follow the instructions.

• The partial credit was given for midterm/exam questions, including taking into the account an incorrect previous answer that could affect the following ones; the final exam was not 3 hours of calculations, it covered the material.

• W rate and "getting D for sure" if no background: the withdrawal rate was less than in many courses. Several students who found it tough during the course and were worried, have either made it to A or were upset that they just didn't get to it after ending on high-B. The extra miles would be needed for someone who has no background in the basic architecture, programming, assembly, C, etc. It's all well documented. It's possible to make those miles during the course, though, depending on effort and time. However, the summer is tight in time, we all know it, need to make the judgement.

Good luck everyone!

TLDR; this class is awesome and you should take it! After you take it you'll actually know how computer hardware works, which is very cool.

My background: 10 years software engineering, zero prior hardware knowledge, zero experience with C or C++.

I took this class because nothing else was available at registration time. I'm so, so glad that happened because I ended up LOVING this class.

The biggest problem was I had none of the relevant prerequisite knowledge to take this course, which would be C++ programming experience and some understanding of computer architecture. Specifically I also didn't really know how to do binary <-> hex <-> decimal, which turned out to be important, so I had to cram a lot.

Right at the beginning of this course I crammed through NAND to Tetris Part 1 on Coursera. I had never touched assembly before and didn't know anything about computer internals, so that helped a LOT. However, it was also a lot of material to cram and it would have been easier if I'd taken that to prepare BEOFRE the class started. I also watched some YouTube videos to learn the basics of C++.

The class is composed of 4 projects (0,1,2,3) a midterm and a final. Projects 2 and 3 can be done with a partner, which is a huge help.

Project 0: Write a basic C program and then look at the assembly code it generates, explain what's going on. This was short and most people thought it was an easy 100, but I didn't know enough at this point and I got an 84. Because I was starting so far behind and catching up as I went, this project felt really difficult to me.

All the other projects involve doing some instrumenting and testing on a big C++ program called SESC, which is a processor simulator, then answering a bunch of questions about the results.

Project 1 involved tweaking branch prediction in the processor. For me this was the hardest, and I got an 83.

Project 2 involved doing some classification of cache misses. This project had a partner, which helped a lot as my partner provided one key insight I was struggling with, but we each did our own independent work, and I found this project easier than Project 1. I got a 100 on this one.

Project 3 involved instrumenting to see how cache coherence behaves in a multi-core processor. This project was the easiest for me, because it basically just took the code from Project 2 and tweaked it a little. I got a 94.

The tests were tough but fair. There was a lot of good study material provided, and I took a day off work before each test to study.

I was nervous about the midterm. I worked through all the study material, which took the better part of two days. While taking the test, it felt challenging, but I ended up doing well and got an A.

The final is cumulative, and it felt like a lot to study for, so I didn't feel as well-prepared. But when I sat down to take it, it felt easier than the midterm. Unfortunately I misread one of the questions and lost a lot of points on that one, so I got a B on the final.

The class felt somewhat front-loaded, with Project 0, 1, 2 and the midterm occurring before the withdrawal date. This makes the first half of the class feel pretty tough because it's fairly busy, but the good thing is you have a very strong indication of what your grade will be before the withdrawal cutoff.

After Project 2 it felt like there was a nice break before Project 3 and the final, which would have made it easy to prepare and study for those if the whole COVID pandemic hadn't hit right then - thank God it didn't come a few weeks sooner or I would have had a much rougher experience with the midterm and Project 2.

"Tough but fair" is probably the best description for the class difficulty overall. I had to really work at it, but I was coming from absolutely no relevant background (as were many others in the class), so I expected this. But all my efforts were rewarded because I learned a ton.

The class was well-taught. The lectures were fantastic. Nolan, the head TA, did a great job answering questions and keeping students on track. The assignments were very clear, and the tests were fair. This is the absolute model of how a Computer Science class should be. It's right at the top of my favorite courses, along with KBAI and ML4T.

So that's it. If you've read this far and haven't registered for the class right now, just stop reading and sign up!

An amazing course that focuses on high performance computing from the perspective of computer organization. The lectures are super fun and professor teaches complex topics with simplicit. Although, assignments are little tricky. It requires good knowledge of linux and C. Overall, one of the best courses in this program.

I took this course as my very first one in the OMSCS program and I can definetely recommend it to anybody who is interested in how modern processors work. If you thoroughfully work on the projects and prepare the exams, it is definetely possible to get an A in this course. However, especially the projects will require an effort to reach that.

The lessons are very well structured and supported with lots of quizzes whereof some are simple multiple-choice tests, but many require one to actually apply the knowledge gained in the preceding videos.

The projects require that you have
a) understood the lessons and can map them to (simulated) real world and
b) do quite extensive reverse engineering and adaptions in C++ code
so that at least basic knowledge of C++ (and will to learn more) is required. The projects are quite time-consuming, either because the simulations take some time and you will need many iterations of them to come to the right results (at least I needed them). However, you will learn a lot of either C++ constructs as well as the actual content of the course. Two of the four project could optionally be done in a 2-student team.

The professor and TAs really do their very best to support the students in their questions, either in his regular office hours and especially via Piazza. If questions are not alreaady answered by fellow students (which happens quite often), it mostly does not take more than a day until one receives a very useful answer from one of the TAs.

This was my first course in OMSCS. I wasn't sure what to expect, but found that most of the other reviews here are a pretty accurate description of the course. There are 4 projects - an introductory project 0, and then 3 more substantial projects. The course allows partnering up on the last 2 projects, and they are also the projects that I ended up spending the most time on. All of the projects are done on a VM that the course provides, and everything is done using the SESC codebase. The projects require a medium amount of depth and understanding about the codebase, but classmates on piazza and the TAs (especially Nolan) offer quite a lot of support in understanding the code.

I did not know assembly, and had a very basic understanding of C/C++, and also was not very familiar with converting hex/dec/binary, so most of the material and skills were new to me. I found that I had to repeat the lectures a couple of times and really work out the examples/problems on my own before I fully grasped the material. If you do not have any prior understanding of memory addressing and assembly language, prepare to spend some extra time with the lectures and outside reading/youtubing.

The pacing of the class is kind of streaky... there's a stretch of a couple of weeks where it's only lectures/problem sets (optional), and then all of a sudden a major project is due, followed by a midterm or final the next week. I would recommend starting early on the projects to leave yourself enough time to study for the tests, which make up a significant portion of your grade. The midterm and final (20% and 30% of your grade) are really the discriminators in this class, as it is very easy to get 90%+ on all projects. For those aiming for an A I would suggest spending a lot of time reviewing problem sets, examples from the lectures, and the practice and sample midterms and finals. If you understand how to do all the problems from those sources, you will be well prepared for the tests. When I took the class, the tests were open notes, and printed and handwritten materials were allowed. No electronic notes, and no searching. I printed out sample problems and solutions for reference on the tests, which helped me a lot.

I was able to finish out the class with an A, and since this was really my first exposure to the lower-level structure and processes of a CPU, I got a lot out of the class. It was a rewarding experience, and I felt that the effort I spent in the class directly translated to a good understanding of the topics. The tests and projects were all fair, and your grade reflects your understanding of the topics tested.

I had practically no C++ experience so I struggled to understand the projects. I eventually got them done though, in at least one case because my partner helped me out greatly (the first 2 projects are solo and the second 2 are with a partner if you want a partner). If you are lacking in C++ experience I strongly suggesting finding a partner who isn't if possible.

The material was interesting though of mixed difficulty. Sections on Fault Tolerance (RAID0, RAID1) and Storage, for example, were quite easy, whereas Cache Coherence was harder. Then again, I hadn't take a legit computer architecture course before this one. The video lectures were clear and thoughtfully constructed, meaning understanding the lectures should not be the hardest part of this class.

The projects involved modifying a MIPS processor simulator. These projects were difficult for a bad reason, i.e. that the source code for the simulator was difficult to read and understand. Thankfully, Nolan Capehart, the main TA, gave good pointers that guided you in the right direction. I don't think I could have done the class without him. The projects were certainly interesting and rewarding, but if you are like me and don't have C++ experience, you will struggle and should start them way ahead of time and ask for lots of guidance. On the plus side, you will be forced to gain some level of competence with C++ if you didn't already have it.

I got an A.

An amazing class! I recommend this to all who are interested in knowing about Computer Architecture. The projects were great, you have to work on the SESC simulator. It was difficult for me in the beginning as my C++ was rusty but I was able to catch along. The videos are very well presented and the professor explains the concepts succinctly. I did not have to refer any textbook, the videos were enough.

The TA for this course, Nolan, is absolutely brilliant. If he is still going ahead for the next term and you are interested in the course, take it without second thoughts. Nolan did a very good job of anticipating problems and made helpful pins in piazza throughout the term.

There are 4 projects, the first one is just an intro to the simulator and for the rest of them, you work iteratively on the same codebase. The TAs allowed pairing up for projects 3 and 4 which was very helpful as the C++ code can be difficult to understand.

There are two exams and the material in final covers the midterm too, so, you need to prepare well. There are problem sets available and students used piazza to discuss many problems which was helpful. Solve the problem sets and you are good for the exams.

Overall, a very good course!

This was my 2nd class in OMSCS (first was IIS) and between these two classes I've already increased my understanding of computers and programming multiple times over. This course was challenging in a good way. It wasn't ridiculously hard, the assignments were pretty well explained and any questions you had were answered timely through Piazza. The others reviews' assessments of Nolan aren't exaggerated. He's top notch. The instructor/lectures were outstanding. I'd take a class from Milos Prvulovic anytime. The class materials flowed logically and there weren't very many (if any) logic gaps in his explanations. He didn't under or over explain. He drew pictures and diagrams which I found helpful. The course spends most of the time on the CPU architecture (pipelines, branches, instruction flow, and caches). Towards the end, there are some seemingly 'random' lectures about memory module and storage (HDD, SSD, hybrid) hardware architectures. Don't take these for granted. Except for the lectures, these topics are otherwise an afterthought to the rest of the class, which was too bad. I wish there was a mini project or something that helped cement those lectures better.

Speaking of projects, there are 4 that progress in weight as the semester goes on. I wasn't a C++ guru coming in, so I found the projects to be somewhat frustrating at times. I found myself understanding the concepts, but futzing around with C++ and the (lack of a proper) dev environment for hours. I will say, I'm much better at C++ now (though not a guru by any stretch). Our slack channel was pretty much a ghost town most of the time, but Piazza was the place to go when you got stuck as there were lots of hints and useful info to help you out. Whenever I did ask a question through Piazza (maybe 2 or 3 times throughout the course), I always got a timely and helpful response, even hours before projects were due (I wasn't procrastinating, but I don't like to ask questions while there's still time to figure it out on my own). Speaking of procrastinating, don't do it! You'll get burned. Start first couple of projects at least a week in advance, and for the last couple start a few weeks in advance if you can. The midterm and 3rd project are due within a week of each other, so plan accordingly

All in all, I'd recommend this course to anybody - even if it's a refresher. The materials are well organized, the instructor was humorous at times and really seemed to not only enjoy the subject but enjoy teaching it to others.. You won't be disappointed.

Great course!! Very well organized and the head TA (Nolan) did a fantastic job of helping students to understand the material. The lectures are very well put together and I learned a lot from them. Make sure to watch the relevant lectures before starting the projects, they can help quite a but with understanding how things are working.

The projects were all done in a large C++ codebase and were fairly straight forward. The codebase is very old and there isn't a lot of documentation so it can be overwhelming and takes a while to get used to. It would also help to be familiar with C++ beforehand, but I wasn't and didn't have much trouble getting up to speed. Projects 2 and 3 were allowed to be done with a partner if you choose. The projects aren't so difficult that you can't do them by yourself, but it was nice to have someone else to bounce ideas off of.

The tests were TOUGH. There was one midterm and a comprehensive final. Make sure to study everything as the tests are a mix of problems and some more conceptual multiple choice and T/F type questions.

great class, well organized, clear instruction, and very helpful TA(nolan is a mf og). in the past i've had to find other videos on subjects i was trying to learn because the professor did a terrible job of explaining or looped in other concepts that they didn't bother explaining. never once did i want/need to do that this semester. tests are very straightforward and test your understanding of the material well. projects aren't too hard but they line up well with some of the bigger course topics(more so than other projects i've done in omscs so far). the course sounds intimidating at first with all the language requirements but i didn't know any assembly language before the class and it was totally fine. it definitely does help to know c++, but the projects are not overwhelming so you can definitely learn c++ as you work on them.

you learn a good amount on processors and the optimizations that are used to improve performance, would recommend.

Coming into this class, the only relevant background I had was from taking Operating Systems during the prior semester.

This class felt easier than IOS for me. There was less programming and perhaps slightly denser in terms of lecture content.

The projects were definitely not trivial and I echo what others already said about spending a huge amount of time trying to figure out how to change relatively few lines of code in C++. Nolan is a rockstar TA who kept the projects understandable. This was necessary because the projects as-designed had some vague instructions. I felt that overall this did not detract too much from the learning experience.

The professor touched on many different topics in computer architecture. The lectures were well-paced and there is a lot to be learned here. Good note-taking pays off for the midterm and the final exam, which is open-book. The exams were tough but fair.

I took this course after taking AOS (which I heartily recommend!) and found it an excellent look at some of the same topics from a hardware-centric view rather than a software-centric view. Pair these together and you should come away with an excellent understanding of low level systems implementation.

I didn't have wide experience with C++ prior to OMSCS, but now feel reasonably comfortable. If you're not, be ready to get that way fast, since the projects here all involve: read and understand a large-ish C++ codebase and make selective changes.

Thus probably not a great first course unless you have previous experience with computer architecture or professional experience with large C++ codebases.

Exams this term were open-anything-printed, so you have that fallback, but the questions expect you to synthesize information or work out on paper the steps of relatively complicated algorithms. Having practice this prior will help more than reams of paper.

The last two projects are optionally to be done in pairs for the coding parts, so that can be helpful if your C++ isn't as good as you'd like it to be. You still do your own analysis and students are always allowed to check their measurements on a different benchmark: this helps greatly in verifying correctness.

TLDR; Great--but difficult--course with an excellent TA who helps to keep you from getting lost in the weeds. Need to know basic C++ and get a fast computer to run the simulations. Would recommend!

Very good course overall and covers some of the more interesting topics in processor design (branch prediction, caching, cache coherency, etc). C++ knowledge is necessary, however, you do not need to be up on the latest C++ standards to get by. Frankly, if you know C you should be fine as picking up what little extra C++ is necessary will take no time at all.

As stated by others, the projects largely involve applying what is learned from the lecture materials to the simulator. This means studying the code quite a bit to understand its function. It's actually shocking how little code ends up getting written in this course. I suspect that the course has matured quite a bit over the past few years so I would strongly encourage you to give more weight to the recent reviews as I think they reflect the current state of the course much better.

For example, many of the assignments may have bugs or other errata but you will be warned in advance of the assignment about these issues so as to not be led astray. While the course material itself has not been updated to address these issues the TAs and/or instructor have been diligent enough to document these issues and make sure to advertise them to students in subsequent terms. Consequently, all of the sort of "gotchas" that previous students have encountered have long since logged and are published to students ahead of time.

Hope and pray that Nolan is still around as the TA for this course. The other reviews do not lie--he's that good and he helps keep the course focused and prevents students from wasting a lot of time digging into areas that aren't relevant for the course or a particular assignment. I'd say without his gentle hand guiding the class students would have to spend SUBSTANTIALLY more time with busywork merely trying to find their way. His contributions help keep students focused on relevant, productive work for the course.

The course time commitment is heavily dependent on your C/C++ knowledge, any pre-existing knowledge of CPU designs, etc, as well as how fast or slow your computer is as this will affect how long some of the simulations run. Personally, I would say the assignments weren't terribly difficult or time consuming with the third of the four projects taking the longest as it required that you develop the most understanding of a particular part of the simulator code base. If I had to guess I spent an average of 10 hours a week on the course but please understand that, like other courses, this is an average with some weeks being 4 hours and other weeks (especially exam study/prep weeks) being up to 24 hours.

Grades do take a LONG time to get back which is unfortunate, especially when you have an exam that contains questions that may be found on an assignment that you have submitted but for which you've not yet received an answer key or a grade.

Exams are BRUTAL. You will need the full amount of time for the mid-term as I suspect the mid-term is the exam that always features a particular question that is a multi-part question (as in 20+ individual answers) where each part is dependent on the others so you have to spend quite a lot of time working through the entire question to arrive at each of the related answers. The final is somewhat easier and did not require as much time though it is a cumulative exam so you will need to study all of the material from the course to be prepared.

Exams provide very few opportunities to explain your answer so if the answer you have provided is wrong you may not get any partial credit (you can provide brief comments to answers but the exams are largely designed to allow for a single "correct" answer) and this can at times be a problem if a question is perhaps not written in an unambiguous manner. Fortunately, these sorts of issues were not common.

The professor almost never contributed on Canvas but I don't really see this as having detracted from the course especially considering Nolan's excellent and timely posts to Canvas. I suppose if you're keen on pursuing a career in this field you would want more interaction with the professor which is limited to the weekly office hours.

I'm highly interested in the topic (Computer Architecture) and had prior experience working with low-level driver development, startup code, compiler tool-chains ..etc on different processors and this was really helpful during the course. I would say it's far from being easy and requires diligent effort to keep up with projects as well as recommended reading which is essential if you want to get an A.

Working with SESC needs crafty troubleshooting skills and good organization, also can be time-consuming! so no projects can be done last "minute". Therefore, Following the suggested schedule for learning the material and especially doing projects as soon as they're available is very very important.

Very little slack for recovery as the course follows very strict deadlines and deliverables. but Prof. Milos and head TA Nolan Capehart provide guidelines and advice on what to expect and how to get a good grade .. when followed can be very helpful. Head TA Nolan Capehart is doing a great job and very helpful and provides detailed guidance and advice to get a good grade on each assignment.

A lot of work, but worth every minute.

Language: C++ Exams: Midterm and Final, Final covers complete syllabus, so expect Question from midterm material. Weight: Project 0 - 5% Project 1 - 10% Project 2 - 15% Project 3 - 20% Midterm - 20% Final - 30%

I did not have prior experience of working with C++, hence projects were challenging for me. It is recommended to start projects early, so that they can be completed in time. Pay heed to this advice seriously. I lost out on 50% of Project 2 grade because I couldn't start ahead. Don't lose hope if you do not do well in first half of the semester, you still have chance to perform well on Project 3 and Finals(which comprise 50 % of the overall grade). Exams were open book, and questions were conceptual. Personally, I never figured out how well/badly I did on the exam until results were out. You keep thinking about answer choices you made while giving the exam. It's on par with the GIOS course(CS 6200), in terms of quality of lecture material, projects and exams. Just that this course does not have curve, at least it didn't have for Summer 2019. Head TA Nolan Capehart is outstanding at his job. He is one of the kindest and most helpful TA I have ever come across in OMSCS. He makes this course so much likable.

This was an extremely difficult class, although extremely rewarding as well. The projects were relatively little coding, but did take some thoughtful analysis of the problem space. Verification of your project results is difficult to near impossible without the facilitation of the ever-excellent TAs. Course material is extremely detailed oriented, and the tests will challenge you on those details.

This class was very informative and interesting, speaking as someone who had never looked deeply at how the hardware works before. The 4 projects use a CPU simulator written in C++, which is a massive codebase with lots of .... legacy parts, but fortunately the projects don't require too many lines of modifications. The tricky part is usually not understanding the idea of what you need to implement; it's understanding how and where to make changes. (On two of the projects, I started with one approach that, in theory, should have worked; but the CPU simulator was implemented in a way that made theory different from practice. A different approach was required.) The exams were tough, but fair. The questions were similar in style to the quizzes during the lecture and to the example midterm questions. My recommendation is to spend a lot of time preparing for the exams and doing practice questions, since they can be pretty tricky.

This class touches many interesting concepts in modern computing, though the course material is a little bit outdated compared to today's latest cpu offerings, basic concepts still carries over. This course will help you understand how a modern computer functions. Projects are hard but they give you ample amount of time (like 1 month to finish it). Start early and keep asking questions on Piazza. Nolan is a great TA and he answers questions in timely manner with great detail. Tests are somewhat hit-or-miss. I felt like the test was formulated to really distinguish people who understands intricate details of the course from ones who are getting broader understanding of the subject. You really have to study for the tests in order to get an A in this class. Doing projects alone will not get you an A in this class.

Pros

• The course offers overview of many different techniques that is used in modern processor.
• The TA (Nolan) is a blessing for this course. Very helpful.

Cons:

• Not even a single time I saw any comment/answer from the prof on Piazza in the entire semester. W/o the TA's help you can't get through this course.

• My assignment grades are 97, 100, 96.5, 96. (last two projs can be done with a project partner as well). Midterms and Final are ~70% each. I got a B. No matter how well you do in the programming assignments, if you don't do very well in the exams , then you can't get an A. The weightage is purposefully distributed that way. Exams are difficult and very lengthy. No curving.

• Lessons are so lengthy and a LOT of quizzes on Udacity. Feels tiring and never ending . If you're working professional , you may have hard time covering them.

• I was so busy working for the assignments, finishing quizzes , preparing for exams e.t.c. that they wasn't enough time to actually learn the materials.

• The course could be broken down into one introductory and one advanced course to cover the material well such that students can take some ideas from it and use in real life. But seems the purpose of the course design was that so it can be claimed as a "Difficult Graduate Course" to meet GaTech standard.

• Old fashioned way of teaching. In a way waste of time. But if you really interested in computer architecture, you can take the course.

This class is truly graduate level and good entry class to system level matter. Especially I like the topic covered in the former half, about how processor works (pipeline, branch prediction, predication, reorder buffer etc). If you are interested in how each line of your program is executed by hardware, you can gain much from the class. The latter half of class has some overlap with OS class (Storage, Barrier synchronization, consistency) and while I feel it's bit redundant, it is still interesting for people who learn it for the first time.

The grade is based on projects (#0 to #3) and 2 exams. Projects are.. to be honest I don't fully support it. Instead of implementing what we learn from the class, what this class employs is that using simulator you will emulate the theory taught in the class. What we would do is to modify the simulator code to see the difference per each condition which we want to compare, or to measure a count of some behavior. Throughout the projects, TA, especially Nolan was super helpful.I could get full mark for all projects thank to Nolan. He is welcome to ask questions for the answer in a private post on Piazza. #2 and #3 can be done in a group project format while I did them alone. To me #2 is the heaviest one and #3 follows, but #1 is felt most challenging because we need to get used to the simulator code base.

Exams are fair but not easy. Midterm was especially difficult. Final was easier but not very similar as a sample test given, so depending on your preparation it could be difficult. Also Final covers all topics including what Midterm already covered, so it is bit overwhelming for students.

There is a slight extra credit for projects, but I don't think it won't help that much. If you aim for A, get 100 for all projects and make good preparation for tests. A note is allowed in exams so you don't need to memorize them all.

Overall, I like this class. While the projects don't make sense to everyone and exams are not easy, the lectures and TA are brilliant. I recommend this class for everyone who is interested in low level stuff.

I loved this course. The projects were fun, well-structured, and aligned well with the lectures. The exams were challenging but fair. The lectures were enjoyable to watch. The head TA Nolan Capehart is a superstar and has been one of the best TAs I have ever encountered in the program (IMO he and Stacia Stokes from CN are tied for first place).

Course Contents

• 3 projects plus an intro project
• 2 open book/open note exams
• Lectures, no required readings
• Lecture notes are provided by the course

Overview

This course covers the high level design of a modern superscalar processor. All the projects are based on the SESC (superscalar simulator), which is an open source academic project for simulating high performance processors. The exams are comprehensive with a combination of free form answers, true/false, and assembly coding examples.

C++ knowledge is required for the projects - although it doesn't need as much in depth knowledge as, say, the AOS projects. Basic assembly understanding is also required for lecture material and exams.

Review

I really enjoyed the computer architecture aspects of this class - learning in depth about how superscalar processors work: how they execute and pipeline instructions, branch prediction, caches and cache coherence. The lectures in this class are very good, with almost uniform praise from everyone who watches them (even those in other classes, who want to understand the relevant material better). So I am glad I took this class, and I learned quite a lot.

Now the bad. Post midterm this class took a downturn. It starts to turn into a basic OS class (covering RAID, for example), which isn't what I was looking for in a performance oriented computer architecture class. I'm not sure why it starts covering these topics (very tangentially related I guess?). Unfortunately, as a result, this class is not as comprehensive as I would have liked. On the plus side, if you're using this as a second class, the class seems to get easier after the midterm (some weeks I only spent a couple hours watching lectures). The cache lectures and cache coherency lectures are still good post midterm.

The midterm was hard, and not in a good way - I think this is a reason for some of the negative reviews this class gets (plus the projects, which I'll get into in a sec). It's very time constrained, and the kind of questions it asks are difficult to do in an online format - they really need pencil and lots of paper to work out. And for some reason you are limited to 1 blank piece of paper only. All I can say is make sure you understand the algorithms you learn up to the midterm very well. I think the median on the midterm was upper 60s for my class - and many people dropped or at least considered dropping after it. On the positive side, my midterm was graded quite generously (lots of partial points) which sort of helped sooth the wounds.

The final in comparison, while comprehensive, was easy and much more reasonable in my opinion.

The projects are a bit contentious.The main difficulty is that SESC is a ball of C++ sphagetti, and the project docs are MS Word docs with weird formatting and some ambiguous specifications. Fortunately, the head TA Nolan helped to smooth over most of these difficulties. Also most people get 100% on the projects because we're allowed to compare our results on extra simulations. I personally found only the intro project difficult (trying to understand SESC). After that I found it pretty easy. For each project, you basically write 1-15 lines of code and you're done. AOS projects are a lot more work in comparison.

There is rarely a curve in the class due to everyone doing well on the projects and final. As a result, your grade will mostly be determined by your midterm score.

There are also a lot of problem sets attached to the lectures, but these were pieced together by the Udacity developers I believe and are not great quality. You can spend a lot of time doing these though. I think I did the first batch of them and stopped looking at them after that. However some people said they got a lot out of them, so up to you.

Overall, I can recommend HPCA and think you'll get a lot out of it if you can get over some of the shortcomings.

Exceptional course that I think all software engineers should take. It provides a comprehensive review of modern computer architecture, so that you can better understand HOW your code actually executes.

The TA in this class (Nolan) is the best I've seen in the program so far, by far.

The midterm was tough but fair and effective. I used the whole 3 hours for the first time in this program. The final is comprehensive, so I was pretty freaked out heading into it, but it ended up being much easier than the midterm. Finished in about an hour.

I wasn't a huge fan of the 4 projects. I got high A's on all of them, but in my view they aren't designed very well. You spend most of your time learning a chip simulator, which is a big, crusty C++ codebase. In the end I probably just wrote maybe 30 lines of code for all 4 projects combined, but it took more than 20 hours (total) to understand the codebase enough to know what to change. I think a better approach would be to use the simulator to assess C and assembly across a wide variety of architectures, plus some small homework assignments to have us write toy versions of some algorithms, like Tomasulo scheduling or MOESI cache coherency. As it stands, though, if your C++ isn't good enough to read a highly templatized codebase, your grade could suffer pretty seriously. The last few projects are optional group projects, though, so if you can find a buddy to help out you'll be fine.

Interesting material, but very poorly run exams and projects which ruins the experience. Projects involve running simulations and making small edits to a large existing codebase. It takes a lot of time to run the sims, and it can be frustrating to figure out the wacky behavior of the program (generally the less you try to dig deep, the better).

Exam material is based on trivia tidbits and has little relation to the materials. Several typos and gotcha questions.

Professor is pretty much absent, but the head TA Nolan is active on Piazza and very helpful.

Grades on projects take way to long to get back considering that they don't give partial credit anyway (just check to see if your answer in the blanks matches the key).

Honestly, just audit this course on Udacity if you are intersted in the material. Don't bother taking it unless nothing else is available.

This course is a solid overview of modern computer architecture covering everything from processor pipelining and branch prediction to multi-core architectures. This is a topic that everyone, even the data science and software oriented folks should know and I highly recommend this class to anyone who wants to have more than a superficial understanding of how computers work.

Pros:

• Lectures are also pretty informative (though some may find them dry).
• Homeworks are not too difficult and are more focused on learning than other courses. You're essentially modifying a simulated processor and filling out a worksheet detailing your results and answering some short answer questions. They do require a good working knowledge of C/C++ and the ability to work in a large codebase.
• Exams are reasonably fair. They're difficult and tricky, but they could be much worse.
• The head TA (Nolan) is the best TA I've had in the program. Very active on piazza and very helpful.

Cons

• Grading can take a while.
• If you have some background in computer architecture this course will probably be quite boring.

I took this course in Fall 2018 (didnt find that option while writing this review)

I found this course informative and hard. There were lots of nitty-gritty details about the processor architecture discussed and these needed to be applied during the exams to solve problems. I found the midterm exams quite tough and ran out of time trying to solve these detailed problems. The exams were open book but only on notes that were hand written. All my notes are online and printing them out was not an option for me. So, this made the exams pretty much closed notes for me and was unnecessarily tougher due to this

I throughly enjoyed the projects which were inline with the weekly topic and helped understand the topics better. They were all C based and understanding code navigation (using csope or anything similar) helps.

Overall, I found this course well organised and informative. IMO its quite hard for as a 1st course

This was my first class in the program. At first I felt a little overwhelmed by the amount of information and especially the project #0. Once I passed through the first half of the semester it became much easier. After projects #0 & #1 projects all started to make more sense. Nolan deserves a nice bonus for going above and beyond for his TA work. Overall, I entered the class with very limited computer architecture knowledge and finished with a solid understanding of the area at a graduate level. I recommend this course to anyone who is fascinated by how computers work.

P.S. My course was in Fall 2018. OMScentral feedback page did not allow me to choose Fall 2018 and the only closest option was Summer 2018.

Great class. Really enjoyed it. Nolan was an awesome TA.

If you are already familiar with related concepts already, especially pipelines, cache, and out of order execution, this course is not that difficult. However, if it's your first course into computer architecture, this could be very difficult. In the labs, we have to go through part of a CPU simulator written in C++ and figure out how to make proper modifications.

HPCA was a really fantastic course overall. Highly recommend it if you enjoy low-level topics like this.

Solid class.

Overall the course is good, lectures are meaningful, up to date with current technologies and Nolan as a TA was awesome. However the work on projects are tedious and time consuming. The projects are not stimulating at all and I had a hard time bringing myself to doing it. Overall, if you pace yourself properly (and not keep things for the last moment), it is not a difficult class at all. Make good notes throughout the course and keep it handy during exam. Professor allows the notes to be used during exam and it will help you give pointers to solve problems.

This was my first class in the program. While it wasn't a subject I was initially interested in, I learned a lot and had a good experience. The lectures were very clear and well paced. The exams were very much in the spirit of the lectures and were not difficult, although you should study for about week in preparation.

Additionally, the main TA, Nolan, was incredible. He was very attentive, caring, quick to respond and knowledgable. I was surprised by the amount of collaboration and camaraderie among the class. The other TAs were almost inactive (as far as I could tell. May have done things behind the scenes), however, Nolan was so good it didn't matter.

The only thing that could be improved were the projects. Each project was essentially running a simulated processor with a test program, tweaking the inputs of the processor, and seeing how it performed differently. Then, there would be a code section were you alter the code of the processor and see how it performs.

The first section taught me a lot about processors, however, the code portion was more tedious than informative. This is because the simulator is a huge C++ code base that is somewhat poorly written. Most of the time involved in the projects is trying to understand what the code is currently doing. The feedback loop is also very long because running the simulation normally takes about 30 minutes real time.

The saving grace here is that the TAs allow you to compare results on a simulation other than the one for the project. So you can know for sure if you have the right answer.

This could all be mitigated if the instructions gave you more direct guidance. "Edit function, foo, so that it does x instead of y."

Overall, though, good class, great TA(s).

Great course. I have no background in computer architecture before, therefore It's could be hard at the beginning. But if you got through the course, you will definitely learn a lot a lot. The grades for both project and exam are very generous, I got overall 98 at the end. The leader TA Nolan is awesome! He is the best TA in this program I have ever seen.

This was a pretty great course. The lectures are well done, and the tests were straightforward. The projects were on the challenging side, but not because the concepts themselves were difficult (though they aren't a cakewalk either... ). The main challenge in the projects is development in a simulator that is old, very poorly documented, somewhat nebulous, and doesn't seem to follow a coherent design. That being said, it isn't really a problem, just time consuming.

I took a similar course in undergrad, but this class goes more in-depth into actual algorithms and designs, and peels off several layers of abstraction to get into the core of CPU architecture design and theory. I would definitely recommend it, but do be prepared for the projects!

Challenging yet very rewarding course! Be warned, do not take this if you don't have some OS knowledge or C++ programming experience; the course knowledge is very dense/broad and you will be playing catchup to understand the concepts if you do not have the sufficient background. On the other hand, the course was relatively easy in terms of grading, the exam is way less overwhelming than the actual material taught. The projects require you to understand the concepts and make less than 200 lines of code changes(I think we were required to make changes to less than 8 C++ files total. )

Overall it was a very interesting course imo. Worth taking if you are interested in how modern computers are optimized.

This class was hard for all the wrong reasons. The instructor was not present at all on Piazza at all during the semester, although he did hold office hours once a week (those were not recorded and I was unable to attend so I can't comment on their usefulness).

As others have mentioned, the projects aren't hard once you figure out what you need to do. My major difficulty with this class was the sheer amount of material, and the grading structure. 50% of the class was assignments, while the other 50% was tests. I did well on all of the assignments and met or exceeded the class average on the tests and still ended up with a B. The final was cumulative, so it was really hard to decide what to focus your studying on, and there was one concept that I simply didn't dig into when I was studying that came back to bite me.

I didn't end up using the book too much and it's not required. So I wouldn't recommend purchasing it unless you really want to.

Overall, the material in this course was interesting, but the administration needs some improvement. Still, consider taking it if you're interested in computer architecture.

• First class taken in OMSCS.
• First time back in school after 15+ years. Was never a very studious person...
• Married w/ 2 kids under 5, full time job.

This was my first semester in the program, and I took this class because I was in the middle of nowhere with no Internet for the first 8 hours of my low priority registration window - so I was pretty much forced to take this class.

I thought the lecture videos were done very well. The TA was doing his best to be helpful and was for the most part responsive, but it was clear that he was overworked. The HWs and projects were not graded in a timely manner. Half of the HWs were not graded by the end of the course (though to the TA's credit, he offered to consult individually for students to see where they stand in the course prior to drop date).

The midterm was pretty difficult. The final was made to be no-notes, no-calculator, and no-scratch paper. The result was that it was a lot of hand-wavy sort of conceptual questions (poorly-worded questions like "what would be the more likely outcome if... " sort of questions) - which I do not excel in as indicated in my grade in the final.

The projects were not too bad if you have previous C++ experience like I did. But I question the usefulness of these projects in learning the concepts. But yes - in the end, you're interpreting thousands of lines of code and changing 10 of them.

I think the biggest problem is that the subject matter was just too academic for me to relate to in terms of generating excitement. And plus it was just drinking from a firehose for 4 months in terms of the amount of material covered during the semester.

I took this course but dropped at the drop date due to the fact that I was also taking another course. Well for the part I covered (about 55%) the course per se is not extremely hard if you strictly look only at the concepts, what makes it hard are the projects and the exams. In fact even the projects are not too hard, it is the exams I found to be particularly different from all other courses. The exams only have problem solving question with some heavy arithmetic. A lot of practice with formulas is necessary. You not only need to know your formulas but the questions will wrong-foot you at every turn. Hardly in real life we get situations where one has to do HPCA arithmetic within a quick turnaround time. And that is what this course's exams are about, doing HPCA arithmetic within allowed time constraints. Well I am not saying the arithmetic is not important but the course turns it into something like a race at Olympics which I think is not necessary. I would say that if you know your formulas well you can do very well in this course sometimes even if you don't understand the concepts well. In fact a high school student can be taught to use the formulas effectively and be made to do well in this course's exams. I did not like the fact that the course's exams only focus on arithmetic even though it is at a graduate level.

I decided to jump into this program with both feet, taking 6210 and 6290 in my first semester. HPCA was an incredible class and I learned more about computer architecture and optimizations in this class than in my entire undergraduate program. The projects could be hard or easy, depending on your skill with C++, but the grading is fair. I ended up with an A, mostly because of good project performance and spending a solid day before the final working through all the problem sets again. I agree with the other commenters, Nolan was awesome!

I was able to manage this course with no professional programming background. But you need to spend a lot of time trying to understand the code in the simulator for the projects. I think this code is basically written by hardware folks trying to get the job done in software, which is effectively what the simulator is simulating, a processor. I think the intention of the instructor is to have students spend time on understanding the code rather than give it to them on a platter with comments. If you nail the project 1, the others are just a breeze. Once you understand the flow, actual implementation should be fairly straightforward. Lectures are just awesome. Mid-term was hard mainly due to lack of time, 2 hours is not sufficient. Final was easy even though it was comprehensive.

although it is not a easy course, I find the projects helpful. they projects are not very related to the course materials, but rather a complement. The course videos are very good, covering a lot of concepts, and the instructor did a great job explaining abstract concepts very clearly. The videos are one of the best course videos I've seen in OMSCS. (I've taken 8 courses so far)

I think this course was more difficult that it needed to be. The course covers a ton of material, and only had two exams (second was comprehensive) which made the amount of material to study for both quite staggering, and there were tons of quizzes and problem sets that were picky about rounding/formatting. Office hours weren't recorded for some reason when they were held, and the majority of grades weren't released until after the final was over making it hard to gauge one's progress. The SESC code base used throughout the class is horrific coming from someone who has worked in enterprise for a few years, and sadly the majority of the projects were spent just figuring out what was going on in the code vs. actually implementing and having fun measuring different aspects of the project questions. One project involved modifying the simulator in a file where ~20-30 lines of code directly pertinent to the project didn't even work correctly, and was effectively dead code that misled students. Luckily the main active TA Nolan was awesome, super-responsive to questions and helped clarify a lot of the confusion over Piazza. All lectures were just on a virtual whiteboard with a short intro/outro by the professor, and I would have appreciated a bit more production value like in Computer Vision where there is a mix of slides/camera angles/reading to break the monotony a bit.

The thing that sucks the most about this course is that you don't really know how you are doing in it. When we took the final we only had 30% of our overall grade reported back.

For the most part, I really enjoyed this class and the labs. My problems with the labs were twofold. First, the emulator used in this class is poorly documented and has weird behaviors that have to be taken into account to get correct results. Once I understood (read: got burned by) this, I spent more time in the projects trying to make sure that I didn't misunderstand how the emulator worked than I did actually doing the lab. The second part was that it was really hard to get a feel if your lab results were expected. It is structured so that you do the work and analyze the results. I ended up analyzing the "wrong" results and got double penalized (see point one). The TAs try to help with this, but they can't just come out and say whats wrong, so make sure that you read everyones notes to the TAs regarding the labs. There may be something there that is relevant to you, even if the post's title doesn't seem that it will be.

Extremely difficult course, I'm glad that I passed it.

This is a very hard class, but in my opinion completely worth it. Don't let fall behind on the lectures or cram everything into a weekend, it will be your downfall. The professor was active for the first half of the semester on Piazza. We had a really great TA that was active in answering questions and clarifying any material we've learned. Please review your C++. It wasn't too bad but having some background on C++ will help you be ahead in the coding projects. Overall I loved the course, even though it was difficult.

This class is hard, but you will learn a lot. Hands down, this class has the best lectures of any course I've taken.

The projects revolve around a simulator whose source code is old, defunct and hacked together by a bunch of academics. On the surface it looks incredibly hard, but you only need to change a few lines here and a few lines there to get it to do what you want. They'll tell you which source files to look at. I found this experience of reading other people's source code helpful, now that I have a job as a maintenance programmer. Use a buddy for the project if groups are still allowed.

The tests were hard, but not unreasonable. Study and you'll be fine.

We had an issue with one project spec (the required IPC was not attainable), but the Prof gave us a few day extension.

I agree almost completely with a number of the other recent reviews.

The Pros -- Course material is great - the videos are quite interesting. By the end of it, you learn an amazing amount of material. I seem to be in a minority, but I felt the embedded quizzes were great (despite typos & errors) and really helped to reinforce the course material. You can always hit the skip to answer button if you run into trouble. You got credit for just attempting the quizzes.

There is a partner option for the last two projects which was great. That became an important channel of communication for working out issues that were not addressed via Piazza.

Generally positive -- I quite enjoyed the project and felt like the effort level involved was quite reasonable (8-15 hours). If you cannot read C++ or figure out undocumented code you will have trouble. This is a real academic simulator, written by people just trying to get things done; commenting was a secondary concern. The actual coding you do is 20-50 lines, the trouble is just figuring out where they go. Having read horror stories about multi-hour simulations from prior terms, I was pleasantly surprised that the simulations took only a couple of minutes.

The Major issue (as stated by others) -- was the Piazza interaction with the professor & TAs. Office hours were cancelled for a few weeks, then disappeared altogether. Logistics around projects and exams were poorly communicated. Halfway through the semester instructor (professor / and especially TA) participation fell off a cliff. Shockingly, there was no formal announcement for the Final Exam!

Overall -- the content is great, but be prepared to have to figure things out on your own. Make sure you take the lab partner option as he/she will be one of the best resources to resolve issues that you are unable to post publicly to Piazza.

Pros The content of the class was excellent and the professor presented them very well When there are problems in regrades and proctor, TAs and professor handled well although not very timely Office hours were very useful for project1 and project2 Cons Absolutely no presence on Piazza after mid-september Office hours didn't happen regularly after september Other comments

• you have to be proficient in C and be able to understand huge code which has no comments to be able to do projects
• I found the midterm1 content and exam tough. After that the material [cache, coherence and multiprocessor] was very familiar and so found it easy
• If this is your first course as it was for me in OMSCS, it is a bit frustrating as everything is new to us and the TAs and professors are not very responsive
• projects are a direct application of the material learnt. After reviewing sample projects in the wiki, I felt our batch got quite easy projects :)
• All in all, it is a wonderful course, even if you are not specializing in computing systems, it is always useful to understand how processors are designed

Very disappointing class. Its starts out fine. The lectures are good and the professor is very good at explaining the material, and there's A LOT of material. The exams are hard but decent representations of what was taught.

The projects on the other hand are poorly done. Any attempt at trying to implement what you've learned in the lectures is overshadowed by very confusing code. For one project students wasted hours and hours trying to work on code that the TA's eventually admitted had an error in it. I didn't learn anything from the projects and they account for almost half the grade.

The worst part of the class was the presence of the professor and the TA's on Piazza. It was decent at first but halfway through the class suddenly nothing was being addressed. There was literally an entire week leading up to the due date of a project where no questions were addressed, and there were a lot of questions. I'm actually amazed that the TA's in this class got compensated for their efforts. Not only was their presence abysmal, but many students were still posting about month old regrades into the last week of classes.

Bottom line: There's a reason this class has the highest withdrawal rate in the program.

The subject matter is really quite interesting and you learn a lot about processors. Projects are not hard but tedious to get through because of SESC and its lack of documentation. Grading feedback and general responses on Piazza was very poor and highly intermittent.

The Pros -- Course material is great - videos are interesting, funny, and full of content. Minor supplemental reading helped flesh out some of the more challenging topics. Learned a tremendous amount in a quick time.

The Cons -- the embedded quizzes have frustrating errors at times (typos, looking for specific formats of values, accept only an incorrect answer). Some videos appear missing or incorrectly ordered.

The Major issue -- Piazza interaction with the professor & TAs was very limited. Office hours were cancelled for a few weeks, then disappeared altogether. Logistics around projects and exams were poorly communicated.

Overall -- great content, but be prepared to learn it with you and your fellow students. Very limited ad hoc teaching support.

Amazing course! Excellent video lectures. Haven't learnt so much in a long time. Prof. Prvulovic's explanations left very little doubt on almost all the topics he covered in the lectures. I have them all downloaded & can keep going back for reference. Although a more active participation on piazza would have made the learning experience even better. But, having gone to a college here in the US for my masters' I know it's almost not possible to get full attention of a Prof all the time... Perhaps some homework assignments would have helped improve the understanding even better (& helped in the midterms :)). The projects were interesting and were useful in applying what we learn in the classes. There were lot of complaints about the SESC simulator code in general. Its very understandable that the code is in that state having changed so many hands. Don't have much to complaint about this course in general. Overall experience with the course has been very satisfying.

Avoid taking this class! Tests were very unfair. There were some lectures without problem sets that then had exam questions. Professor was not to be bothered regarding additional problems. Overall the professor was hardly on Piazza. Professor would not spend time to create Piazza threads and interact with students. Udacity TA was rude in Piazza in a couple of instances. Would have spent more time on the course if it was presented and maintained better. This course uses ProctorU and is mainly test based (60% of course grade - two midterms and a final). I had a horrible experience during the first midterm exam with ProctorU and it took almost 5 days to hear anything from the course staff. I found the projects (40% of course grade) relatively easy, but they required a good bit of tinkering and took a good bit of time to run the simulations.

The lectures are entertaining. The exams are very detailed, so don't slack on preparation. They are open-note though, and that helps. The projects are not very code-intensive- its mostly understanding the existing simulator code and making some tweaks. The simulations can take a lot of time so you can't procrastinate. The professor does seem a bit overzealous in looking for honor code violations (to the point that most people are too scared to post answers on Piazza), so there is a strange dynamic there.

Instructor is good, material is solid and interesting, exams seemed fair, assignments were frustrating (Largely trying to understand somebody else's simulator, not much understanding of comp arch required). Overall, I recommend the class.

The lectures (and the material they cover) are great if you are even somewhat interested in the low-level design of a modern computer. I thought the exams were mostly well-constructed and representative of the material we learned. However, I didn't care much for the assignments. Reverse-engineering SESC (the CPU simulator used) is neither educational or interesting. I would have learned more if we had built our own simulations of certain architectural pieces (ideally to plug in to well-defined/documented interfaces to a larger simulation) and perhaps written thorough tests for those pieces. All this aside, I think the excellent lectures make the course worthwhile. Note: Professor/TA responses to questions and issues have been problematic for many people.

This class is fairly tough. It is both broad in scope and deep in individual subject material. If you aren't already well-versed in it, you will learn a TON. It helps if you are already familiar with processor architecture at a high-level (you should have heard the terms pipeline, register, ALU, cache, etc, and have an idea of what they are). You should have encountered MIPS assembly language for the discussions, but you won't need to do any MIPS programming - you just need to understand what the arguments and commands look like and you should be able to pick it up from there. The four assignments (2 individual, 2 with optional partners) will require C++ knowledge, and a VM environment to run the linux VM that contains the simulator (VMWare is recommended). I think the class started with something like 160 students, and at last count had around 100 on the roster; although the professor indicated something like 50-60 students turned in the latest assignment, so maybe quite a few more have dropped. If you have any doubts about this class, I would recommend taking it in a semester by itself when you can focus on it.

It was an engaging course with a lot of material. This course does assume you have some background in computer architecture and continues on assuming you know some of the basics. The midterms and final are open book but some questions require a significant amount of critical thinking of the topics covered. I would say that overall it is a relatively tough course but definitely doable if you stay on top of the lectures.

This class is definitely difficult, moreso than 6210 in my opinion. And, for some reason all of the instructors seem to have completely dissappeard off of the Piazza boards and it's really, really hard to get an answer from anyone (even fellow classmastes). In any case, I REALLY enjoy the content, I think the lectures are really well done, the projects are VERY difficult and involve a deep understanding of the simulator and what is really going on there, even though we have no instructions about how to use the simulator. You have to spend a lot of time just figuring it out on your own. The tests are interesting, they are proctored on proctorU, but you answer all the questions in your browser and submit, not like 6210 in which you had to create a word document and submit it.

Very rewarding. Learning a lot (not yet finished). Projects are good but little tedious and reinforced what we learnt in theory. This is my first class and I think it will act as a solid foundation to any systems class I might take like intro to HPC or Intro to OS or even AOS. I have gone through random lecture of all these classes and found the concepts are highly needed there.

Exams require good unnderstanding of subject matter and its application, exams are mainly math so you can end up scoring low even if you have prepared well. Projects are not very code intensive but takes a long time to run multiple simulations, simulator is not documented well enoungh and you need to spend considerable amount of time to get started. Overall I enjoyed this class, great class to take if you are interested in systems

I dropped this course after the second project/first midterm due to workload of the two courses I was taking (this + CS 7637 meant basically spending all of my time outside of work on OMSCS stuff. It was down to a coin toss which one I dropped). Fantastic lectures and content, but I found that the projects were difficult but in an annoying way - there was a lot of time spent trying to figure out how the underlying simulator works, or what the assignment actually wanted, as opposed to actually applying concepts in the class. Midterm felt difficult but fair. I do plan on taking this course again in the future - it's really interesting, just expect a high workload covering a lot of content.

This class is very challenging, both difficulty and time-wise. The lectures are very good, but the projects have been fustrating and time-consuming. More time is spent trying to understand the poorly documented simulator than demonstrating the concepts. There were a lot of curveballs on the tests also, and you needed very good understanding of the concepts since the problems were often quite different from examples in lectures.

Learning a lot. The midterms are tough. The projects are very useful and hard.

May review may be biased since I am working on processor verification. This lecture gave me more insight and broader perspective. Beginers may find overwhelmed by course load but lot of them are building blocks and are absolut necessary for computer architecture. In my time assignment was average hard. Once you figure out initial thing rest are mostly repetative contact TAs for starting, Exams are open book and question quality is great , But it tend to have only 5 questions if you dont get a part of it whole question you wont be able to answer. Also evaluation of assignment and exam is harsh

I really like this class. It has provided a lot of clarity to what happens where the electrons hit the silicon. It was not difficult, but there is a lot of information to digest. It is the compliation of decades of very clever ideas, all rolled up into a short class. The lectures are well laid out and I was able to watch them at 1. 25x or 1. 5x the speed, depending on whether or not Milos had his coffee before he recorded the session. I enjoyed the coding sessions and I think that the changes we were required to make are close to what you might see in the real world if you were modifying internal simulation software. The most difficult aspect is that there is little guidance as to whether or not the metrics that you find in your projects are the optimal solution. This simulates the real world, where you have to make sure that what you code isn't outputting crap numbers, but makes it difficult to ensure that you get a good grade on every assignment, especially those where you are competing against the other students. Not for the feignt of heart, but a good class full of pretty cool information.

Very erratic course. The material was very interesting, and I generally liked the presentation. Everything else, though, was awful. Poor responsiveness on Piazza, with a week or more going by without any instructor or TA presence. Absurd grading... one assignment had us submit (among other things) a 'Hello World' program with a modification to include our name. I forgot to submit that one (partly because the way the assignments are written makes it tricky to pull out what's needed for a submission) and got docked 30% of the whole grade. The course makes use of the SESC simulator, which is one of the worst, most poorly documented codebases I've ever seen. In addition, the effort required to work with SESC and modify it was vastly out of proportion to what we were studying. I never understood how wading through SESC to figure out how to change the branch predictor had any relevance to what a real processor does. Finally, the exams were a disaster. They used ProctorTrack for the test, but it was basically open book in that you could use any printed or written references, but couldn't use anything on your computer. You had to do everything by hand on paper (like when doing the incredibly tedious cycle counting problems). This was a real problem in the test, because I hadn't done them that way... I always worked in OneNote to set up my tables, plug in my steps, etc. When I had to do it on paper on my desk, it was a complete mess.

I did learn a lot in the class. For anyone who took a computer architecture class in undergraduate this class picks up where it left off. Projects take a lot of time, but most of it is from running the simulator multiple times under different conditions. This also means you need an early start on projects because making the wrong code change could take a few hours to figure out your results don't make sense. Exams I believe cover most of the material in the lectures, so there shouldn't be any surprises. Lots of quizzes throughout the lectures to reineforce the material. Overall I'm glad I took it, even if I won't be designing processors I think the techniques used to solve challenges in modern processors are useful for developing new technologies.