It was my first course. I came with a non CS background, but decent programming work experience. I was not sure what I was getting into. I had a high level overview of parallel computing (OpenMP/MPI), but never wrote any useful code. Had no clue what CUDA is.

I was expecting the instructor would cover more of the MPI/OpenMP/CUDA details in the lectures, but those things are left to students to learn via the assignments, office hours, reading etc. The lectures mostly cover different general parallel algorithms for some standard problems, and teach how to analyse your parallel algorithms. In a way, this is great, because you would never learn this outside of a class.

Assignments were challenging. I found the labs 1-3 decrease in time required/complexity, which was a relief TBH. I spent insane amount of time on lab1. Grading was very generous. I scored below median in the mid-term, but I scored highest (I think) in the finals. I did put in a solid 20-30 hrs of prep for both mid term and finals. I found finals to be easier than mid term. Ended up with an A, which I wasn't expecting until almost end.

Lectures are super high quality and loved Prof. Vuduc's sense of humor! Keeps the lectures engaging.

I took HPC and found it to be a well-balanced yet challenging course. Lab 0 took only a few hours, while Labs 1-3 required a few days each to complete.

Lab 1 (involving OpenMP and CUDA) was the hardest in terms of maximizing performance for a 100% grade, while Labs 0 and 2-3 were more straightforward to achieve full marks.

The midterm and final exams were very challenging, even with open-internet and open-notes policies. However, they benefit from significant grade curves (+25%). I recommend practicing previous exam questions to prepare for the exams.

Compared to Compilers and Distributed Computing, HPC had significantly lighter project workloads, but the theoretical concepts were harder to grasp.

As a full-time student who has also taken GIOS, AI, Compilers, and DC, I spent about 10-15 hours per week on this course.

This was my last serious course in OMSCS, one more easy course and I'm done for the entire program. Some background: I have taken some challenging courses in through my time in this program (RL, GA, GIOS), I wouldn't call these super challenging, but did create some hiccups as I came from non-CS undergrad background (even though I code in my fulltime job). This has been the most challenging class for me, but I do like it a lot.

What I liked about it:

1. You really learn stuffs, useful stuffs, and will have a much better understanding of parallel programing and distributed system in general.
2. The project are rewarding and cements what you learned from lectures and textbook. You will realize that if you understand more, the better performance your code will be.
3. Even though there are private test cases for projects, but it's not too "edge-gy", meaning that you don't need to spend hours to figure out edge cases that are trivial. It is generally easy to get most of points from compiling and public/private tests, the meaty part is the performance part.
4. Textbook of this course and some reading materials are enjoyable to read (will be better if without any time limitation)
5. The TA team are super clear, project instructions are very clear as well.
6. Curve is generous, if you do your work, you get what you deserve.

What I didn't like:

1. Last project was graded on comparative performance, will be a time sink if you try to outperform your peers.
2. Exams, are pretty challenging and are pretty challenging to get a grasp on, 50/100 was like a average, but they are open book, open internet, so you don't have to memorize.
3. The last part of the course wasn't very well structured, it feels like crunching a bunch of things in a short period of time. I get it... it makes the learning curve not as steep for the first half of the course, but I did not enjoy the pace of last 3 weeks.

Some facts:

1. Unless you are a rock star, prepare many weekends doing nothing but projects. I had a regular fulltime job which is a little time demanding and I had to spend some weekends immersing in the projects.
2. The learning curve is very steep in the first half of the course, there are so much you need to learn before you can even do your projects: OpenMP, CUDA, MPI. Also, it is challenging to think in parallel programming's fashion, not to mention the algos with different types of analysis comparing to serial programs.

Says SP23 but was taken in SP24

This is a good course. Lectures are very good, albeit dense. A lot more math in this course than what I expected going in. The course readiness thing mentions calculus but you never use it (at least, not in lectures and not in our exams). Algebra and very basic linear algebra are good enough

Course is in 3 parts: memory-hierarchy-aware algorithms (e.g. external sorting), SMP multithreaded algorithms, and message passing distributed algorithms. Each section has its own mathematical model that's used for analyzing performance

Would recommend taking this course alone. Getting an A is already hard, but even if you manage to get an A there's still more to understand

This class was the halfway point for me, best one I've seen so far in OMS. Grateful for the professor and TAs

