High-Performance Computer Architecture

Quick Facts and Resources

Something missing or incorrect? Tell us more.

Name
High-Performance Computer Architecture
Listed As
CS-6290
Credit Hours
3
Available to
CS students
Description
Topics concerning very high-performance computers including techniques exploiting parallelism in single and multiple processor systems.
Syllabus
Syllabus
  • Georgia Tech Student2022-05-08T18:39:40Zspring 2022

    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!

    Rating: 5 / 5Difficulty: 2 / 5Workload: 6 hours / week

  • Georgia Tech Student2022-05-07T17:20:25Zspring 2022

    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.

    Rating: 4 / 5Difficulty: 4 / 5Workload: 18 hours / week

  • Georgia Tech Student2022-05-03T20:42:41Zspring 2022

    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

    Rating: 4 / 5Difficulty: 4 / 5Workload: 16 hours / week

  • Georgia Tech Student2022-05-01T19:13:19Zspring 2022

    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.

    Rating: 4 / 5Difficulty: 3 / 5Workload: 6 hours / week

  • Georgia Tech Student2022-04-19T19:09:40Zspring 2022

    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.

    Rating: 3 / 5Difficulty: 3 / 5Workload: 15 hours / week

  • Georgia Tech Student2021-08-11T20:27:54Zspring 2021

    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.

    Rating: 3 / 5Difficulty: 4 / 5Workload: 15 hours / week

  • Georgia Tech Student2021-08-08T15:17:54Zsummer 2021

    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...

    Rating: 5 / 5Difficulty: 3 / 5Workload: 13 hours / week

  • Georgia Tech Student2021-07-15T21:21:08Zspring 2021

    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.

    Rating: 4 / 5Difficulty: 4 / 5Workload: 10 hours / week

  • Georgia Tech Student2021-06-25T14:17:14Zspring 2021

    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.

    Rating: 5 / 5Difficulty: 3 / 5Workload: 14 hours / week

  • Georgia Tech Student2021-05-01T11:51:16Zspring 2021

    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.

    Rating: 3 / 5Difficulty: 3 / 5Workload: 15 hours / week

  • Georgia Tech Student2021-02-25T03:26:50Zsummer 2021

    2nd / 3rd class (taken with IIS)

    Rating: 4 / 5Difficulty: 1 / 5Workload: 100 hours / week

  • Georgia Tech Student2021-02-13T07:04:04Zfall 2020

    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.

    Rating: 1 / 5Difficulty: 4 / 5Workload: 25 hours / week

  • Georgia Tech Student2021-01-20T21:32:50Zfall 2020

    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.

    Rating: 4 / 5Difficulty: 3 / 5Workload: 13 hours / week

  • Georgia Tech Student2021-01-16T18:23:39Zfall 2020

    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.

    Rating: 5 / 5Difficulty: 3 / 5Workload: 8 hours / week

  • Georgia Tech Student2020-12-19T10:37:27Zfall 2020

    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]

    Rating: 3 / 5Difficulty: 4 / 5Workload: 15 hours / week

  • Georgia Tech Student2020-12-18T05:06:23Zfall 2020

    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.

    Rating: 1 / 5Difficulty: 4 / 5Workload: 12 hours / week

  • Georgia Tech Student2020-12-10T14:54:55Zsummer 2019

    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.

    Rating: 5 / 5Difficulty: 3 / 5Workload: 16 hours / week

  • Georgia Tech Student2020-12-02T04:25:25Zfall 2020

    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.

    Rating: 1 / 5Difficulty: 4 / 5Workload: 13 hours / week

  • Georgia Tech Student2020-11-25T11:40:54Zfall 2020

    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.

    Rating: 1 / 5Difficulty: 4 / 5Workload: 8 hours / week

  • Georgia Tech Student2020-08-27T17:51:44Zsummer 2020

    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.

    Rating: 4 / 5Difficulty: 4 / 5Workload: 20 hours / week

  • Georgia Tech Student2020-08-10T22:48:37Zsummer 2020

    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.

    Rating: 2 / 5Difficulty: 3 / 5Workload: 15 hours / week

  • Georgia Tech Student2020-08-09T13:30:46Zspring 2020

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

    Rating: 5 / 5Difficulty: 4 / 5Workload: 16 hours / week

  • Georgia Tech Student2020-08-05T04:34:49Zsummer 2020

    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.

    Rating: 4 / 5Difficulty: 4 / 5Workload: 15 hours / week

  • Georgia Tech Student2020-08-02T17:43:26Zsummer 2020

    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.

    Rating: 5 / 5Difficulty: 3 / 5Workload: 15 hours / week

  • Georgia Tech Student2020-08-02T10:06:52Zsummer 2020

    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.

    Rating: 4 / 5Difficulty: 3 / 5Workload: 7 hours / week

  • Georgia Tech Student2020-07-28T16:46:57Zspring 2020

    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).

    Rating: 4 / 5Difficulty: 4 / 5Workload: 15 hours / week

  • Georgia Tech Student2020-07-27T23:41:48Zsummer 2020

    **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).

    Rating: 4 / 5Difficulty: 4 / 5Workload: 20 hours / week

  • Georgia Tech Student2020-07-25T22:48:29Zspring 2020

    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!

    Rating: 5 / 5Difficulty: 4 / 5Workload: 15 hours / week

  • Georgia Tech Student2020-07-25T14:07:14Zsummer 2020

    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

    Rating: 4 / 5Difficulty: 3 / 5Workload: 12 hours / week

  • Georgia Tech Student2020-07-24T03:10:16Zsummer 2020

    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.

    Rating: 3 / 5Difficulty: 4 / 5Workload: 30 hours / week

  • Georgia Tech Student2020-07-16T15:46:48Zspring 2020

    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!!

    Rating: 5 / 5Difficulty: 3 / 5Workload: 12 hours / week

  • Georgia Tech Student2020-06-27T21:31:11Zsummer 2020

    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.

    Rating: 1 / 5Difficulty: 4 / 5Workload: 20 hours / week

  • Georgia Tech Student2020-06-27T02:43:36Zsummer 2020

    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.

    Rating: 1 / 5Difficulty: 5 / 5Workload: 50 hours / week

  • Georgia Tech Student2020-06-25T21:52:06Zsummer 2020

    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.

    Rating: 1 / 5Difficulty: 5 / 5Workload: 40 hours / week

  • Georgia Tech Student2020-06-25T18:36:09Zsummer 2020

    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.

    Rating: 1 / 5Difficulty: 5 / 5Workload: 20 hours / week

  • Georgia Tech Student2020-06-25T18:32:41Zsummer 2020

    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.

    Rating: 1 / 5Difficulty: 5 / 5Workload: 40 hours / week

  • Georgia Tech Student2020-06-24T16:04:18Zspring 2020

    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.

    Rating: 4 / 5Difficulty: 3 / 5Workload: 8 hours / week

  • Georgia Tech Student2020-06-07T19:42:00Zsummer 2020

    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.

    Rating: 1 / 5Difficulty: 4 / 5Workload: 40 hours / week

  • Georgia Tech Student2020-05-11T07:37:26Zspring 2020

    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!

    Rating: 5 / 5Difficulty: 2 / 5Workload: 10 hours / week

  • Georgia Tech Student2020-05-02T04:16:23Zspring 2020

    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!

    Rating: 5 / 5Difficulty: 3 / 5Workload: 10 hours / week

  • Georgia Tech Student2020-04-29T15:12:20Zspring 2020

    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.

    Rating: 5 / 5Difficulty: 3 / 5Workload: 15 hours / week

  • Georgia Tech Student2019-12-13T19:17:35Zfall 2019

    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.

    Rating: 5 / 5Difficulty: 3 / 5Workload: 16 hours / week

  • Georgia Tech Student2019-12-13T16:37:00Zfall 2019

    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.

    Rating: 5 / 5Difficulty: 4 / 5Workload: 15 hours / week

  • Georgia Tech Student2019-12-10T18:35:14Zfall 2019

    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.

    Rating: 4 / 5Difficulty: 3 / 5Workload: 35 hours / week

  • Georgia Tech Student2019-12-10T12:53:22Zfall 2019

    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!

    Rating: 5 / 5Difficulty: 3 / 5Workload: 9 hours / week

  • Georgia Tech Student2019-12-10T02:29:28Zfall 2019

    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.

    Rating: 5 / 5Difficulty: 3 / 5Workload: 10 hours / week

  • Georgia Tech Student2019-12-09T21:51:14Zfall 2019

    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.

    Rating: 5 / 5Difficulty: 3 / 5Workload: 12 hours / week

  • Georgia Tech Student2019-12-09T18:14:53Zfall 2019

    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.

    Rating: 5 / 5Difficulty: 3 / 5Workload: 10 hours / week

  • Georgia Tech Student2019-12-09T00:46:44Zfall 2019

    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.

    Rating: 4 / 5Difficulty: 4 / 5Workload: 9 hours / week

  • Georgia Tech Student2019-12-04T16:13:47Zfall 2019

    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.

    Rating: 4 / 5Difficulty: 3 / 5Workload: 10 hours / week

  • Georgia Tech Student2019-08-13T20:11:14Zsummer 2019

    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.

    Rating: 5 / 5Difficulty: 4 / 5Workload: 10 hours / week

  • Georgia Tech Student2019-08-06T11:27:25Zsummer 2019

    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.

    Rating: 5 / 5Difficulty: 4 / 5Workload: 10 hours / week

  • Georgia Tech Student2019-08-05T22:46:37Zsummer 2019

    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.

    Rating: 5 / 5Difficulty: 4 / 5Workload: 9 hours / week

  • Georgia Tech Student2019-07-30T02:49:50Zsummer 2019

    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.

    Rating: 4 / 5Difficulty: 5 / 5Workload: 20 hours / week

  • Georgia Tech Student2019-07-29T01:34:42Zspring 2019

    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.

    Rating: 4 / 5Difficulty: 3 / 5Workload: 10 hours / week

  • Georgia Tech Student2019-05-10T15:45:00Zspring 2019

    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.

    Rating: 4 / 5Difficulty: 4 / 5Workload: 15 hours / week

  • Georgia Tech Student2019-05-06T15:57:26Zspring 2019

    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.

    Rating: 3 / 5Difficulty: 4 / 5Workload: 18 hours / week

  • Georgia Tech Student2019-05-03T04:46:17Zspring 2019

    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.

    Rating: 4 / 5Difficulty: 3 / 5Workload: 12 hours / week

  • Georgia Tech Student2019-05-01T13:41:46Zspring 2019

    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).

    Rating: 5 / 5Difficulty: 3 / 5Workload: 15 hours / week

  • Georgia Tech Student2019-04-30T14:53:47Zspring 2019

    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.

    Rating: 4 / 5Difficulty: 3 / 5Workload: 10 hours / week

  • Georgia Tech Student2019-04-29T21:57:08Zspring 2019

    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.

    Rating: 5 / 5Difficulty: 3 / 5Workload: 5 hours / week

  • Georgia Tech Student2019-04-28T19:55:09Zspring 2019

    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.

    Rating: 1 / 5Difficulty: 3 / 5Workload: 9 hours / week

  • Georgia Tech Student2019-04-28T00:11:31Zspring 2019

    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.

    Rating: 4 / 5Difficulty: 4 / 5Workload: 10 hours / week

  • Georgia Tech Student2019-04-04T04:48:44Zsummer 2018

    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

    Rating: 5 / 5Difficulty: 4 / 5Workload: 15 hours / week

  • Georgia Tech Student2019-01-06T19:03:10Zsummer 2018

    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.

    Rating: 5 / 5Difficulty: 4 / 5Workload: 12 hours / week

  • Georgia Tech Student2019-01-02T14:52:12Zfall 2018

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

    Rating: 5 / 5Difficulty: 3 / 5Workload: 12 hours / week

  • Georgia Tech Student2018-12-12T05:39:07Zspring 2018

    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.

    Rating: 4 / 5Difficulty: 4 / 5Workload: 15 hours / week

  • Georgia Tech Student2018-11-06T07:23:30Zfall 2016

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

    Rating: 5 / 5Difficulty: 4 / 5Workload: 15 hours / week

  • Georgia Tech Student2018-05-10T15:30:01Zspring 2018

    Solid class.

    Rating: 4 / 5Difficulty: 3 / 5Workload: 7 hours / week

  • Georgia Tech Student2018-05-07T23:45:15Zspring 2018

    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.

    Rating: 4 / 5Difficulty: 3 / 5Workload: 15 hours / week

  • Georgia Tech Student2018-05-06T22:12:48Zspring 2018

    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).

    Rating: 4 / 5Difficulty: 3 / 5Workload: 9 hours / week

  • Georgia Tech Student2018-05-05T18:36:08Zspring 2018

    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.

    Rating: 5 / 5Difficulty: 3 / 5Workload: 15 hours / week

  • Georgia Tech Student2017-09-27T18:58:55Zspring 2017

    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!

    Rating: 5 / 5Difficulty: 2 / 5Workload: 8 hours / week

  • Georgia Tech Student2017-01-06T23:59:12Zfall 2016

    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.

    Rating: 4 / 5Difficulty: 4 / 5Workload: 12 hours / week

  • Georgia Tech Student2017-01-06T14:41:24Zfall 2016

    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.

    Rating: 3 / 5Difficulty: 4 / 5Workload: 15 hours / week

  • Georgia Tech Student2017-01-01T07:40:26Zfall 2016

    • 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.

    Rating: 3 / 5Difficulty: 4 / 5Workload: 14 hours / week

  • Georgia Tech Student2016-12-22T11:54:43Zfall 2016

    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.

    Rating: 4 / 5Difficulty: 5 / 5Workload: 12 hours / week

  • Georgia Tech Student2016-12-20T20:19:06Zfall 2016

    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!

    Rating: 5 / 5Difficulty: 4 / 5Workload: 15 hours / week

  • Georgia Tech Student2016-12-20T00:12:11Zfall 2016

    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.

    Rating: 4 / 5Difficulty: 3 / 5Workload: 15 hours / week

  • Georgia Tech Student2016-12-19T15:31:56Zfall 2015

    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)

    Rating: 4 / 5Difficulty: 4 / 5Workload: 10 hours / week

  • Georgia Tech Student2016-12-19T05:56:32Zfall 2016

    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.

    Rating: 1 / 5Difficulty: 5 / 5Workload: 15 hours / week

  • Georgia Tech Student2016-12-19T05:15:27Zfall 2016

    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.

    Rating: 4 / 5Difficulty: 4 / 5Workload: 20 hours / week

  • Georgia Tech Student2016-11-22T14:31:29Zspring 2016

    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.

    Rating: 4 / 5Difficulty: 4 / 5Workload: 10 hours / week

  • Georgia Tech Student2016-10-29T00:37:31Zspring 2015

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

    Rating: 3 / 5Difficulty: 5 / 5Workload: 10 hours / week

  • Georgia Tech Student2016-05-11T14:12:31Zspring 2016

    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.

    Rating: 4 / 5Difficulty: 5 / 5Workload: 20 hours / week

  • Georgia Tech Student2016-05-07T13:29:18Zspring 2015

    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.

    Rating: 5 / 5Difficulty: 5 / 5Workload: 15 hours / week

  • Georgia Tech Student2015-12-25T13:50:44Zfall 2015

    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.

    Rating: N/ADifficulty: 3 / 5Workload: 12 hours / week

  • Georgia Tech Student2015-12-18T00:14:57Zfall 2015

    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

    Rating: N/ADifficulty: 3 / 5Workload: 12 hours / week

  • Georgia Tech Student2015-12-15T13:19:01Zfall 2015

    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.

    Rating: N/ADifficulty: 4 / 5Workload: 12 hours / week

  • Georgia Tech Student2015-12-10T14:43:06Zfall 2015

    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.

    Rating: N/ADifficulty: 4 / 5Workload: 7 hours / week

  • Georgia Tech Student2015-12-09T17:43:46Zfall 2015

    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.

    Rating: 5 / 5Difficulty: 4 / 5Workload: 15 hours / week

  • Georgia Tech Student2015-12-08T16:18:13Zfall 2015

    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.

    Rating: 5 / 5Difficulty: 4 / 5Workload: 12 hours / week

  • Georgia Tech Student2015-11-05T06:00:00Zfall 2014

    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.

    Rating: N/ADifficulty: 4 / 5Workload: 7 hours / week

  • Georgia Tech Student2015-11-05T06:00:00Zfall 2014

    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.

    Rating: N/ADifficulty: 3 / 5Workload: 10 hours / week

  • Georgia Tech Student2015-11-05T06:00:00Zfall 2014

    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.

    Rating: N/ADifficulty: 3 / 5Workload: 8 hours / week

  • Georgia Tech Student2015-11-05T06:00:00Zfall 2014

    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.

    Rating: N/ADifficulty: 3 / 5Workload: 10 hours / week

  • Georgia Tech Student2015-11-05T06:00:00Zfall 2014

    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.

    Rating: N/ADifficulty: 4 / 5Workload: 20 hours / week

  • Georgia Tech Student2015-11-05T06:00:00Zspring 2015

    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.

    Rating: N/ADifficulty: 4 / 5Workload: 5 hours / week

  • Georgia Tech Student2015-11-05T06:00:00Zfall 2014

    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.

    Rating: N/ADifficulty: 5 / 5Workload: 20 hours / week

  • Georgia Tech Student2015-11-05T06:00:00Zfall 2015

    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.

    Rating: N/ADifficulty: 4 / 5Workload: 10 hours / week

  • Georgia Tech Student2015-11-05T06:00:00Zfall 2014

    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

    Rating: N/ADifficulty: 4 / 5Workload: 15 hours / week

  • Georgia Tech Student2015-11-05T06:00:00Zfall 2014

    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.

    Rating: N/ADifficulty: 4 / 5Workload: 20 hours / week

  • Georgia Tech Student2015-11-05T06:00:00Zfall 2014

    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.

    Rating: N/ADifficulty: 4 / 5Workload: 15 hours / week

  • Georgia Tech Student2015-11-05T06:00:00Zfall 2014

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

    Rating: N/ADifficulty: 4 / 5Workload: 10 hours / week

  • Georgia Tech Student2015-11-05T06:00:00Zfall 2014

    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

    Rating: N/ADifficulty: 3 / 5Workload: 8 hours / week

  • Georgia Tech Student2015-11-05T06:00:00Zspring 2015

    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.

    Rating: N/ADifficulty: 4 / 5Workload: 10 hours / week

  • Georgia Tech Student2015-11-05T06:00:00Zfall 2015

    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.

    Rating: N/ADifficulty: 4 / 5Workload: 10 hours / week

  • Georgia Tech Student2015-11-05T06:00:00Zfall 2014

    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.

    Rating: N/ADifficulty: 3 / 5Workload: 10 hours / week