High Performance Computing

Quick Facts and Resources

Something missing or incorrect? Tell us more.

Name
High Performance Computing
Listed As
CSE-6220
Credit Hours
3
Available to
CS students
Description
This course will introduce students to the design, analysis, and implementation of high performance computational science and engineering applications.
Syllabus
Syllabus
  • Georgia Tech Student2022-05-04T05:34:58Zspring 2022

    This is one of the best courses I have taken in these 2 aspects:

    1. Lectures: the videos and material are well explained and they are engaging. Also, Professor Vudoc is hilarious and he also put great effort into the material.
    2. The Labs are great, they are difficult but not extremely difficult, just start early and focus a good amount of time on it. They also have a performance score and this is the most challenging part. Finishing the code early is easy, but hitting the performance metrics could be difficult if you do not plan accordingly.

    What I did not like:

    1. Some quizzes are terrible in ED, but I guess this is a problem with the platform not being flexible enough.
    2. The exams are brutal, I guess I did pretty good in the labs but I bombed both exams, there is not enough time and the questions are several orders of magnitude compared to the lectures.

    What is missing or can be improved?

    1. The graphs lectures are too abstract and difficult to follow and there are no labs for those lectures. In my opinion, I would remove the midterm but have an extra lab related to Graphs, BFS, and distributed computing in CUDA or MPI, maybe something related to solving a large IA problem. It is very unfortunate that one of the most useful and applicable topics (graphs: VLSI design, planning, simulation, neural networks) does not have better and concise lecture videos and a related Lab that solves a real problem.

    2. Honestly Ed's discussion is not really engaging, this should be improved, there is more engagement in Slack however you are limited to seeing a limited amount of messages in the past and it is not the official channel.

    3. Most of the papers are too old and difficult to digest, with a few exceptions they are a waste of time or you will not understand them with the available time (full-time job and this course). TAs and office hours do not help that much to understand those difficult papers.

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

  • Georgia Tech Student2022-05-02T09:01:50Zspring 2022

    This is an algorithms course that teaches how to develop multi-threaded programs without using a mutex. It could also be called: High-Performance with Style!

    The course is a perfect blend of High-Work and Low-Stress. It is about the best arranged course that I could imagine, with a heavy emphasis on projects over exams. The projects ramp up nicely and are usually made up of many small parts - so if you screw up one part you can still do well overall. Lab 0 is the best introductory lab I've ever done, and should be the warm-up for the whole of OMSCS. Working template code is provided for the other labs so it is very clear what your algorithm needs to do and what output it is expected to produce. The test data is thoughtfully designed to be "predictably random", making it much easier to chase down things like off-by-one errors. Getting each part working is then relatively easy, and you can spend as much time optimizing your code as you like. Getting 90% in a lab is achievable within "expected time". Getting 95% requires "exceeding expectations time", and 100% takes "insane superstar time".

    An optional lab worth a bonus 10% of your overall grade is also provided. Only 10% to 20% of students attempt this lab, but I would recommend you try it. Our optional lab was released immediately after lab 2 (and before lab 3) so you should plan on finishing lab 2 a week early to give yourself time to complete it. It's a challenging lab with very little support, but completely doable. Unfortunately it is an all-or-nothing lab (average grade is 70%), so you could spend 40 hours on it and get 0% if something goes wrong with the hidden tests.

    The course also does a fantastic job managing the roles and responsibilities of all the TA's. At the end of every other course I've taken, I've had very little to say in the CIOS survey about the TA's because they were largely anonymous and working behind the scenes. But in HPC, ownership of the labs and the papers was very clear, and the TA owners did a great job responding to student questions. As a result, you felt a real connection with the TA's, along with a great deal of appreciation of their expertise and thanks for their work.

    I found the lecture material to be pretty theoretical (though thankfully not just a series of mathematical proofs). The professor does an outstanding job of slowly walking you through the theory, but unfortunately I personally found that the theory quickly degenerated into gobbledygook. When it came time to review my notes in preparation for the exam, absolutely nothing looked familiar. I had to convince myself that I really did, in fact, go through all the lectures the first time.

    The course starts off from where the Graduate Algorithms course leaves off - taking serial algorithms and converting them into multi-threaded algorithms (which is not nearly as easy as you might have thought). The Graduate Algorithms course uses the textbook called "Introduction to Algorithms" (by Cormen, Leiserson, Rivest, and Stein). HPC continues using a single chapter from that same excellent book, and it is clear why that book has such a fanatical following. Unfortunately, that one chapter is all the book has to offer on the subject of multithreaded applications, and so we had to transition to a second book called "Introduction to Parallel Computing" (by Grama, Gupta, Karypis, and Kumar). While the content of this second book is good, the end-of-chapter problems are insane, and the (mostly lacking) answers completely unhelpful.

    Unfortunately, the course exams are a roller-coaster and do not fit into the High-Work and Low-Stress model of the rest of the course. The practice exams handed out in advance are crazy-difficult. Given that only 30 minutes are allocated for every question, the practice questions would break down into: 25 minutes to understand what-the-hell the question is asking + 5 minutes to write an answer. Thankfully I found the real-world exam questions to be better than that. After the mid-term, we were told the average score was 36 out of 50 with a top score of 44. "Wow," I thought, "44 - I didn't find the midterm that bad - maybe I got the top score". Nope - I scored 38. So expect some sticker shock!

    There were some curious explanations about the exams. We were told that: "Exams are hard because we want to give the top students a chance to show us what they can do". But this seems weird. The projects are designed to give the top students room to shine, so why also do this with the exams? And, besides, the top students are not showing us what they can do - they barely scored better than the rest of us!

    In addition, we were told: "If you are scoring well on the projects and average on the exams then you've got nothing to worry about". But consider the translation: "If you screwed up a project or scored below average in the exam then now would be a good time to panic"!

    So I think the exams remain an area of improvement, but the course is active and improvements are always in the works.

    The course has traditionally had a reputation of High-Work High-Stress, but the workload has been eased off over the last few years. Several of the lectures are now marked as "optional" and there are now only 4+1 labs (including Lab 0 and the optional lab). In the old days, there were 6 mandatory labs with no time to study for the exams.

    In terms of course preparation, you will be doing a lot of C, OpenMP and MPI in this course, with very little pthreads and C++. While something like AOS could prepare you for the OpenMP and MPI, you really don't need it. On the other hand, this course does require a lot of algorithm complexity analysis. So if you really wanted to be prepared, then do Graduate Algorithms before you do this course. I didn't and have never really done big-O analysis before, so I struggled. But with a little extra work you can figure this out.

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

  • Georgia Tech Student2022-05-01T19:26:18Zspring 2022

    One of the best courses I've taken in OMSCS. If you are new to algorithms or to C, it might be challenging, just like some comments who disliked this course mentioned. Otherwise, take it, especially if you are interested in parallel or distributed computing.

    The videos are fun to watch and topics are well-organized. The projects can be hard if you are pursing a 100/100, if not you can spend much less time to only get it pass the correctness tests which usually accounts for 90/100 scores, without spending a lot of hours to improve the performance. The exams are hard, but can be managed if you do understand the lectures. I don't read papers or attend TA sessions at all, can't comment on those aspects, and I don't think those events are required for completing the course.

    I'm really glad I took this course.

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

  • Georgia Tech Student2022-05-01T04:52:30Zspring 2022

    I took this course in the final year of my OMSCS journey, and I think it was the right decision. To begin with, it benefits from having some experience in C, like pointers, arrays, memory management. Thus, it was very wise to take courses IOS, AOS, IIS prior to this one to build some confidence. Next, it is a good prep before GA because it trains you to analyze algorithms and complexity.
    This course gave knowledge above my initial expectations, since it provides in-depth cases of memory efficient, parallel and distributed computing.
    From my experience, it wasn't a time sink with workload similar to pretty much any course I have taken so far. With that said, I tried to be efficient and put just enough effort to score at least 85% in labs. TAs are great and experienced, and it is rather a small cozy class; You will remember names of people posting in Ed.

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

  • Georgia Tech Student2022-04-24T02:57:20Zspring 2022

    This is an algorithms class. You learn about algorithms with respect to systems that have large amounts of processors or are processing large amounts of data. Then the projects have us implement some of these algorithms and run them on the GT supercomputing cluster. Neat class, I thought it was executed well with helpful TAs and lectures that did a good job of breaking down difficult topics. The topic is a bit niche but I think the ideas it touches on are going to be relevant to the computing industry as computing clusters get larger and larger.

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

  • Georgia Tech Student2022-04-23T18:43:35Zspring 2022

    My Background: work as full time developer/software engineer at tech company in the industry about five years.

    Why I choose the course

    • it has good rating on OMSCentral. Most people like it.
    • I review syllabus which covers many interesting topic that I would like learn more

    But after I enrolled into the course, I really find myself strongly dislike the course based on below reasons:

    • The are some errors and typos in course videos, even algorithm is not correct in some video lectures, which is very misleading and frustrated for student to understand.
    • Labs: It lacks of requirement description. So As as student, after you read their project description, you don't know what is required to implement and what the expected result looks like. You must read through their test code to understand what is required to implement, which is not quite good for the design of labs. Furthermore, when you tested your code on their provided cluster, it sometime will be nightmare. If there are too many people testing the code at the same time, it generates some weird errors and TA doesn't know how to fix it.
    • Video is lack of explanation in details. Many algorithm and computation analysis in the video directly gave the results without many mathematical derivation or details analysis. And some explanations for algorithm is very hard to understand especially when professor didn't gave many details explanation.
    • Quiz in the video lecture is misleading if you use quiz/lectures to prepare for the exams. Questions in the exam are mostly like questions and answering. But quiz in the video lecture emphasized computation and writing pseudo code for some algorithm which may gave wrong direction when you prepare for the exams
    • Paper: It is very nice to hold paper discussion session weekly. But personally I felt like many papers focus on theory and hard to understand especially if you don't have many such theoretical and research background for parallel computing.

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

  • Georgia Tech Student2022-04-19T19:08:00Zspring 2022

    Lectures were excellent! Prof Vuduc is very funny and entertaining! The material was interesting and the projects were very challenging but doable.

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

  • Georgia Tech Student2022-03-18T02:11:56Zfall 2021

    Mixed feelings overall about this course. The video lectures are just okay. I was hoping the content would be more focused towards practical applications in the modern tech world.

    The staff was not very helpful and it almost seemed like they look down upon you just for being a student. Yikes! Definitely not a welcoming feeling for you as a student.

    I ended up dropping after the first project besides the warmup.

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

  • Georgia Tech Student2021-12-24T01:32:31Zfall 2021

    This was my third course in the program. It is a very good course, to put it simply. The lectures are informative and the prof keeps it moving and fun. The material is covered with what I believe to be mid-depth, not too deep, and not too superficial. The labs are powerfully educational. It is very difficult to do well on the labs without knowing what you are doing, and knowing what you are doing means understanding how to write efficient parallel algorithms. That is what I set out to learn, and I was taught it well in this course.

    The exams are very challenging. The midterm was fair and if you literally studied all of the material given it was possible to do well. I watched all the lectures twice (once sorta on schedule and again on double-speed to study), read through the papers, did all of the practice questions, then reviewed the solutions. The first paper was way too thick and I barely understood any of it. If I read it again now, maybe I'd understand it more. The rest of the papers were much better. One of the exam questions was straight from one of the readings...so take seriously the suggestion to do the readings. With that said, there will probably be little bang-for-your-buck in reading the papers beyond a cursory understanding (at least in terms of prepping for the exam). I ended up with a good score on the midterm with the approach I just mentioned. The exam made me sweat but the graders were fair.

    The final was a different story. They threw wham-bham-thank-you-ma'am curveballs at us - including a question covered in what seemed like optional lectures/readings from before the midterm. I went through every question and did the whole "I'll go back to this one" thing for all four. I sweat it out, gave my best answer to each, had to go back to the optional material, and ended up with a good score. My studies for this were similar to the midterm, but I studied for the midterm for a week and a half and only gave the final about three days. Also got sick and took cold medicine the last day of the exam/when I had to take it. That was fun. I will say this ------ there is little substitute for developing intuition through rigorous study and practice throughout this course. I was able to do well on the final, I think, because my intuition for the material grew to a point that I could get pretty close even without understanding all of the details.

    Grading was especially generous. 83.5% for an A. 74% for a B. 64.5% for a C. There was a 5 point (10%) adjustment for the midterm and a 7 point (17.5%) adjustment for the final, plus a 5 point (12.5%) extra credit question on the final. It is straightforward enough to get at least a 90% average on the projects. The final + midterm (combined) = 35% of your grade. That means you could've gotten a 71% on the exams (after the adjustments) and still gotten an A if you got 90% on the projects. All that to say, please do yourself a favor and take this course even if you are concerned about the exams being hard. It's well worth it and totally doable.

    Last comment: As always, get active on Slack and Ed. Some of the fellow students and TAs were real lifesavers and made it feel like a community.

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

  • Georgia Tech Student2021-12-13T22:59:11Zfall 2021

    I consider the content to be must-know material regardless of your specialization, so that alone is why you should take this class. The class itself is good enough not to be a deterrence.

    It feels like it's still a work in progress. They've been slowly restructuring since new staff took over a couple years ago. I think it's better than it was in the past but still has a way to go. For example, performance scores used to be always competitive, but they made benchmark implementations to beat instead now for the labs #1 and #2. The first month we did almost nothing, and by the end we had a lot of things due in short-ish succession. So it was very back-heavy.

    The exams are so brutal because each question is written by one of the rank-and-file TAs, but they make up for it with generous exam/semester curves. They govern the labs the same way, but those are more mature because they don't have to write them from scratch every time. Go all out on the labs to carry yourself through the exams.

    They've reduced the number of required labs by 1-2, which helps. It would be better if they focused more on the theoretical side. TA staff if you're reading this you should:

    • Have more time and discussions around the written homeworks.
    • Maybe even grade some of the written homeworks, so we have with-stakes practice before exam time.
    • Shift the schedule to the left a few weeks to create more space.
    • Consider dropping lab #2 to allow more time for theory.

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

  • Georgia Tech Student2021-12-10T05:02:47Zfall 2021

    Cool class. Challenging, but not overly time consuming. Very little fluff - short dense lectures, fun labs, and two exams. Some aspects of the pacing were nice (slow build-up, lecture/reading free weeks around exam time) but I actually wish there were one more lab or the EC lab they provided was not jammed into the schedule with another lab and a holiday week. TAs and co-students were great. Be comfortable with C and come in curious about parallel algorithms.

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

  • Georgia Tech Student2021-12-09T23:17:54Zfall 2021

    Probably unpopular opinion here. I have a so-so experience regarding this course. I think this course is overrated, partially because this is a hard course, we work on the assignments all the time while forgetting to actually thinking about what do I really want out of this class.

    I won't list pro's here, I think other reviews covers most of them already. I'll only list con's here, just to give some perspective.

    1. TA's are not very responsive, other than the office hours. It's a few days wait to expect some answer from them, and usually the answer is not what I asked. The labs are quite hard, while I understand we should spend our personal efforts on it, however, when we have questions to ask, the answer is usually super vague, like nothing, not very inspiring. I learned nothing from TA's.

    2. As a new student in this area, I don't understand how good the Georgia Tech PACE cluster is. The labs are mostly performance based. It has to be run on PACE. The thing is, I tested my code on my computer, doing great, then on PACE it is not as good as my personal computer. The answer is that PACE is where grading is based, you have to make your code perform good on PACE in order to get scores. The lab results vary dramatically on PACE. This is the worst part of this course. I have to waste a lot of time to make sure my submission is good enough.

    3. I just feel there are so many gaps between lectures and labs. It's like I'm taking two classes at the same time. It would be better if there are several graded assignments on theoretical stuff, not just on random performance coding stuff.

    4. Exams are a different story. I wish there could be related graded assignments similar to exams, instead of "optional" homework. It would be much much better if one lab is replaced by grading homeworks.

    5. Back to TA, I really want this course to have TA's communicate more.

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

  • Georgia Tech Student2021-12-07T21:45:00Zfall 2021

    This course provided a great introduction to C and parallel algorithms. The course consisted of 5 C labs that covered OpenMP, OpenMPI, and CUDA. Three of the labs focused on OpenMPI, but I would have preferred more exposure to openMP and/or CUDA/openCL. The main time consumer for the course was the labs, especially if you want full performance points; expect 1-2 days for each lab to get full correctness points, but a week per lab if you want full performance points. Lectures provide a decent overview of the topics covered, but sometimes can feel a little too distracting with puns/jokes.

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

  • Georgia Tech Student2021-12-04T14:14:43Zfall 2021

    I have not received the grades, so my evaluation is unbiased ;)

    Take the class only if:

    1. You know C.
    2. You want to learn ways to attain speedup and performance of programs.
    3. You have a knack for translating algorithms to code.
    4. You know how to read academic papers and skim out useful information.

    This class really helped me in my system-design interview (along with others i.e. GIOS, AOS).

    Good Luck!

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

  • Georgia Tech Student2021-08-19T14:42:49Zsummer 2021

    The lectures were well put together. The labs were fairly straightforward but were the bulk of time spent in the class. Correctness was typically about 70% of the grade, with performance being 30%. Only one lab was graded against peers instead of against predetermined levels. Getting at least 90% on the labs is fairly doable within about 1.5 hours of work after finishing correctness, but 100% could be many, many hours. Between labs and lectures I spent about 16 hours per two weeks, doing the labs just before they were due. I don't recommend that schedule, but advise having energy drinks on hand if doing the same. The course vm was good and allowed local development except for the gpu part of one lab.

    The tests were very hard, but were given a flat curve of about 9%. Some of the difficulty came from ambiguity. The piazza forum was not particularly active because there is no participation incentive, but it was also temporarily closed for the whole test window. I would encourage future students to study collaboratively before the test window starts. The ungraded homework assignments were good practice for the exams.

    I mainly skipped the office hours, paper talks, papers, and readings. The recordings were not linked from the piazza posts, so I didn't realize I could access them through the canvas sidebar. I would encourage other students to do these things, since they might make the tests a little bit easier.

    There was a very large curve on the final grade. An 81% was an A, 68% B, 55% C, 42% D. No details on the curve even existing were announced at the start or middle of the class, only after the final. The curve appears to be aimed at half of students getting an A. There was a 10% extra credit assignment available, but that might not be typical. A perfect grade would have been 113%. One no-penalty late assignment is allowed. Subsequent late assignments receive a 0. Both tests were available for a little less than a week.

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

  • Georgia Tech Student2021-08-17T05:44:17Zsummer 2021

    6th class (AI4R, HPCA, IIS, GIOS, SAD)

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

  • Georgia Tech Student2021-08-12T23:26:34Zsummer 2021

    My background: No-CS undergraduate, who has 15 years in the software industry. Knows languages from assembly, C/C++, Java, Scala, Cobol. Have taken AOS, Compiler, HPCA, Infolab: BE before taking CSE-6220

    Firstly, I know there are a lot of people who saying they learned a lot, but below is my observation

    Mr. Vuduc is a truly knowledgeable professor. But the problem for this course is the concept for this course is old, we're still using a textbook that was published 2 decades ago. We never got a chance to know the latest update on the parallel computing world.

    The setting for the course covers a lot but not too deep. I guess Mr. Vuduc wants to leave this for reading but as you will see in my later discussion it's not enhanced at all. Mr. Vuduc has a powerful sense of humor, but the problem is for ESL students I don't capture most of the points. I'd rather we can focus more on the real topic.

    Unlike other courses that have office hours where you can reach out to the professor, the whole class was driven by TAs. Which causes a lot of problems.

    1. Most of the time people just randomly chat during office hours or paper discussion, TAs would read papers at paper discussion, which I think it's not help too much.

    2. There are no criteria for the exam. TAs give make-up points if many people don't score well, this makes me feel there is no rule at all. The quality of exams is so bad, they have a lot of ambiguities. For me, it does not work to measure people's performance.

    3. Speaking of labs, lab zero is more like a prerequisite, which leaves us with 3 labs and one extra lab. TAs were inattentive scoring, which means students need to be incredibly careful on the score because you might get wrong scores in any case. Also, TAs don't read code. Which makes them make some obvious mistakes.

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

  • Georgia Tech Student2021-08-05T17:33:43Zsummer 2021

    This is a good intro parallel/distributed algorithms class, and it adds perspective to serial algorithms.

    Programming is done in C. I suggest to take this before or after GIOS and before AIOS.

    Labs are easy (lab0) to medium/medium-hard (lab1, lab2, lab3) to get decent grades. The final lab has 30% of score based on performance ranking among class, a little high IMO but makes for competition and open-ended difficulty.

    Exams are difficult but allow open book, notes, etc. They are text-box algorithm/pseudocode and analysis, generally following information from the lectures. Optional homeworks are provided before the exam that you absolutely should do to prepare.

    The summer semester is good time to take this, depending on how tight your schedule is. Instructor and TAs were helpful.

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

  • Georgia Tech Student2021-05-25T00:01:14Zspring 2021

    1. Background

    • Education:
      • Bachelor's of CS (2019) from a top Canadian university
    • Work:
      • currently working full time
      • software developer YOE: 2 years (mostly with C++)
      • current work tech stack: primarily C++, a bit of Python, Linux/Unix
      • industry: quantitative finance at a big bank
    • Previous OMSCS course:
      • GIOS (Fall 2020)
    • This Term: Spring 2021
      • Second term of OMSCS
      • working full time
      • only took one course
    • My Relevant Experience
      • Took Algo as an undergrad, did poorly
      • Have worked with C++ for the last 2 years, so I am familiar with working with pointers and memory, as well as C-style syntax

    2. Review

    1. Difficulty: 10/10 This course is relatively hard if you want an A. If you have not taken an algo course before, and/or are not comfortable with programming in C in a Linux environment, the assignments will be a big challenge.

    The assignments are difficult mainly due to the two tiered grading. Usually 50-70% of the grade is for correctness, and then 30-50% of the grade is for optimization/speed. Getting the correctness marks is not too difficult, often with pseudocode in the lectures to guide you. However, getting full or good performance marks takes just as long as the first portion.

    The exams are very difficult. Open book, open internet, but it wont help much. Usually 4-6 questions with one bonus question. Doing the practice exams will give you a feel. Most of the questions will invovle giving an optimal, efficient algorithm, along with some basic time complexity/cache complexity/parallelization analysis. Don't spend too long on a single question, and make sure to attempt all of them.

    2. Time Commitment: 8/10 If you want to cover all the course content, this course will be very time consuming. Between the long assignments and lots of papers, it will be very time consuming. However, if you only watch the course lectures and are not aiming for 100% on the assignments (that is to say, are happy with a B), I think this course is less demanding.

    Lectures: very entertaining and interesting, no more than 1 hour a week commitment

    Papers: there are a lot of papers to read (almost 1 per a week). You can probably get away without reading any

    Assignments: this is the biggest time sink. I spent half my time getting the correct answer and the other half trying to optimize.

    3. Quality of Instruction: 10/10 The modules were well recorded, informative and digestible. I feel like it covered a good breadth of content and I came away learning a lot.

    4. Usefulness: 10/10 One of the most useful classes I have taken in all my CS education. The approach to parallelism, discuss about caches and other high-performance computing topics should be applicable to everyone in the software industry at some level.

    3. Overall Thoughts

    HPC was challenging, engaging, informative, and worth it. I feel like this is a great course to take, for a good balance of theory and application of parallelization and high-performance computing.

    For refnerence, I ended up with ~86% (A) in this course, scoring 90-100% in each of the assignment and roughly ~70% in the exams. I also watched all the lectures, but barely read any of the papers. I was aiming for an A, therefore invested a lot of time in the course (20-30 hours per week).

    I completely agree with the majority of OMSCS students. I think this course is well-ran, with great content and engaging assignments. I think this course is a must-take and you will end up learning something useful regardless of your experience.

    TL;DR difficult and time consuming assignments, but worth it. very useful content. 10/10, would take again

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

  • Georgia Tech Student2021-05-21T21:20:20Zspring 2021

    Summary

    • With multi-core processors the new standard, I think anyone with an interest in advancing their algorithms knowledge would benefit from taking this course. If algorithms aren't your deal, perhaps consider HPCA if youโ€™re more interested in the hardware side of things (as the TAโ€™s recommended โ€“ I cannot speak from personal experience).
    • I think the review posted on 1/15/21 is very accurate (well, they claim this is the best course in the program โ€“ Iโ€™m still too early to defend or deny that!) and a bit more brief.

    Course Format

    • Make no mistake: this in an algorithms class: a parallel algorithms class.
    • While this is an algorithms class, the labs consistent of the majority of your grade (65%), while the exams take up the rest.
    • Pre-Reqs:
      • You should feel comfortable coding and debugging in C or C++.
        • I list this first and foremost as the labs are the majority of your grade, and labs are graded on not just being able to scrape together the algorithm, but also being able to implement it such that it runs quickly. Your knowledge or lack thereof of efficient C programming will directly translate to your grade.
      • You need a basic understanding of CS algorithms framework, big O notation.
      • Linux command line interface knowledge is very helpful. Itโ€™s needed for the course but possible to quickly pick up at the start of the course (as I did)
    • You can get ahead on material but the Labs are not released until 3 or 4 weeks before they are due.

    Instructors

    • Very knowledgeable TA's who put in a ton of time to facilitate learning, with 2x hour long office hours each week.
    • TAโ€™s are active on Piazza, but not perfect โ€“ some questions would go totally unanswered.
    • Instructors are consistently working to improve the course by shifting the order of materials and updating the Labs, which makes the class materials that much more current and effective. This term there was a very helpful new intro Lab on how to use valgrind.
    • I do wish Professor Vuduc could have been somewhat involved in the course of the term. He responded a handful of times on Piazza and that was it. It would have been nice to have him attend at least a couple of the office hours, instead of being given the excuse that another class is his priority.

    Course Materials

    • Very engaging and well-constructed lecture videos. The lecture style is generally very succinct yet rich with content.
    • CS algorithms arenโ€™t any strong passion of mine, but I still found myself excited to watch the next module of videos, usually replaying them to make sure I internalized the concepts.
    • Some textbook readings and many literature articles are required reading for the course. You need a high-level understanding of all of them in order to do well on possible exam questions on them. The TAโ€™s can help in comprehending them as they are not easy reads. I didnโ€™t find the readings particularly useful in helping me understand the concepts.

    Labs

    • Lab topics included cache locality, parallel list ranking using OpenMP and CUDA, implementing distributed collectives in MPI, and parallel sorting. Labs were all in C.
    • The labs are structured to where you can get the majority of credit by correctly implementing the algorithm, while full credit requires meeting speed benchmarks set by either the instructors or competing against your classmates.
    • They are not easy and took me 40-50 hours+ each, but almost all of the concepts are sourced from the lectures. The format is inherently challenging because you can almost always improve and optimize.
    • Labs are all graded on the GA Tech instructional supercomputer cluster. If, like me, you had zero experience using Linux command line, setting up a virtual machine, sshโ€™ing over a networkโ€ฆ be prepared to teach yourself all of that in the first few weeks of the course. Donโ€™t get me wrong โ€“ itโ€™s good stuff to learn and the TAโ€™s will answer questions, but be prepared. You donโ€™t want to be spending hours just getting your environment set up or getting connected to the cluster heading into a Lab deadline.
    • A frustrating experience for both students and TAโ€™s seemed to be the variance of the performance metrics on the cluster used to evaluate code. In student testing, code would perform faster or slower at certain times, or would perform differently when graded by the TAโ€™s. Generally the TAโ€™s were very gracious โ€“ running labs multiple times and taking the best result. Students can also request regrades of any lab with no penalty (except if the regrade happens to perform worse). But every lab there were complaints about this. Iโ€™m not really offering a solution, just be aware of it going into the course.

    Exams

    • Two hours with short answer questions applying the concepts of the class to new contexts. Questions about designing parallel algorithms, writing pseudocode, or analyzing an algorithmโ€™s complexity or runtime. Open book, open notes, open internet (except copying direct answers, or collaborating with others) which of course meansโ€ฆ
    • They are brutal. Means around 50-60%. I did not do very well on them. Luckily they were somewhat curved and the course grade cutoffs were generous: 83%+ = A; 72%+ = B; 61%+ = C. Cutoffs vary by semester but are historically somewhere in this area. Because I did well on the labs I was able to just barely grab an A.
    • To prepare, old exams and solutions are provided. This helps to be familiar with the format and difficulty youโ€™ll likely experience. Unless youโ€™re familiar with the materials before taking the course, I would highly recommend re-watching ALL relevant lecture videos prior to the midterm and the final. You really have to know the material inside-and-out in order to do well.

    Review Context

    • This was my first semester in the program, and I did not have a strong academic background in CS or relevant work experience. Going in I had basic experience coding in C++ and undergrad level algorithms knowledge. I decided to enroll in this course to challenge myself in a subject I was unfamiliar with, and to become more well-rounded in my CS knowledge. It was also one of the few classes I was interested in that wasn't already full. I say all this to preface my personal difficulty rating and average time spent per week; in short: your mileage may vary!

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

  • Georgia Tech Student2021-05-01T23:22:14Zspring 2021

    One of the most fun courses in OMSCS. The labs can take a long time to complete, so start early! Similar to other reviews, the initial implementation of the lab is usually not too hard, but the bulk of the time will be spent optimizing and getting the algorithm to run faster and faster. One of the great things I found about the lab was that it really helped me understand the concepts from the lectures deeply.

    The exams were fair, although it was hard to determine which parts of the lectures would be on the exam. Doing the past exams definitely helped.

    The TAs were amazing, and spent a lot of time helping the students with problems, getting through logistics of running on the cluster and giving enough hints to push us along.

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

  • Georgia Tech Student2021-03-28T07:12:14Zspring 2021

    This is my first OMSCS course, I took it with CS 6340. I have to say I don't like this course. The videos are helpful and essential to do the labs. However, I cannot solve midterm questions and I have no idea what should I do. The sample midterms have solutions but rarely have explanations. I found that I am not able to fully understand what this course is about and don't have any confidence that I can design parallel algo at work. TAs are not very helpful. When I ask for feedback on my lab no one gives me feedback. Very depressive

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

  • Georgia Tech Student2021-01-15T17:14:34Zfall 2020

    In a nutshell, the best course in the program. If algorithms scare you, you probably shouldn't be pursuing a Masters in Computer Science. If they do scare you, then don't take this course, although this course is anything but a dry approach to algorithms.

    A course like this adds value to the OMSCS degree in a way that few courses do. The professor is knowledgeable, likeable, witty, and down to earth. The TAs are helpful, competent, and generally available. Videos are top notch quality and show an attention to detail not seen in any videos elsewhere in the program. Courses like this do not exist outside of academia, so you simply can't youtube your way to an in-depth understanding of HPC concepts.

    The math is doable, getting a little thick from time to time but generally understandable. The projects are interesting.

    You will be running your project code on the PACE cluster. While you can code for correctness locally, all projects are performance-based. This means that you will be graded on how quickly your algorithm completes both known and unknown test cases. Your local 32GB of RAM and 16-core CPU won't give you an accurate performance score, so you will need to use the provided cluster. One negative was that the cluster went down a couple of times as one project's deadline approached.

    The midterm and final are generally epically tough. You have 25-30 mins per question and open notes/internet/world, but the average being around 50 should hint at how difficult they tend to be. Still, with only 35% of the grade on these tests, you can swing a B easily, if you make 25-50 on the exams, and get 90-100% on the projects. Getting an A is very doable if you can manage reasonable test scores.

    Practically, your job most likely does not require you to be able to compute a list rank on (or sort, or etc..) a multi-million element list in sublinear time. But there are quite a few practical takeaways from this course. It will open some new doors in your mind on how to approach algorithms.

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

  • Georgia Tech Student2020-12-18T05:50:52Zfall 2020

    tl;dr Don't take this if you don't dig algorithms.

    This course might not be for you. It wasn't for me.

    That's not to say it wasn't a high-quality course. It was. The TA's were knowledgeable and quick to respond. Prof. Vuduc clearly loves his work, and he was engaged and responding to questions as well. The course material was up-to-date, and typos and bugs were recognized and fixed quickly (a truly rare thing in OMSCS that I've come to appreciate). Grading was prompt, predictable, and lenient. Altogether it was rivaled only by GIOS in terms of quality and effort.

    Like you, I read all the positive reviews here on the site and thought this would be a perfect last course in the OMSCS program. It wasn't until a week after the drop deadline that it really kicked in that it wasn't for me, and by then there was zero chance I was going to withdraw and postpone graduation another term.

    This course is inherently about running algorithms in parallel. That's it. So if, like me, you grit your teeth through the required algos course and find this kind of material deeply boring - this course will be no better than the "serial" algos course. In fact, it might be even harder to bear because it's optional. Worth emphasizing: that is no fault of the course itself and the staff probably made it as bearable as it could be.

    Besides trying to hold my eyelids open through the lectures, this was actually a fairly easy course - I came out with a high A with limited effort. I didn't learn much, and it doesn't take much time to not learn much. By the time I realized that I was stuck in this course, I resolved that a C would be okay, and since it's curved that was something like a 60 percent.

    The labs took a decent amount of time, only because I write C like I would never write production code - no tests, dive-right-in, oh-man-everything-is-broken-how-do-I-debug-printf-printf-printf. But they weren't particularly tricky, and only one of them (this term) was king-of-the-hill, curved-against-your-peers style. With 10-20 hours on each I got 100's, only losing a few points on the last one because someone had a faster program.

    I can honestly say, too, that the exams weren't hard - but that's (a) not because I'm particularly smart and (b) not because I studied hard (I didn't). I saw people on the forums diving much deeper into the material than I did. I tried to read some of the papers but my eyes glazed over quickly; I watched most of the lectures but some of my notes are literally just me complaining about being bored, watching the same segments 3x until I gave up and moved on. I only discovered the course textbook an hour before the midterm.

    The exams weren't hard - because I took the right approach. Both had 6 questions, and prior to both we were given 4 previous exams with "solutions" which were sometimes only partial solutions. However, they showed what the "shape" of a right answer looked like, and I just waved my hands enough until my answers looked like that shape. I suppose this is what being an artist feels like. What also helped is that on the first exam, 3 of the questions were derived from previous exams. One was exactly the same algorithm, and I cited that in my own answer and then basically copy-pasted (although not literally copy-paste since that's disabled in the exams). Full points. Bingo. Another question was nearly copy-paste out of the textbook (that I quickly ctrl-f'd through in a mad scramble to write something down).

    Another question I had zero idea how to solve, but I wrote all the "shell" pseudocode that one might write when you have a deadline but you don't know how you're going to do the hardest part. It was basically the equivalent of South Park's "Step 1. Collect Underpants 2. ??? 3. Profit". In the middle I wrote nonsense code with a comment explaining how I ran out of time (which was true). How many points did I get? 8/10 IIRC. Sweet.

    Not a single of the 12 exam questions was I confident in my answer, but that didn't keep me from getting about a 75% on each pre-curve which became a 90% each post-curve.

    All that being said, I do have a slightly improved understanding of how to scale algorithms beyond a single processor (there are some clever tricks), and I can say some of the right words at a CS cocktail party if that's a thing.

    The CUDA assignment (Lab 1) was also very eye-opening and will likely pay off in my professional work. I'm glad I did that.

    I'm very thankful the teaching staff was so invested, and I could tell that much of the class really took the material to heart. If algorithms are your thing and 2 hours of lectures about sorting a list or partitioning a graph sounds like a great time to you, then this is your course!

    But if, like me, you prefer the concrete to the abstract - don't be wooed by the siren songs of supercomputing and the high ratings you see here. A well-taught course in something you don't enjoy is still not something you'll enjoy!

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

  • Georgia Tech Student2020-12-14T17:04:06Zfall 2020

    This was by far the most rewarding, and even fun, class I've taken in OMSCS out of 9. The class is broken up as follows:

    ๐‹๐ž๐œ๐ญ๐ฎ๐ซ๐ž๐ฌ: The class is broken up into 3 main topics. Two-level memory (Caching, I/O). Work-Span Model/Shared Memory, and Distributed Memory. You will have to learn different APIs on the fly (which isn't that bad, but be prepared to lookup documentation). There is no grade for finishing lectures, but you should watch them, as they are the best, and possibly most enjoyable, lectures in the program. Professor Vuduc has the gift of teaching.

    ๐‘๐ž๐œ๐จ๐ฆ๐ฆ๐ž๐ง๐๐ž๐ ๐‘๐ž๐š๐๐ข๐ง๐ ๐ฌ: Papers, some of which you will have to implement described algorithms from in one of the labs. These are actually mandatory, as their topics are fair game on the exams. Most of them are very dense, so try your best to scan relevant information from them without diving too deep into the specifics.

    ๐‹๐š๐›๐ฌ: The majority of your grade. If you want an A, you must do well on the labs as they are 65% of your final grade. You will mostly be using C/C++ and C++ parallel libraries such as OpenMP, OpenMPI, and CUDA. That's right, this semester was the first time a lab used CUDA, and it was very rewarding to be able to write a GPGPU program that can give upwards of 15-17x speedup. Each project has a correctness score (which is typically pretty easy to max if you start early), and a performance score (which is where you will spend most of your time). You will be graded on how fast your code runs on the class PACE cluster, which is notoriously finicky. START EACH PROJECT EARLY! Getting an A will depend on if you are hitting the performance targets consistently. The first three labs have well-defined timing cut-off targets to hit, while the last lab's performance score is scaled depending on how the other students perform. The curve was pretty generous for our class however.

    ๐„๐ฑ๐š๐ฆ๐ฌ: Weighing in at 35% of the final grade, these are open-everything (except sites where you can communicate) exams which are HARD. Past exams with solutions are given, but memorizing the solutions won't get you far. You should actually attempt to answer all of the questions before you look at the solutions. Even if you have a mathematics background these exams can be brutal (~60% class average on both) as the time limit always seems to be too low for the amount of questions on the exam. Keep your recommended readings handy as sometimes they can be a crucial device even during the exam. (You are allowed to look them up on the internet, or have them printed out during the exam). The good news is, the exams get curved depending on the overall class performance, but if you are aiming for an A you will want to beat the class average on both the final and midterm. (It is still possible to pull an A with the exam averages, but you must basically ace each lab).

    ๐Ž๐ฏ๐ž๐ซ๐š๐ฅ๐ฅ: The final grade may or may not be curved depending on how the class performs as a whole. But overall I would say the grading is very fair. I spent probably 20+ hours each week on average between reading papers and watching lectures, and working on the labs. This jumped up to 30-40 hours near lab deadlines. There is no ceiling to the amount of time you can spend optimizing your algorithms, so browse the Piazza pages, and Slack channel to see how others are fairing to get an idea of where you can stop. The Piazza and Slack channels are pretty active, as well as the TA responses, use those, and you will do fine. Overall this is one of the best courses in the program and I highly recommend it.

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

  • Georgia Tech Student2020-12-14T16:28:22Zfall 2020

    This is essentially an algorithms course, but focusing on performance and parallelism.

    • Prerequisites: While OMSCS courses don't formally have prerequisites, you absolutely should not take course unless you have already taken a graduate level algorithms course and a course with C/C++ programming.
    • Projects (Labs): These were extremely challenging and fun. Expect to spend 20+ hours on all of them (except for the first). All of them involve implementing an algorithm from the lectures/readings, running it on the cluster, and tuning/tweaking to improve performance. This semester had CUDA for the first time which was great.
    • Exams: The worst part of the course was the exams. They are open-book with questions that require writing psuedocode to make parallel algorithms. If you study the lecture material and do a few past exams, you should be able to get the class average or above. The class average might be low, but they will curve and adjust it in the end.

    Overall a great class if you want a challenge and to learn some practical skills. Professors and TA's are responsive on Piazza and will give private help.

    Note: There is a review from Summer 2020 for this class that is a mistake. This course was not offered in Summer 2020 and I think that person meant to review HPCA.

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

  • Georgia Tech Student2020-12-13T23:00:04Zfall 2020

    This was the most rewarding and enjoyable course of the 6 I have taken thus far (others were ML, RL, DVA, AI4R, CN). I highly recommend it! I found the programming labs to be some of the most fun assignments in the program. I also appreciated the new lab section that used CUDA. The labs involve both getting a correct implementation of a parallel algorithm to solve the given problem(s) and optimizing performance to achieve a certain speedup threshold or make your program as fast as possible. The exams were quite challenging, but the teaching staff provided old midterms and finals with solutions to study from. The exams were open-book and open-internet, but still difficult. The best way to prepare is to make sure you have a good understanding of the material in the lectures and do your best to solve the problems in the practice exams without referring to the solutions.

    The teaching staff was effective and very responsive on Piazza. There were some issues with data center stability/availability during lab 1, but the teaching staff adjusted appropriately and gave due date extensions. One thing I noticed is that Piazza seemed a bit quieter than in my other courses. This may be due to the relatively small class size 150 students starting out and ~125 sticking with it after the withdrawal deadline.

    In terms of preparation for the course, I would recommend

    • C: this course did not require a broad knowledge of C, however, you definitely need some experience and comfort level with handling pointers and pointer arithmetic as well as debugging issues with pointers
    • Data structures course, algorithm design and analysis - complexity analysis, sorts, greedy algorithms, divide and conquer, basic graph algorithms
    • Some basic linear algebra knowledge

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

  • Georgia Tech Student2020-12-11T05:17:32Zfall 2020

    Seeing that this was the highest rated course on OMSCentral, I signed up for this class with exceedingly high expectations coming in.

    It wasn't a bad experience, but overall this class wasn't any better than any other class I took so far.

    The first half of this class was probably the best. The 0th lab (first assignment) really intrigued me by making me realize that you can rewrite plain C code to run faster. I thought you had to be a systems programmer with deep knowledge about compiler optimizations in order to make it work. But you only need a general awareness of cache and slow memory to get the desired speedups (I still don't fully get why my code is faster, just that it is somehow). It helped me realize that the computer architecture somewhat affects performance.

    The first lab was also really cool because it introduced us to CUDA. It was really interesting, but I highly doubt I will be able to use CUDA in my real job anytime soon.

    The second and third projects were fair, but dry. The main problem is that speedup is hard to figure out. You can easily spend days on improving the code and not see any speedup (or even slowdown), which is what happened to me on both projects. The TA's don't really provide any hints on what can be sped up, so I felt stuck and hopeless for many days for each of these two projects.

    The exams are just plain stressful. The questions are very lengthy and the provided solutions are vague. It takes a great deal of effort to just get a high level of understanding of a solution. And there are so many practice problems to digest, that I felt it wasn't worth the effort.

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

  • Georgia Tech Student2020-12-06T09:21:29Zfall 2020

    If I was to describe it simply, Iโ€™d say IHPC is like GA for parallel / concurrent algorithms, but with a heavier focus on the practical side with substantial labs.

    I believe this course is a must take if you are doing the computing specialization. I learned so much in this course - probably more than any other course so far in OMSCS (itโ€™s my 8th class).

    Pros

    • Labs are the best part of the class, and possibly the best in the entire program. They are very substantial so be prepared - make sure your C is sharp. These are harder than any other lab in the program. For example, where AOS has a single barrier MPI project, the MPI lab in this course has you implement 8 different collectives and performance tune them! The CUDA lab and terasort labs were my favorites.
    • Professor Vudac has a great sensor humor, and his lectures are very enjoyable to watch. The only issue I had is they can be quite light on details sometimes, so be prepared to spend follow up time understanding them.
    • The material is very interesting and relevant to most software engineering positions. Even if a lot of it was MPI, Iโ€™m confident Iโ€™ll be able to apply the concepts to my professional work.

    Cons

    • Unfortunately Professor Vudac was mostly absent this term, albeit with a few piazza posts, due to his teaching obligations for CSE-6040, an OMSA course with 1000 students in it. Fortunately the TAs did a pretty good job I felt of covering the class.
    • The exams are brutal and can feel unfair as nothing in the class really prepares you for them. The midterm was basically 6 GA style questions, but for parallel algorithms, squished into 2.5 hours. There is virtually no preparation for them either. The lectures don't even begin to prepare you for the kind of hard math type questions on them. All you get is some sample midterms, which are not even comprehensible, and there were no office hours or anything to review them. The answers use notation we are never taught, and even the notation across answers is different. The exams are the worst aspect of this class and stop it from being an excellent class.
    • Minor thing but the course textbook is on Pearson, which has the worst ereader interface on the planet. You canโ€™t even buy a PDF anywhere for it. It may be worth buying a physical copy for this course.
    • Piazza unfortunately was fairly dead this term with little discussion among students. Slack was a little bit better so be sure to hang out on slack if you find Piazza unhelpful.

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

  • Georgia Tech Student2020-11-20T22:06:07Zfall 2020

    Definitely an interesting course, learned a ton, but there are a few things I didn't enjoy as much.

    Pros

    • Most of the material is interesting and challenging
    • The labs are quite fun -- you get an opportunity to code up performant parallel algorithms and test them on the cluster
    • Exams are difficult but have very lenient grading; they really test your understanding of the concepts (open book so no memorization needed)

    Cons

    • The lecture videos are bit jumbled due to reorganization, so the flow isn't as smooth; the presentation of the content in the videos isn't as clear as I've seen in other courses, but maybe that's just personal preference
    • There isn't a set of high quality slides or notes for those who learn better by reading; the official notes are meh, and the textbook doesn't map well to course modules (and needs to be borrowed from library)
    • Maybe it's just my term but I found Slack / Piazza to be a bit less collaborative than other classes I've taken

    Overall ok class. Loved the labs, liked the exams, but disliked the teaching.

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

  • Georgia Tech Student2020-05-23T03:03:09Zsummer 2020

    I ended up dropping the course. This class requires a considerable amount of assembly experience, much more than what is advertised on the course page.

    The course VM also sorely needs to be updated. It's an Ubuntu 12.04 image (from 2012, which went end of life in 2017. Don't connect it to the outside internet.) Yes, I verified with the TA's that it is current version of the class VM since I was surprised too.

    But, it looks like a promising class besides the VM. Just make sure that you're prepared.

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

  • Georgia Tech Student2019-12-30T09:58:19Zfall 2017

    A tough but very good course! The lectures are good, if a bit too simplistic at times. The exams are very hard (for the given time) but completely open book. The real challenge are perhaps the assignments, which do need a good grasp of C, pointers, pointer arithmetic and recursion. Overall, a great course, though my word might be biased since it was my first into the program,

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

  • Georgia Tech Student2019-08-17T16:34:55Zspring 2019

    Quite difficult class. Lots of math. Good material.

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

  • Georgia Tech Student2019-08-14T13:20:48Zspring 2019

    One of the best courses in OMSCS. The course is similar to "Intro to parallel computing", how to think about algorithms when designing for the same.

    Exams are tough, will push you to put on your thinking cap. On the plus side, they are graded leniently and if you score well in projects, you can get (A or B) easily.

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

  • Georgia Tech Student2019-07-19T21:22:55Zspring 2018

    This was one of the more challenging classes I have taken. I believe all of the material (lectures, projects, and tests) encouraged thinking about common CS problems in very different ways. This was my 4th class and probably by far my favorite due to how rewarding it felt and how I learned to approach problems from a very different perspective.

    The main advice I'd give for this class is to start projects early and try to keep up on the lectures.

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

  • Georgia Tech Student2019-05-06T07:11:50Zspring 2019

    Course content material is good. Assignments require a considerable amount of work. Start early on Assignments and attend TA hours. Rich is very active in Piazza and TA's are quite helpful.

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

  • Georgia Tech Student2019-05-01T17:36:14Zspring 2019

    Overall, this course was fantastic and I would definitely recommend you take it, if interested.

    That said, to parrot other reviews: It is a lot of work, but the grading is fairly lenient. You need a solid understanding of C and the time to devote to projects and studying. I, admittedly, crammed a lot of the projects in a single caffeine-fueled weekend, but I've been writing C professionally for the better part of a decade, so I could typically write a working implementation of every assignment within a day. The biggest hurdles with the projects was conceptual understanding and, once you get a correct implementation, you almost always end up spending just as much time, if not more, getting the performance numbers up. Typically a correct implementation will get you at least 60% of the grade with bad performance (in my experience, my initial implementation would get me about 80-85%) -- getting up to 90-95% is fairly easy with a little effort. Getting to 100% on some of the assignments took considerable effort.

    I don't know that this will remain, but we were also given two late passes, meaning: out of the 5 assignments, we were able to turn 2 in 2 days late if needed. I used both due to work being hectic, so I was very pleased to see this be the case.

    As for tests: either the tests are bad or the lectures don't prepare you enough. The assignments were about applying the knowledge and then you were hit with tests that were very conceptual and theory heavy. The midterm was far worse than the final as the midterm was more about writing algorithms and the latter was on easier topics and explaining the algorithms. Both tests were 6 questions of 10 points, making them 60/50. Total, I got ~20/50 on the midterm and ~35/50 on the final. On both exams, they gave everyone an additional 15pts, which brought me up to ~35/50 and ~50/50. The midterm median, after adjustment, was 38 and the final was 41.

    If I could do the tests again, I'd try to find more time to study and prepare -- unfortunately, with work and some personal obligations, I was just struggling to keep up with everything. That or maybe taking Graduate Algorithms before this class would've helped on the tests. That said, I didn't really need to do any better to pass (though, at the time, I was concerned about getting a C because of my midterm grade bringing me down and not feeling ready for the final)

    Final grade distribution was 85 for an "A," 70 for a "B," 55 for a "C" -- I managed an A at 90+% -- I was very surprised by the lenient grading distribution after we were given +15pts on two tests, but I'm definitely pleased to see it.

    If you're interested in parallel/distributed algorithms, definitely take this course. This has been the most difficult class I've taken to date, but it's absolutely worth it.

    Courses I had taken before this: IOS, AOS, NS, HPCA, EOS

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

  • Georgia Tech Student2019-04-30T19:48:37Zspring 2019

    I took this course not knowing exactly what I was getting into except the funny and amusing "intro" video on the website. I must say that I did not regret taking this course. Let me tell you why!

    The professor and TA's actually care and give a crap. They're active on Piazza and weekly OH as often as their schedules can allow them and they respond to (almost) all piazza posts. The course is very well run! Each project has a detail README that help to get you started but nowhere enough to let you make an easy A. Furthermore, the labs are based on topics that are covered in the video lectures.

    Talk about the video lectures, they're great. The professor and the videos creator definitely put a lot of thoughts into trying to make the lectures as enjoyable as possible, and it showed! This is actually the first course I've viewed all the videos properly without skipping! The exams are hard but were given some curves, so as long as you did your best, you should be fine.

    Now some bad things that could be better:

    • The lab README need to be updated per semester instead since there were some outdated information that was confusing.
    • There's a lab that has some variation in performance that it's hard to know for sure what grade you'll get. It's annoying to troubleshoot but they are looking at revamping the labs for future semesters so that might not be an issue anymore.
    • Exams are too hard. I think it's by design, but I rather a more practical exam that doesn't require you to be at researcher level type of understanding to answer all the questions properly on time. Or maybe less of a percent of your grade if possible.
    • The video lectures can be paced and broken down better or less topics but more in depth. The first unit was great in term of pacing and setting up some base ground knowledge, but comes unit 2 and 3 (which the final is based on), the materials quickly become so dense that it's difficult to fully grasp and understood all of the topics properly to prepare for the exams.
    • Jokes can fall flat / forced (but tbh, I still enjoy them).

    All in all, I think it's the most rewarding and well-ran class I've taken so far and I've taken 5 courses already before this. I recommend this course wholeheartedly!

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

  • Georgia Tech Student2019-04-30T16:09:27Zspring 2019

    This is the best course I've taken in OMSCS. Strongly recommend it.

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

  • Georgia Tech Student2019-04-28T16:39:42Zspring 2019

    tl;dr

    Takes a bit of time and effort, but one of (if not the) best courses in the program. Highly recommended regardless of specialization.

    Lectures and Material

    This class is about the analysis of parallel algorithms. It had some of the best lecture videos I've seen in an OMSCS course -- packed with content and rife with light-hearted humor. They were as entertaining to watch as the Littman and Isbell's Machine Learning lectures, but even better at explaining the material.

    Projects

    There were five projects in this course that tied pretty closely to what the lectures cover (the same can't be said for all courses). Think things like:

    1. Writing a program that takes advantage of the processor's L1 cache.
    2. Writing a distributed (across machines in the PACE cluster) sort.
    3. Writing your own MPI primitives.

    Major takeaways from the projects for me were:

    • Be comfortable with C -- particularly memory management and pointers. You definitely do not need to be an expert at it, just be familiar enough for the language to take a backseat to the actual problems at hand. I'd say if you've taken Intro to Operating Systems, you need about that level of proficiency.
    • Start early. You get about half-credit for having a correct solution so get correctness ASAP. Tuning the algorithm for performance can often take longer and is addicting!

    Office Hours

    I appreciated the weekly hour-long office hours. TAs were always present and engaged and Professor Vuduc attended about half the time to answer questions and discuss HPC in general.

    Exams

    Exams were real hard.

    Summary

    I wish all courses in this program even attempted to reach the quality and value of IHPC. Thank you Professor Vuduc and all of the TAs!

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

  • Georgia Tech Student2019-04-27T23:29:56Zspring 2019

    2 pointers went to a bar on opening day. All hell broke loose and we spent all semester looking for the double free. True Story. Ok. Now for the serious review.

    HANDS DOWN THE BEST COURSE I HAVE EVER TAKEN! (I have taken 18 grad level engineering courses so far. On that note, the last time I took algorithms was in undergrad 10 years ago, but I watched Stanford Algorithms at the start of the semester to brush up.)

    Lectures: The lectures are super fun. The material is quite challenging but Prof. Vuduc breezes through it and keeps it super engaging with his jokes and awesome doodles. (I LOVE his sense of humor) The best part- I mean, second best because the doodles are clearly the best part- is that even though he makes jokes and tiny detours, he still keeps the lectures very crisp. Together, these make the lectures super watchable. None of that rambling you hear about in other courses. And amazingly, he still makes his point and even manages to get us to think (gasps!) about some of the concepts. I also love that they give lecture time at the start of the lecture. On that note, the time estimate only includes lectures and projects. I didn't do most of the readings, and I spent about 2 days on exam prep each time, which I haven't included above. Anyway.. Prof.V is a wizard at teaching, really. I hope that in the future he teaches a course on how to present material, so I can sign up for it.

    TL;DR if you are interested in learning but scared of pointers and afraid to take this course, do yourself a favor and just watch the lectures.

    Projects: Though I said you can just watch the lectures alone, to get the most out of this course, you do have to sign up for it and do the projects because they take your understanding (and blood pressure) to another level. Of course, they were pretty cool and you will survive if you are up for some serious C/C++ head banging. Most have points for compilation, Bonnie correctness and performance. The performance tuning for some was equal parts fun and frustrating. Lab 1 (List Rank, C) was very approachable and maybe gave a false sense of security, because Lab 2 (Barnes-Hut, C++) was brutal. It took a while to understand, but took twice that time to implement, and as I implemented it, I discovered all the holes in my understanding. Rough, I tell ya. Lab 3 (MPI primitives, C) was a relief in comparison if you didn't care about getting the most performance. (I didn't and still got a 90+) Lab 4 (Terasort, C) was "easy" in the sense once you got the correctness, you didn't have much to do. But I bought into the "easy" image, started 3 days before submission and ended up having to use the late submission. Lab 5 (Funnelsort, C++) was hard to understand and I spent a lot of time trying to make sense of it, but once it worked, the performance was good . My personal ranking was 2> 5> 4> 1> 3 in terms of difficulty (others have said 3>4>1. So ymmv)

    I was able to do almost all the labs within a week, and I got full credit (or even EC) in most. Of course, my code was nowhere close to top performing, but you get what you put in. My one tip for labs is get to correctness as soon as you can, then work on performance as much as you like or have time for. And don't give up. If you keep chasing those ruddy pointers, you WILL eventually get it working.

    Exams: In one line: Mostly R.I.P, but thank God for the curve.

    The expanded version: they were super cool in the sense that when they say open everything, they really mean everything, like they could have anything from wikipedia links for new topics in the questions to solutions that refer to older midterms/finals. I personally think that them saying no to collaboration outside the class (like talking to someone at home) is moot, because I don't think there is anyone in a 50-mile radius of me (including peer students) who can help with these questions anyway. Like, on the midterm I spent a literal 10 minutes just reading a question and trying to make sense of it, forget answering it. "Brutal" doesn't even begin to describe the exams, but one good thing is I studied for a lot less time and am pretty sure my grade would be no different if I had spent a lot more time. That said, I am glad the questions really forced me to think and challenged my understanding of what I had learned so far, even if I ended up doing poorly on them. Trust the curve and ensure you do everything else in the class, and this too shall pass. Pun intended.

    Instructors: Both Prof.V and the TA's (especially A) were awesome. Prof.V conducted regular Office Hours, posted weekly reminders of what we should be doing for that week and was pretty active on Piazza. A was pretty active on Slack as well, so we almost always got responses for our questions. I felt the grading, if not lenient, was definitely student-friendly.

    Why is it the best? It's hard but for the right reasons. It's fun. You learn a lot. The instructors are amazing.

    TL;DR Take it if you want to learn a lot but only you are ready for a challenge!

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

  • Georgia Tech Student2018-05-18T03:33:10Zspring 2018

    I entered this course with lots of hopes & excitement & reading good reviews about it here. But unfortunately, I ended up being disappointed - which was in part due to my own undoing & in part due to my expectation of this course.

    The Good:

    1. Prof. Vuduc has a good sense of humor!
    2. Some parts are interesting, How do you parallelize a seemingly serial algorithm. I liked Unit 1 especially.
    3. Initial labs were really interesting. (Basically lab1 & lab2, lab3 was okay).
    4. Generous marking.

    The Bad:

    1. It's a time sink. The lectures only give you really basic intro - with hundreds of external references, which you may have to read to actually understand the material.
    2. Not much interaction with Prof. Vuduc. The course was mostly driven by TAs.
    3. More theory oriented than needs to be & heavily tilted towards MPI scheme of things (which is really niche).
    4. No mention of CUDA & related stuff. Not even basic NUMA which are becoming commonplace. So this course has limited practical utility.

    Misc:

    1. The last 2 labs were about Terasort & Funnelsort. Really ? I came to this course for learning parallel algorithms, not yet another sorting algorithm. And don't get me started on Deepthought :-(
    2. OpenMPI is really niche, and unless you work in an area that uses it, no point banging your head for it.
    3. Finally, I came to this course reading all the good reviews, but IMHO this course is highly overrated. You should look up the actual course material on udacity to decide on whether you want to take this.

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

  • Georgia Tech Student2018-05-10T16:12:01Zspring 2018

    I know a lot of people are writing that this course is very time-consuming and challenging, but I found that it is also extremely forgiving and, as everyone agrees, incredibly worthwhile. I work full-time and took this course along with Network Security. I pulled one allnighter for this course because I am a champion at procrastinating, and even then, I could have just used one of the two 48-hour late day passes everyone is given. I even bombed one of the first assignments and ended up with a 97% in the class with all the extra credit they give out towards the end.

    I test much better than my actual understanding, so I found the tests fun and engaging and both the midterm and final had a generous curve (60%->90% and 76%->100% in my case). I would recommend going over the textbook somewhat thoroughly, or at least know where the relevant sections are, since on both tests, I managed to basically transfer pseudocode from the book onto the test for an entire question. Also have the solution manual to the book handy (there's a bunch of pdfs online). On the midterm, one of the questions was almost identical to the last year's midterm solutions.

    If you're worried about taking this class, just take it and stay engaged on Slack and Piazza. Since it's usually a smaller class, all the students are very helpful and the professor and TAs were phenomenal. I started some projects 2-3 days before they were due (spending about 4-7 hours a day on it) and did fine by utilizing other people's questions and answers on Piazza and Slack. I don't recommend that because every single time, I would start an assignment and panic that I wouldn't crack the algorithm in time, but you should not panic if life gets ahead of you a bit and you neglect this class for a week or two.

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

  • Georgia Tech Student2018-05-07T02:05:56Zspring 2018

    I usually don't write reviews for course, but felt that I should for this one. I have to admit this was the first time I struggled in a course, and have been very mixed on what to write. If you have any significant milestones in life or at work during the semester you intend to take this course, then I don't recommend this class to you. If you are have a lot of free time available then proceed.

    It was definitely the most difficult course I have ever taken. I did think the material was very useful, and came out better for having made it through. The assignments were pretty cool, and required a significant time to complete. Only complaint was that it was never clear what made the best/fastest approach. It would have been nice to see what others did to get better performance.

    The exams were absolutely insane, and not in a good way. Like other reviews said it is about taking what you learned to the next level. Given an entire weekend you might be able to solve all problems given, but in two hours just try to maximize the points you can get. The only real saving grace to the exams are a significant curve. My first class in the program was CS-6505, and those exams were easy compared to this class.

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

  • Georgia Tech Student2018-05-06T04:05:05Zfall 2017

    This course is a great course for mid to late program students. The lecture videos are very well done and entertaining, getting the core lessons across in a digestible manner. Topics are split across different areas with technical names which I would summarize as local parallelization (OpenMP), remote parallelization (OpenMPI), and cache stuff.

    Projects are uniquely challenging in that correctly implementing code (IE successful sorting) will only get you partial credit - full credit requires performance goals (Either completion under a certain time or number of cache misses). I previously took IOS/AOS so I thought that would give me a leg up for projects but I still found myself scrambling to complete projects. I ended up getting full credit for all projects but it cost me - I spent ALL my free time writing code and reimplementing methods to try to get better scores. ** MY MAJOR COMPLAINT - Though I scored full marks, other people got crazy performance gains as compared to my implementations. While the lectures and papers leading up to projects give hints as to methods to use, there aren't any official recaps to let you know what you should have done.

    Exams are very difficult. I am not entirely sure the motivating philosophy behind them, but I suspect the goal is to "elevate" your understanding of course material. What I mean by this is that the questions ask you to provide algorithms/psuedocode for problems you have not seen before. When I took Advanced Operating Systems I shut myself in my room for two weeks to study material and came out with 90s - for this class I did the same and scored raw 40/50 on the exams. Curves bumped me up to passing grades (approx. 75 each) but it does make me wonder what the exact point is of making things so difficult.

    Still, it was a fun class. The TAs are great, Professor Vuduc is great, and you will learn a lot if you put in the effort.

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

  • Georgia Tech Student2018-05-05T23:20:53Zspring 2018

    This a challenging, but very rewarding class -- maybe the best in OMSCS. The course material is excellent and well-organized and the projects do a good job of reinforcing the material. For example, we implemented MPI collectives using only send and receive operations in one lab, so that you really understood what they did before you started using them as black boxes.

    Getting a correct implementation of an algorithm (which isn't trivial) will get you 80 to 90 percent of the project points usually and then it takes some significant fine-tuning and experimentation to get the rest. The test are very hard, but the problems are well-stated, unlike some other classes where the tests are hard because of ambiguity. The TAs give generous partial credit and the Prof Vuduc gives a generous curve on top of that. Note, however, that you're being curved against some very smart classmates due HPC's reputation as a difficult class, the fact it's not required for any specialization, and the substantial drop rate. I would strongly recommend taking CCA or GA before this class and you need to be decent with C (taking GIOS would certainly be enough prep).

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

  • Georgia Tech Student2018-05-02T16:36:42Zspring 2018

    This course is "Intro to Parallel Computing". This will teach you the primitives for parallel computing. I learnt and enjoyed the programming assignment. The exams are on tougher side, but it will be a fun. This course will teach you so many tools that can be used to analyze the parallel algorithm , and also cache friendly code.

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

  • Georgia Tech Student2018-04-30T14:05:28Zspring 2018

    This was my first course in the program, and I enjoyed the class and learned quite a bit about HPC programming. The class is a lot of work, but the TAs are very helpful through Piazza and Slack. Exams are challenging, but doable with a generous curve. Definitely study: review the assigned readings and lectures. Exams used ProctorTrack but were open notes/book/internet. The instructor (Prof Vuduc) was great, but only showed up for a couple of the office hour sessions. I would have liked more interaction with him.

    A few things that I disliked: it felt like there was a lack of feedback on graded work. For the projects/labs, many times implementing algorithms as presented in class would not get you 100% on the lab (but you could still get an A or B fairly easily). You need to be creative or research some methods to speed up your code (grades are based on run times). After the grades were returned, there wasn't really much discussion on ways that people were able to get full credit, so I felt there was an opportunity for more learning that was missed.

    Some of the later projects had a few issues with cluster being temperamental - no fault of the teaching staff, but definitely frustrating for the students. Our grades were based solely on run times, but we couldn't actually get accurate timings on some of the labs.

    Finally, the exams are notoriously difficult. Midterm was 60 points, but only graded out of 50, and the prof recognized that no one would even get close to 60 points during grading. An additional (generous) curve was added after grading was complete.

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

  • Georgia Tech Student2018-01-06T07:30:48Zfall 2017

    ToDo

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

  • Georgia Tech Student2018-01-05T17:11:47Zfall 2017

    This was one of my first two courses, and with no prior experience with HPC, I found it very difficult. The course requires a lot of hard work and dedication, and of course, expertise in C along with debugging. Instructors and material are awesome and the course is very well designed.

    A piece of advice: might not be a very good idea to take this course in first semester along with any other course!

    Overall, I loved this course and learned a lot!

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

  • Georgia Tech Student2017-12-20T18:35:11Zfall 2017

    HPC is pretty cool. As an oversimplification: this class is about making algorithms as fast/performant as possible. The programming assignments are graded on how fast they run on a high-performance computing cluster. The course material covers parallelization on a shared memory system, distributed computing, and cache performance, and I felt like the class provided a good general intro to these topics.

    Dr. Vuduc is clearly a passionate educator. He's good at illustrating many of the difficult HPC concepts. The lecture videos have high production quality. The class was well organized and the Piazza/Slack interactions were engaging.

    CSE 6220 was my first OMSCS course. I knew it was going to be challenging, but it was harder than I'd hoped. I found the midterm and final to be difficult and grueling. The exams are mostly theoretical / analytical while the labs are obviously practical. There seemed to be a disconnect between these two components of the course. The harder labs took a large amount of time, and I'm not sure how much additional time/energy would have been required to do really well on the exams. That said, if you do well on the labs, you can still get an A even with middling performance on the exams.

    I took this course to fulfill a foundational requirement, to challenge myself, and to get exposure to HPC. I came into the class with some light experience in C. I had to spend a lot of time on the labs wrestling with C issues that a more experienced C programmer wouldn't have. I also didn't have strong algorithmic analysis background, which made it difficult to follow some of the analysis portions. Overall it was a hard but good course. I feel accomplished after having completed it.

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

  • Georgia Tech Student2017-12-13T15:38:35Zfall 2017

    Projects need to start as early as possible, don't overestimate yourself, almost every people in this class need at least 3-4 days to figure out one project, especially Lab2, Lab4 and Lab5 for me. But overall, compare with exams, projects are much easier. My average score for projects is 100.1 with some extra points, but the midterm only got 72, hope final exam would be greater than 70...

    Update: final is 78, with 20 curve points. Although the exam is really tough, the score is not that bad due to the curve points. Overall, great course! I definitely learned a lot!

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

  • Georgia Tech Student2017-05-12T02:31:14Zspring 2017

    This is a very interesting, but very difficult course.

    The lectures are great, the discussions on Piazza are great, the interaction with Professor Vuduc and the TAs is great.

    The midterm and the final kind of sucked ( i. e. they're just really hard ;) ). The approach that the class takes on exams is to get you to take your knowledge to the next level, rather than testing what you learned directly. This could be a good thing or a bad thing; depends on how you look at it.

    The assignments are okay. Their goals are really exciting (parallel list ranking, the N-Body problem, distributed communication collectives, TeraSort, and funnel-sort), but I thought the instructions were a bit lacking. I'd say I spent 40% of my time trying to understand the skeleton code, another 40% learning about the goal of the assignment, 15% coding, and 5% learning things about C.

    While working on the assignments I found myself more stressed out and frustrated than focusing on putting my knowledge into practice. However, they're continually improving this course, so I anticipate that this will change in the near future.

    I do feel quite accomplished after finishing the course, and for what it's worth I took this as my first course while working full time, plus my wife and I had just had our first baby a couple of months before the class started, and I was able to pull off an A. So if you're up for the challenge, then I say go for it, you're learn some really cool stuff.

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

  • Georgia Tech Student2017-05-08T19:17:55Zspring 2017

    I already had a fair amount of experience in HPC going into this class, so it didn't seem as hard as a lot of the reviews suggest. The one challenge was that 3 out of the 5 labs were in C; I have a lot of experience in C++, but none in C and there was definitely a bit of a learning curve. My recommendation for students is to start the labs early, check the piazza discussions daily, and try to squeeze every possible point out of the labs, particularly if there is any extra credit available.

    My recommendation for the instructors (should they happen to read this) is that I found Unit 3 and lab 5 a bit esoteric and not particularly valuable. I would have preferred that Unit 2, which is on distributed memory systems, be expanded and include more challenging labs, possibly a Cartesian finite volume solver of some kind.

    Overall it was a fantastic course, and I definitely learned a lot.

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

  • Georgia Tech Student2017-05-08T08:29:59Zspring 2017

    Definitely a tough course but very fulfilling. Instructors/material are great and the course is a well designed one. My word of advice will be, can you code in C? To be able to write a ~250 lines of code in C with pointers and be able to use debugger is a must.

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

  • Georgia Tech Student2017-01-01T20:14:42Zfall 2016

    This course is a fun ride through High Performance Computing. I didn't expect to love the class as much as I did, but seeing how to push computers to their limits in several different ways proved to be an exhilarating learning experience. The class is broken up into 3 sections: the Dynamic Multithreading Model, the Message Passing Model, and Cache-Optimized Algorithms. To do well in this course, I found it necessary to do most of the extra readings, and it was also helpful to go through the video lectures multiple times. If you put in the work for this course, you should do well, and you'll be rewarded by a wonderful understanding of the HPC landscape. My only wish for this course is that it was broken up into multiple courses so that I could dive deeper into each topic.

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

  • Georgia Tech Student2016-12-21T02:02:45Zfall 2016

    I found this class to be extremely challenging, but very rewarding. I took it my first semester in the OMS program, which was definitely a mistake! I'm coming from a non Computer Science (but still engineering) background, and I had almost no experience with C/C++. I ended up spending between 20-30 hours a week on the course lectures, readings, and assignments, and ended up with a 'B'. That being said, I learned a ton. Prof. Vuduc is an amazing professor, and I found the concepts fascinating. If you're not coming from a CS background, I would strongly recommend doing some prep work on C and parallel algorithms. And be prepared to spend a lot of time debugging and getting your code to run. In the end, I loved this class, but wish I had not taken it my first semester.

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

  • Georgia Tech Student2016-12-19T19:43:16Zfall 2016

    This is one of the most challenging classes in OMSCS, but crazy fun at the same time. Some algorithms such as Z-order curve will blow your mind.

    The class has video lectures, reading text-books/publications and assignments. The Prof gives guidance on what to do each week, and you must follow that schedule if you want to do well in class. Office hours are held every week, and you must make full use of it.

    There are 5 assignments, all of which are not at easy, even for the experienced C/C++ developer. You develop your project on a VM provided by the class, and then test it on an IBM super-computer, for which you are given access. An initial performance benchmark is provided for most of the assignments and your grading depends on the performance metric. Its better to start the assignments as soon as they are released. After submission, each assignment gets a 48-hour window to improve performance. The class is set up for student to succeed !!

    Exams are open-book, open-internet, but none of that is of any use if you don't master the subjects. They release previous semester papers, and you should refer to it while reading the class material / lectures.

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

  • Georgia Tech Student2016-05-11T21:31:11Zfall 2015

    Intro to HPC has been the best class I've taken in the OMSCS. It blew my mind. Everything about it was awesome.

    The projects were crazy-engaging. It was kind of a competition: the teaching staff often posted the top 5 performers among the submitted projects, with metrics and whatnot, so I got to try my very bestest to make it to that list. It was madness! (good madness) Each project illustrated a very advanced element of HPC, so I left with a feeling of having learned a lot.

    Prof. Vuduc has a very particular sense of humor, which he embedded in his videos. It surprised me how I never got fed up with the jokes. I guess I always find a true nerd's humor amusing.

    I'd like to invite everyone to give HPC a chance. The fact that it's not required for a specialization (anymore :'S) shouldn't mean it's not worth the effort. This class is the bomb! It's packed with algorithm design and analysis (and very clever algorithms, by the way), several models of computation that you may not have studied before, and probably should, oh and the projects are spectacular. If you like algorithms, programming, getting your mind blown, and are up for a challenge, this class is for you. It's hands-on Computer Science in my opinion.

    There are some requirements that I'll try and emphasize here:

    • Running time and complexity analysis, Big O and Theta notation, the master method, etc.
    • C and C++. You gotta know how to code in these languages. I mean know them well. If you're afraid of pointers, you should get some practice first.
    • Basic Linux command line knowledge, as projects involve a virtual machine and the Deepthought Cluster.
    • Some linear algebra, as in virtually any other class.
    • C and C++. Yes, you need to be able to get an algorithm from a lecture or an academic paper down to functional C/C++ code.
    • Debugging in the woods with your teeth and a knife.

    Give it a shot, You'll have fun!

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

  • Georgia Tech Student2016-05-10T02:46:34Zspring 2016

    This class is definitely a challenge. But it's a challenge for all the right reasons. The lectures are well presented and you'll certainly learn a ton. The assignments can be very challenging and count for a large percentage of your grade. In fact if you do well in the assignments you can still do well in this course despite the extremely difficult midterm and finals. Going into this course, I'd make sure you take the prerequisites seriously. Know you algorithmic analysis. I found that I had to brush up on a few areas of maths during the course which didn't help under the heavy workload. Knowing some linear algebra is also helpful as 2 large sections of the course work with matrices. The assignments are mostly done in C, so make sure you're well versed with that. The level of C needed is (imho) about the same as that for AOS or similar courses.

    The class is hard because achieving high performance is a difficult problem. If you do this class, you'll discover that even something simple like sorting which you may have mastered from undergrad now becomes an order of magnitude more complex and if you don't do it right you may have severely degraded performance even though you have N times more computing power.

    I highly recommend this class. Even if you're not solving a problem across many compute nodes, performance will always be important and this class will give you the right tools to write high performance software.

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

  • Georgia Tech Student2016-05-09T14:13:53Zspring 2016

    Agree with most of the reviews here. This is one of the best courses available. It's really hard but equally rewarding as long you can stay up to the end (I think only 36 of ~80 or so who started remained till the end). The labs are challenging & exams can be brutal (depending on where you stand under the overall distribution). Prof. Vuduc & all the TA's are very good in what they do. They are almost always available on piazza, we had office hours almost every other week etc. Prof. Vuduc is not only good at HPC but has a very good sense of humor which he mixes well in between the lectures. That kind of lightens up the sometimes heavy content. Overall the video lectures are super excellent & worth while revisiting them when needed. If you are willing to work hard & learn a lot, this is a course you shouldn't miss. I would highly recommend this course.

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

  • Georgia Tech Student2016-05-09T04:05:11Zspring 2016

    Very difficult class, but very rewarding.

    This was my first OMSCS class and I was afraid that it would be too much to handle right off the bat, but while it was very difficult I definitely learned a lot. Professor Vuduc and the TAs were very active and helpful on Piazza, and the lecture videos are put together very well.

    There is a lot of reading between assigned chapters in the text book, assigned papers, and the papers necessary to learn about how to do the labs. Speaking of, the labs can be very difficult to get working fast enough, and I would highly recommend starting them as early as possible. They are all in C/C++, so brush up on that before the class starts.

    Overall it was a very informative course and the helpful Prof/TAs made my first OMS course feel less disconnected.

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

  • Georgia Tech Student2016-04-29T00:33:21Zspring 2016

    One of the best course I have taken in OMSCS (having taken ML, CV and RL). Lectures are fun, HWs are intense, exams show you what your actual understanding of the subject is. If there was a follow up to this course, I would have taken it hook line and sinker. Tips:

    1. Know your pointers (need not be an expert though)
    2. Leave sufficient time for the projects.
    3. Don't get discouraged, if you work hard you would definitely get to the other side smarter and funnier.

    Recommendation: Just take it !!! (if you love coding, algorithms and want bragging rights !!!)

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

  • Georgia Tech Student2016-04-24T18:29:44Zspring 2016

    This class is definitely one of the best classes I've taken (both in this program and overall).

    The class is very rewarding, and Prof. Vuduc's way of explaining/presenting things is just awesome. However, be aware of:

    • Assignments: they are really hard and require time
    • You need to know both C and C++ (one of the assignments is in C++, and it is not a trivial program to code)
    • Exams are really hard, and there only a few people getting 90%+ on them

    All that being said, don't get discouraged, as this is a very good course, and your grade most probably will be quite good.

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

  • Georgia Tech Student2016-04-07T19:26:35Zspring 2016

    This class is really hard for a first class. If it has been a while since you were in a hard class you might want to wait till you have some other graduate courses under your belt. Labs where VERY time consuming and took me over 50+ hours to complete. One lab took me over 130 hours to complete.

    Some things to keep in mind:

    1. If you are not proficient at C don't take this class
    2. If you don't know how to use GDB or Valgrind don't take this class
    3. If you don't have massive amounts of time to spare,.... you guessed it, don't take this class
    4. If you want to learn a lot and can satisfy the first 3 parts DO take this course!

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

  • Georgia Tech Student2016-04-03T04:53:56Zspring 2016

    There's a few easy, wishy washy courses in the OMSCS program. This is definitely not one of them. This is probably one of the best classes I've ever taken in my life.

    This class is hard. If you are not a competent c programmer with an understanding of basic algorithms you will probably not make it through this class. However, this class is also completely awesome. The lectures are incredibly well done and are interspersed with actual good humor by Prof. Vudoc. The projects are all very interesting. There are 5 of them and I've spent about 20 hours on each. I could have spent double that time optimizing them, but my efforts were good enough to get close to 95% on most.

    The midterm was brutally hard. I have not taken the final yet but expect it will be the same. However, the grading structure is such that you can get a 50% on the midterm and final, yet still get an A or B in the class if you do excellent on the programming projects.

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

  • Georgia Tech Student2016-03-21T14:16:24Zspring 2016

    TL;DR: This is a fascinating class, but seriously consider taking it by itself.

    THE GOOD: -Fascinating topics (OpenMP, MPI, caching) -Dr. Vuduc keeps the lectures lighthearted and interesting. -You get 2 "48 hour" late passes to turn projects in late with full credit. -You get a "48 hour make your performance better" period if you don't like where your grade is after they're released. This only applies if you actually turned something in though. They take the top result, so you don't need to worry about your grade going down. -The Piazza forum is active (with both the TAs and Dr. Vuduc replying). -Grading is fair.

    THE BAD: -The projects take a SIGNIFICANT amount of time. Even with a very good knowledge of C/C++ I found that I was still spending 30-40+ hours on each project (except for lab0). Heed what others are saying. Do not wait till the weekend they're due. -The Udacity "autograder" can be a complete pain in the behind. At times the output isn't very helpful on why it failed. On top of that, the TAs generally don't expound upon what the grader is actually testing. Depending on the project, you can spend a significant amount of time just passing the autograder. -The projects have roughly a two week cadence. So you're always going to be working on something for this class (circle back to comment in the TL;DR). -Office hours aren't consistent. We'll have one every week and then nothing for 2-3 weeks.

    THE UGLY: The class averaged 23. 8/50 on the midterm and it was curved to being out of 40. While they didn't have to curve at all; this meant the majority of the class got a D or lower on the exam. Some of us were disappointed that last semester the average was 19/50 and it was curved to out of 30. To be fair though, two people got above 40 which is what likely "broke" the curve.

    TIPS FOR SUCCESS: -Have a good working knowledge of C/C++. Especially pointers. -Go to (or watch) the office hours. -Give the class the time it needs.

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

  • Georgia Tech Student2016-01-08T20:31:01Zfall 2015

    This course is both very challenging and interesting. The word "introductory" in the title can be quite misleading. When I took this course, I presumed that the course teaches OpenMP and MPI. It doesn't. You are required to study these as part of the course and use them in solving the assignments. The course focuses more on algorithms and divided into 3 parts:

    1. Shared memory parallelism (OpenMP)
    2. Distributed memory parallelism (MPI)
    3. Cache based optimizations

    Lectures: The course content is very good, but may require multiple readings/viewings before it can be assimilated. This was my 5th course, and my toughest so far. The instructor is hilarious. His jokes are very creative and funny and perhaps compensate for the heavy lecture material.

    Assignments: There are a total of 5 assignments. Of these 3 are reasonable. 2 are very tough (There are students who spent more than 40-50 hrs on an assignment and still couldn't complete it). If you get an assignment to work you get about 80-90% credit. The remaining 10-20% goes for performance improvements. The problem is that if you don't get the assignment to work, you lose big time. And that can be harsh, because many students spend most of their time just getting it to work. Do not underestimate the assignments and start early. Also, you need to be comfortable with C, C++ (especially pointer handling). Without this you will struggle in implementing some assignments.

    Midterms/Final exam: These can be quite tough. The midterm had a class average of around 19/50. The final exam had a class average of about 29/50. You have to be really well versed in the course content to do well in the exams.

    Grading: I do not know the exact grade distribution but based on the numbers shown on this website, the percentage of A's seem to be the lowest among current courses while the number of C's seemed to be the highest compared to current courses. Not the course to take if you want to get away with an easy grade.

    Overall, I would recommend this course if you are interested in knowing more about HPC algorithms and are willing to work hard.

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

  • Georgia Tech Student2016-01-07T02:36:22Zfall 2015

    most of the lectures are well organized, but sometimes are hard to understand for me (with little CS background). Exams contains many details in the lectures and maybe similar but not the same kind of questions to the lecture quiz and sample quits. The two midterms for 2015 fall is hard and the mean is below 80, however the final is quite easy and most of the questions are the same in the two midterms. So my got an A at last... Such a surprise... If you want to get an A without many hardwork, don't take this course. If you like chanllege yourself with a theoretical course, it is an interesting one to try.

    If I read this unofficial suyvey before registering my first semester's classes, I wouldn't chanllege myself.... It was so hard and almost painful to me.

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

  • Georgia Tech Student2015-12-15T17:37:09Zfall 2015

    This has probably been my favorite course in the OMSCS program (and I'm almost done). I'm glad I was able to take it. The lectures are great, they have a great balance of humor and content. My only criticism would be that there needs to be more of them.

    The labs can be challenging. You should have some C experience going into this course if you want to do well on the labs. Some are pretty straightforward but are still time consuming (and difficult to debug since you're running in OpenMP and MPI).

    Exams are hard, really hard. They're open book, open notes, open internet and still the average score on the midterm was 50% (although the curve was generous). Make sure to hand write some of your own notes when reviewing lectures and practice exams to help reenforce knowledge for the exams.

    I highly recommend this course, and hope you make it to the other side air guitar riff of hell!

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

  • Georgia Tech Student2015-12-13T00:52:33Zfall 2015

    For me this course was very challenging - more so than both 6505 and 6210.

    The concepts are really difficult to grasp and the exams proved to really kick my butt every time.

    The concepts for the labs seem pretty straight forward but the implementations often proved very challenging - expect 20+ hours on each lab.

    That being said - the course contents were really fascinating and, while demanding, this course will definitely strengthen algorithm analysis and distributed computing knowledge.

    C / C++ knowledge definitely a requisite for completing labs properly.

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

  • Georgia Tech Student2015-11-18T17:22:19Zfall 2015

    Interesting lectures, great instructor. Challenging Lab assignments (there are 5 total). Need to know C/C++ programming. Not a lot of TA handholding. Facinating topics.

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

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

    Very interesting topics. The videos are a hoot. Challenging labs (homework) that you definitely don't want to wait until the last minute for. There is (as mentioned) a lot of outside reading -- papers etc. If you're expecting everything to be in a big textbook, then you will be surprised. I took this as my first OMSCS course. Fortunately, I'm comfortable with C/C++. Those that aren't are getting killed understanding how pointers work, etc. Know your C first, and you will enjoy this challenging course. Don't know your C and you will definitely learn it the hard way.

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

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

    Took this as my first OMSCS course (along with another, much easier class) so I'm not sure if my 'Overall difficulty' field is accurate. I am somewhat experienced with C/C++ which has been good enough that I didn't need to look up syntax and such, but I am really missing the Eclipse debugger for Java (I am a Java developer at work), since debugging multi-process code doesn't do so well with anything other than printfs and even then the output is kind of hard to parse. The projects are definitely difficult as I spend most of my time just trying to get the algorithm working without consideration for efficiency, but so far I have done well. I would definitely recommend this class if you have enough time and know how pointers work. Lectures were great, if this class wasn't online I probably wouldn't be doing near as well, I usually listen to the lectures 2-3 times before fully understanding what is going on.

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

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

    Lab (Programming) assignments are too intense and difficult in functional implementation itself; thus taking most time in making it work instead of making it faster.

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

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

    Lectures are definitely the best part as Vuduc is very entertaining and and clear. The mandatory readings aren't too bad though the recommended ones can get a bit dense (thankfully skimming those seems to be sufficient). Professor is fantastic! TAs are OK

    The real issue is the labs! So far, they've all required extensive outside reading, which is fine and expected in a graduate level course. The problem is the amount of time required and the lack of transparency in the grading. I had never not completed a CS assignment before (high school, undergrad) but I just could not get one of the labs working, even after 40 hours. There is effectively little credit for completion and none for effort though the target performance is usually doable if you've gotten that far. Just keep in mind that, even if you sink many hours into a lab, if you don't get it working, you will fail

    The midterm was very challenging, with a median grade of ~40%, but there was a +40% curve added which made it more reasonable.

    Finally, if you are not comfortable with C/C++, DO NOT TAKE THIS COURSE. There is way too much pointer manipulation involved for the uninitiated

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

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

    This class is both interesting and fun. The lectures aren't too long. So it is fairly easy to keep up.

    Not to be confused with High-Performance Computer Architecture.. this class is all about Parallel Algorithms and how to program Super-Computers. You learn the Work/Span model and how to evaluate algorithms for Parallel Computers. You develop Parallel programs and you learn how to use new primitives to solve problems in a parallel manner. You learn how to program with both the Shared Memory and Distributed Memory architectures. There also seems to be a part about Cache Oblivious algorithms at the end (though we haven't gotten to that yet).

    On the negative side though, there are topics that should be covered in lectures but aren't so you'll have to learn them on your own from arcane papers. The course organization could be improved a bit so that we aren't jumping from topic to topic.

    If you aren't familiar with the subject matter then it will take some iterations to understand it. I went through the lectures 3x.

    The labs require a LOT of time. Best start them early. The code is in C and C++ with OpenMP and OpenMPI. The main issue is just getting the code to work in the first place so you can then plan with the parallel part.

    The TAs seem inexperienced and are mostly absent unfortunately. The professor is very engaged and answers a lot of questions on Piazza. The lectures are fun and funny to watch.

    Its highly doubtful I'll get an A in this class and a B will only be possible if I improve (I've gotten an A in every other class I've taken in the program).

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

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

    I dropped this class but figured people considering it could use all the reviews they can get right now.

    There's a disconnect between the lectures and labs in that the lectures are pretty short, not too dense, very entertaining, but don't cover what you need to know for the labs. There is a lot of studying of outside sources, not just the recommended readings, but whatever you can find on the algorithms you need to implement. They're not at all easy and you get very little credit for implementing them correctly. You'll spend a great deal of time just getting correct code, but you're graded mostly on performance, so keep that in mind. You need to pass the Udacity grader early, so you have plenty of time left to optimize and test your performance on the cluster.

    You absolutely need to already know C, C++, and ideally at least a little about how OpenMP and OpenMPI work, or it's just going to get worse trying to learn that as you go. Know how to use common debugging and program analysis tools as well, gdb, valgrind, etc. You'll spend most of your time debugging early on when you're just trying to make sure the code works.

    Finally, know that it's not at all impossible to do well. I had trouble and had to drop because I was taking two other classes at the same time (including ML, which has very in-depth assignments) and was going through personal difficulties and just didn't have the time for it. If I had the time, I'm sure I'd have done fine. Just don't take the class lightly. You need to get an early start on every lab, do all the readings plus whatever other readings you can find, and get your code working early. I wish I'd known ahead of time we'd get almost nothing for correctness and be graded mostly on performance, which I guess makes sense in retrospect, but just wasn't what I was expecting based on all the other courses I've taken.

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