This was my 7th class in the OMSCS. It's got one of the best course material I've done, and I feel like I'm a much better engineer for it. The labs are hard but interesting and I definitely feel like I grok the concepts well afterwards.

Unfortunately the teaching staff were the worst I've had. I found them generally disdainful of the students, and my understanding of HPC was not aided by them. As an example, a student asked how a particular approach could possibly be efficient, given the overhead it requires. The response was "It's magic :-)", and no further elaboration.

As mentioned, the labs were difficult - I spent the entirety of several weekends on each one, and some performance tuning in the week when I could fit it in around my job. That being said, I was able to get good marks on them so it felt like the hard work paid off. There was also an extra credit project (which used to be a normal lab). The performance of your code is a significant part of the marks, which isn't surprising of a class called "High Performance Computing".

The midterm and exam were both very difficult. The midterm had a median of 46% and the final had a median of 45%. Both got flat grade adjustments. I didn't feel like they were good assessments of my understanding of the course material, and the instructors admitted that some questions were ambiguously expressed (which I read as "poorly written").

The course material has been shuffled around a bit since it was recorded, so I found there was some jumping around required to have the required background for the labs.

Overall, I'm glad I took this course as I feel like a better engineer now than at the start of the semester.

I'm surprised this course is rated as highly as it is.

I think the content that's attempted to be taught, parallel algorithms on distributed systems, is very rewarding but the video lectures do an extremely poor job of actually conveying the material if you don't at least have a bit of background in each specific topic. From the very first topic of "Intro to work-span model", I felt like a lot of introductory material was skipped and assumed student has the knowledge of. The worst part about this is, there isn't a proper textbook for the course that has the topics covered, and the TA's and instructor don't know of any external resources to refer you to learn the material on your own time. All in all, interesting material, very poorly taught.

Another huge con of this course is there is close to ZERO engagement in ed discussions. Nobody cares. The professor is not involved with the course at all, even though he's an active professor at Georgia Tech. The instructor is low energy and condescending and doesn't care at all. Some of the TA's are a bit more engaged, shout out to Hal Elrod, but overall the engagement is the worst that I've seen in the program by a long shot.

Assignments are good and rewarding, and not too time-consuming. Make sure you've figured out how to set up the virtual machine and you've got it working early on in the course.

Grade distributions for this semester were 81 for an "A", 71 for a "B", 61 for a "C". The midterm and final were both tough - even more so than the assignments. TAs were really nice. I agree with the general sentiment of the other reviews. I gave it a 5/5 difficulty instead of a 4/5 difficulty because I couldn't figure out the extra credit lab. Fully recommend to any other masochists.

Great course, definitely recommend it.

The exams and the projects are challenging but very rewarding. The best part of this course is that the evaluation components are well-spaced out. At any given point, there is only one thing to focus on.

The lectures are good, the TAs are very responsive. The projects are very rewarding and extremely doable despite the difficulty. The projects usually have a correctness and performance component. Getting the correctness is definitely doable. You can budget your time on getting the performance right based on other priorities. The exams are difficult, but there is generous free credit and the grading is generously curved. In our semester, 82 was the cut-off for an A.

You will be exposed to parallel programming technologies like OpenMP, MPI, and CUDA. This course taught me techniques to think in parallel and extract performance from my code. Made me a better coder since it forces you to understand the concepts of parallelism and look into the lower-level details to improve performance.

Big picture in this class you learn abt I/O memory optimization, distributed parallel sorting and interprocess communication patterns and topologies. While the topics aren't too long (in-terms of no. of hrs of video lectures), these still take time to comprehend and there are a ton of papers which I couldn't cover partly because its a shorter summer semester and there is just too much reading to do. There is a little bit of CUDA introduction for one of the projects.

Got an A with 89.5 score and this semester any score above 82-83 is an A. so there is a fair bit of curve. This doesn't account for extra credit project, which I couldn't finish in-time and can be used to bump up the overall score. Exams are tricky as they don't ask direct questions from lectures. Overall I recommend this class and its best to do it in full semester (fall or spring) becoz in summer u just move from one proj to another without reflecting on what u learnt so far...

Do not pair with deep learning in the summer semester.

The summer semester is similar to Spring/Fall, but you have 1 less week for each lab.

The tests are tough but not outrageous. If you think through the labs in detail, it helps prepare. Aside from that you need to brush up on doing complexity analysis.

I had some paralysis about studying for the tests because I had no prior algorithms experience, but it's not as hard as all of the terminology implies. Just take a stab at one of the practice questions every other day. They are very similar to the test so even if it feels like a brick wall, you will score better by being trained to deal with that format and time constraint.

They aren't overly evil with edge cases in the lab. It's a less persnickety difficulty than GIOS. I struggled more in GIOS but I barely knew C when I started.

I got destroyed on one lab because I placed too much trust in my local test. Turns out my VM was only setup to run 3 processes which was special case of memory management for the tree algorithms we were implementing. I went from thinking I had 100% correctness to 0% correctness the day before it was due. Don't be me. Don't call any algorithm passing with less than 4 processes.

I came out of it a somewhat better programmer, and far better at thinking in parallel.

This is a great survey course with a healthy balance of theory (how to evaluate and analyze distributed or multi level memory algorithms, topology and how it impacts algorithmic performance) and applications (specific implementations of fundamental HPC operations or algorithms).

The assignments will expose you to concepts like cache awareness, CUDA GPU programming (only an introductory amount) and OpenMPI (the dominant framework for large scale compute across multiple nodes).

With that said - I have a few issues with the class that made me REALLY not enjoy it towards the end.

1. New final homework: The final assignment had been recently updated to use a language called Chapel by one of the TAs.

This niche language is very interesting on the surface but comes with a lot of frustrating problems that makes the assignment feels more like a brutal language introduction than an HPC assignment.

• There aren't any guides online besides chapel's limited and disorganized documentation.
• The language fundamentally abstracts expensive data movement in the name of language productivity while the assignment is graded and evaluated explicitly on performance concepts like how well we handle data movement.
• This is the most frustrating one - there are several performance gotchas in the language that you would expect the lang to handle correctly. But if you are not aware of them, you program is 1000x slower and you will score zero despite having a "correct" solution after working on it for 25+ hours.

This HW is also graded by relative performance - so you are competing against your classmates for milliseconds of improvement by circumventing frustrating language limitations. This assignment alone made me drop my rating for this class from 5 to a 3.

2. Uneven content density The class feels very weighted towards the end with the frustrating final HW and some graph partitioning algorithms lectures that feel far more advanced mathematically than earlier sections. I would have preferred if we spent less time on graph partitioning algorithms and instead spend that time diving more into GPU, GPAS model and innovations like Chapel, and HPC applications in the industry.

3. Developer experience: the class gives you a vm to work on but things like chapel and cuda might not run/ compile /intelisense locally. You need to spend time to think of ways to effectively develop on a remote cluster or else you will go mad ssh and scp things back and forth. The teaching staff and assignments do very little to help with that.

Very nice course as a foundation for HPC study.

I loved the extensibility of its dealing topics. You will learn canonical terminology or approach for parallel algorithms. Furthermore, you will do project of parallel & distributed computing using OMP, MPI, and CUDA, all of which are very popular in the HPC world.

Important insight I got from this course was, how algorithm itself is important and how framework itself is trivial to achieve acceleration.

If you wish to take this course, be sure to get prepared with the course pre-requisites, at least with undergraduate algorithm knowledge and C language skills. This is a graduate "algorithm" class. Without algorithm knowledge, I am quite sure you will be most likely to struggle with the course.

For C skills, if you have no progress on the coding project while puting more than 50 hours, in my opnion, it would be perhaps due to the insufficient understanding of C. Project goal is highly straight forward; to implement what introduced from lecture. I found some people extremely suffering from memory corruption bugs. If you have moderate experience with system programming with C, this should be addressable.

If you are appropriately prepared, you will never spend more than 50 hours per week for this course. In my case I spent;

lecture: 2h per recording lab 0: 3h total (100) lab 1: 30h total (85, failed CUDA public test) lab 2: 40h total (96) lab 3: 60h total (80, failed one private test with decent performance score) extra credit lab: 20h total (gave up) midterm & final prep.: 10h per exam => average: 15h per week

I have not much system programming experience. I am not gifted at all, but rather I think I am on stupid side. What I have only prepared was taking GIOS and CS8001/1332 (undergraduate algorithm seminar) class. Don't be frustrated by negative feedback, and if you have interest in HPC world, please do take it. I ended up with 86% of A, and as you might guess from my effort dedication, I was quite lazy. If you put more than 20h per week, I believe you can even achieve 100% score given that there are a lot of generous extra credits.

I just finished this class in the Spring 2023 and was debating on leaving a review. Apparently there was a student below that's taken the class and was pretty unhappy with how they did; so much so that they left 4 reviews pretty much complaining about the same thing. So I figured I'd post to give you a more "honest" viewpoint.

Overall the class is very challenging but fair. The projects are intensive but the instructor was very upfront about how much work they typically take. The grading rubrics are also provided on release..so there shouldn't really be any surprises. Sometimes the cluster can be finnicky but they offer regrades to take a second look in case something went wrong.

Exams are brutal but that's mainly because they are completely different than most exams in the program. They aren't "memorize and regurgitate". They ask you to build upon stuff that you (hopefully) have learned throughout the class.

To account for this the class is "typically" curved although the instructor makes no promises going in each term. This past term an A ended up being 80, B ended up being a 71, and so on. He also curves the midterm and final exam scores individually so they match historical offerings.

You'll probably lose some sleep from this class but you'll gain a different outlook on algorithm and solution design that'll make you a better engineer.

TIPS: -Attend office hours -Start projects early -Double check your work; they are strict on only grading what you've submitted.

When you register the course, please make sure number of people on the course for the current semester. If it is 100 or 150 students on the semester, probably you will be fine. If not, but you are still under registration, that probably means the group cheating advertiser haven't have a chance to notify you run away or you are out of massive cheating group, or probably they just setting the semester to have headcount on hands for the blood mission.

If you are out of the cheating group, and brave enough to take the exam by yourself or you work on the lab by yourself, the massive cheating advertiser will ask you some interesting question such as "is it difficult to take the exam by real", or the top talent advertiser will suggest something like "how about we form a meeting, and each one of us contribute one question for discussion". Dont be so naive , it does not mean you are part of cheating group neither way you answered to that is yes or no. If no, for sure, you are not collaborative. If yes, they could potentially turn you in if anything happened and you are mostly clearly person in the group.

If anything happened, this group would provide a list of variety service for your career or identity safe. For instance, as long as your "background" is strong enough, they could get some blood from another person for you to drink per their operation channel. And you are "strong" enough, you could ask the final answer in the group in the last minutes to get straight "A“ for every course not just one, which is extremely impressive.

For the course work, you should have the capacity to figure out everything by yourself completely. or you should be able to kiss ass beyond your capacity to debug the testing code error for TAs. For instance, the TAs/instructors would be very confident to shifting a project instruction/work to a completely new mode and a list coding error in the project, you will stuck there before you actual start the project, extremely good example is chapel. it will be very limited people in the market know about this language, and plenty error in testing code, even intentionally to stop you from non code complier testing.

For majority course, they will put difficult project or assignment at the begging of the semester to leave the student a way to exit before the drop deadline. Yet, there are plenty sneaky/fishing behavior of course, which is on purposely to trap innocent student. For instance, the lab3 is the last lab, there is unbelievable to shifting the code language c++ a low level but almost efficient/flexible language to chapel, a dedicate/heavy shell with limited documentation and you have no idea where are you going to use it at all. and yes, a lot of people heard about Cuda, but how many people have an ear about chapel ever. And you may ask why are they doing so, the real answer is to fail you and because in the small niche of their mind, you are not suppose to get a 90% score with c++ implementation, and instructor/professor has people from their own school they need to cover for, and you lose your blood for the people you never meet/know before， and it worth for them to kill one person to save 25 people life, and your life is not a life.

What if project3 challenge is not sufficient for you, there is another chance on the final exam and final grading threshold. From each semester's feedback, they will continue to shifting on playing the political game to make sure they win. For example, yes, they will make the exam paragraph to be half of screen, and question as simple as what is the difference between one algorithm and another algorithm from the course, dont be naive to think you will get 8/10 for the question although you have answer every bullet in the exam, the subjective sense could be the grader already be very generous to give you 3/10. and another yes, you will be very happy to see there are another 5 extra credit for a meme picture on the final exam, dont be silly, that potentially only set up to rule you out, please keep in mind.

Anything else in specific? Of Course they do, the course threshold. When there is stable context from semester to semester, a threshold could raise from 70 for a B to be a D, and you will get a 69.999. The course instructor/professor will be super excited to see that outcome. And they would also tell you, oh, yes, we got extremely geniuses talent cohort for this semester. Will you actually believe this? please remember there is a "lie" in the believe.

One of last item, you will think about how the instructor/professor would do such to treat the student? why? because ball passing around from one group to another group, and that ethnicity group people lose a nail store, they have to treat you in this way.

You would also think why only this course is so special? because majority course is from Computing college, but this course is from CSE. They dont care about the college or program so much.

So please aware of the workload on the course could be more than it required as layout here. it would not be the time you actual spend on the coding part, but the time you spend on communicating with the instructors as they wont accept anything you have been requesting or they will find out a way to against you and put you down. let me layout the story in this way:

1. the course would cover potential algorithm that you would use that for your coding project, but it will hold on any tool document that you would need for coding work, for instance, mpi, cuda, chapel, like a list of fancy programming tool that outside of course prequest statement beyond c++, and only one or two link about official document of the tool, then you should be able to figure the tool that not so popular in the market.
2. if you want to reach out to instructor for any potential issue, please be sure you are under cover and you are top talent no matter they would like to take you down. please be aware of the comments on the channel, a lot of other course continue to receiving good feedback from students, but the feedback of this course has been discontinued starting this 2023 spring, and majority student drop out from the course.
3. a lot of other course treat student fairly and reasonable for the assignment, including famous by difficulty level course distributed computing course. Yet, this course typically would be short of student because the main purpose of course to fail you other than make you to be successfully.

let's discompose the specific assignments as following: lab0 to lab3, you could try your best to get full score for each assignments, but that only can be accomplished on your imaginary, plus you need to reserve for 2-3 weeks full weekend for each assignment, not for working on the algorithm and core context understanding or implementation, but struggling with a new tool that probably you cannot find much document to figure out the implementation.

extra credit project, you can save your time and effort for meaningless attempts for more happiness of your life and your life security.

Dont attempt to request accommodation for any reason, they wont accept it even you are laying on bed for a big surgery on your life. They would say that is not acceptable for the course policy. But on the other side, they would against the course policy to give a favorable treatment for another student, just for retaliation, or random human psychology experimentation they would like random run out on you.

Yes, they would change course policy from term to term to prevent you from graduation, or stop responding to your email from hold you on graduation. there course grader TAs, they are excited to see the blood on the knife they are holding.

The interesting finding here is, you may got a poor treatment because you are collaborative to collaborate in way you expect, to part of group event no matter it is appropriate, or maybe inappropriate. you maybe be out because you working on the assignment from end to end by yourself, and easier to sacrifice one person to save majority massive actually cheating.

dont be navie to read score you get as it deserve, there are a list of different info they are passing to you. private test case means you should share or not sharing with other behavior misconduct. the score you suffered, maybe use it to another person career or identity, you are a person hanging in the black market for unknown trading. if you are sold, you wont get correct grade letter no matter however grade you have been supposed to earn. curve threshold is black box, and grate different from semester to semester, they would control the exam black box and pace black box, to make sure you are in the right place for the grade letter was assigned already.

Here is my experience on the 2022 summer:

1. lab0, 10% grade. it is not difficult and achieve the goal easily;
2. lab1, 15% grade, it break out to 3tasks for 2 different algorithms for list ranking problem. and it needs implement in c++ and cuda, be carefully, some effectively functionality of cuda on the pace is not applicable, dont waste your time to thinking about different approach but try out manual tunning, which is really silly.
3. lab2, 20%grade, this is coding up mpi from scratch, and this project will tell you private test case means things are not under your control, private is defined by TAS. so you will lose private test case for unknown reasons. 4.lab3, 20% grade, yes, this is simple algorithm for sample algorithm you need to implement in c++, it is not so difficult at the firs point.

extra credit project, not much student would work on this assignment, like 1/4 of students, and your effort will be useless all the time, because of the correctness means you will get nothing.

Exam1, 15% grade, it will be different application question from first half of course. For the grading, it is mystery, because all the answer is on writing not a coding question, good or bad, it's not your call.

Exam2，20% grade, again, it is the same as midterm exam. good or bad, it is not your call. and yes, it is online exam, you dont have chance to ask clarification question about what is instructor or professor looking for, for example, could you using the algorithm and knowledge you learnt from the course to decompose the data. thing on your mind would be what exactly 'decompose' mean here, and you have no time to thinking through and no chance to figure out "decompose" mean.

Being very careful about the exam also, because all the exam question could be potentially entire screen long, and these questions are application questions from a completely different domain, for example, the domain knowledge could be from physics or chip fields, or remote control or routing field, or the algorithm is completely out of mind for majority student.

Beyond that, exam context is random assignment, if you are lucky enough, you will be friendly assigned a short question. if you are not favorable student for any unknown reasons w/o your control, you would spent time to read the question for 25mins, and last 5mins to write up something you have no idea what is that exactly.

It is open book, but you wont have chance or time to open any book. unless you collaborating with peer deep level, but pay attention, make sure you are under cover to do so.

If you are not the top talent in the world and you are not a native male in us and you are not good at rustling, please drop your course asap. following are something you will go through:

1. You will spent 60 in average for as weekly loading, not only for algorithm, but also a list of unknown and not often useful tools and also black box speed developing in a crowd super computer.
2. Potentially, the course assignment or lab is extremely difficult to run through because of some error in testing that created by the instructors and you laptop crashed because you cannot debug the error to do instructor work. and that is before you start actual developing work.
3. the outcome of submitted script, it run completely fine in provide local virtual machine, it will crash for unknown reasons in submission but not problem if you run it by yourself, both for correctness and speed. dont think about this is a code project, there is nothing under your control besides tremendously amount of efforts you put in the course you can sure.
4. 40% of grade is from the exam, although there are algorithm questions, but they are all subjective to ta grading, happy or not depends on their mood, not on your talent.
5. be very careful, the course instructor and TAs could potentially fishing you everywhere to taking you down, for example, you will be accused of different reason to give you zero credit, including you are using pseudocode.
6. at last, you might love algorithms a lot, but this only will be your little toy in your candy house. a lot of things you gain on the learning, you wont use it for your work at all if you are not a person doing the exactly job.
7. you might waste years of your time on this course for nothing could be helpful for your life but screw up your program, your health and your entire life. And the professor and instructors would still say i am really hope you are doing good.
8. If this is still no enough info to stop you getting yourself out of trouble, please prepared 200% of your time and energy to play political game with the school, and potentailly a crew of cyber security monitoring your assignment day to day, and wrap it out when you complete on the due date, because the instructor/professor, they have different mission to serve for the country for a different purpose.

This course was one of my favorites in the program. I took this after GA, and I quite liked how it continued where GA left off. The exams are brutal; you know where you go through the exam and go "oh I'll come back to that question"? I did that for every question. I ended up scoring the average on the midterm and the high on the final. There was a 7 point adjustment for both. I bombed the first project (50%) but did fairly well in the rest of the projects (80% and 90%). I managed to scrape by with an 83.5% without the EC (I ended up with 2% bonus) which was an A when I took it. There was a generous curve, which we didn't know until the semester was over. I see people complaining about this but in my undergrad at GT, this was also common, so I might be used to it.

The lectures are very well done; Professor Vuduc made them so much fun to watch. The projects are hard if you want to get 100/100, you usually have to meet some sort of performance goal. It's fairly easy to get 80-90. I feel like I struggled more than others in the course, but it's a small course usually, and I definitely got to know people in the Slack. The TAs are really helpful and reply fast on EdStem. The semester I took it, there was a rude TA who judged me for starting kind of late, which I didn't appreciate, but the rest of the TA staff was very helpful. I'd recommend taking this class after learning some C; knowing the specifics on pointers and memory management is very helpful especially since the projects are hard. I definitely learned the most from this class. For reference, I've taken CN, GA, GIOS, IIS, NS, AOS, HCI.

The exams in this class are absolutely brutal and unfair. It is honestly incredible that the TA's are able to come up with such convoluted and ridiculous questions. Completely ruins this class, the lectures do not prepare you for the exams AT ALL in my opinion. That is, the exams take the concepts taught in the lectures to the umpteenth degree of complexity. It's the type of class where the exams are written for the students to fail, which I think is ridiculous.

Needs a new head TA that isn't out to absolutely punish students.

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.

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.

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.

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.

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.

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.

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

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.

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.

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.

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.

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.

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.

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!

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.

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

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.

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.

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

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!

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.

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

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.

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!

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.

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.

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

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.

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.

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.

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.

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,

Quite difficult class. Lots of math. Good material.

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.

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.

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.

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

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!

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

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!

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!

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.

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.

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.

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.

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

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.

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.

ToDo

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!

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.

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!

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.

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.

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.

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.

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.

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.

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!

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.

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.

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.

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

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.

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!

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.

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.

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.

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.

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!

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.

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.

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.

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.

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.

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

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

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.