CS-6291 - Embedded Systems Optimization
| ESO |
Toggle to Select Spcific Semesters
Reviews
As others have noted, this class is more focused on compiler optimizations for embedded systems. I was not brave enough to take the compilers course and opted to take this instead. I found the class to be challenging but interesting. One of the reasons I took the course was to get some more familiarity of graph algorithms and I was not disappointed. It was nice to see how graphs are used for various compiler optimizations.
Projects:
The class has two projects, one of which involves writing a VLIW scheduler in C++, and the other involves running performance tuning experiements on a raspberry pi. The first project took me around 40 hours or so spread out over several weeks, whereas the second project took about half that time. I enjoyed the first project quite a bit and it was one of the highlights of the course for me. I was not as engaged in the second project and at times it felt like a chore, but I did learn more about working with my raspberry pi which was nice.
Homeworks
The homeworks vary pretty greatly in difficulty. I ended up spending a lot of time on homework 1 because I was really paying attention to the detail of determing the schedule. Homework 2 took me a couple of hours. Homework 3 was pretty difficult and ended up being my lowest mark in the course. Homework 4 isn’t too bad, but I ended up missing some small details that cost me some points that I wasn’t expecting.
Exam
The exam was pretty stressful since it was the only exam in the course and constituted 33% of the grade. The homeworks do a pretty good job of making sure you are ready for the exam, but be sure to review all the lectures as there were some topics not in the homeworks that ended up in the exam.
Teaching Staff
The Instructor and TAs for the course were great. There was a weekly office hour that I was never able to make, but I think it is pretty cool when the professor is a part of them. The TAs were dedicated and were dilligent in answering questions in piazza. You could tell that they wanted the students to succeed.
Overall, a pretty interesting course that covers compiler optimizations. The summer schedule is tight, but not bad enough that I wouldn’t recommend taking it in the summer.
An update from Fall 2021 - the course structure and content mostly remained the same as Spring 2021 reviews. I paired this with CN, and it was definitely hard to deal with both, but manageable if you’re willing to sacrifice free time. That being said, it was definitely a satisfying course with loads of learnings at the end. Like other less explored OMSCS courses, this course also suffers from the mildly unclear project/homework instructions perspective - but it isn’t a major issue since the TAs are always on the lookout to clear any questions on Piazza. The only complaint I have is the distribution of the weights with the final exam being a major chunk (33%) of the final grade. With the final project also making up 17%, you’ll be left unsure on which grade you will land on even after finishing the exam - and I personally think the projects should be weighted more.
Mixed feelings about the course, mostly positive. Like most less commonly taken courses in the program, it suffers from a lot of underspecification and ambiguous language on the coursework. The TAs and the prof will help you out but it really shouldn’t be necessary after all these years to have people asking the same questions over and over on Piazza because they haven’t sharpened the wording on the assignments.
Project 1 and some of the homeworks were very cool and did a great job of building a better understanding of the material. The course is heavier on the compiler-y side of things rather than the embedded side, but you get some decent exposure early on so it is a good choice if you like both subjects. Project 2 honestly just felt like busywork so I’d prefer it if they upgraded Homework 3 to be Project 2 or made a more interesting Project 2.
The final kind of felt cheap because you can lose huge points on questions that build on themselves. For example, earlier in the course (and even for another course before that) I wrote a working program that answers a question on the final, but because I made slight errors working it out manually on the final closed-notes I lost like 15%.
A lot of the multiple choice questions on the final are illogically constructed from a question making standpoint. For example, why would you make a question whose answer choices are True, False,
TL;DR the content is good but be ready to take a gut punch on at least one of the homeworks and possibly the final unless you really, really rote memorize and scour the readings.
Students had to do a lot of the guess work; what they want, fixing a lot of issues with either the “grammar” and language of the questions, or fighting the autograder.
Most if not all foundational and theoretical questions was either never answered, answered wrong, or ignored, or my favorite, a great TA start saying “I haven’t looked into that…” and shares a wiki page as if I don’t know how to google around.
Beside Tyson, the head TA who have been on this course for 2 years, who spent majority of his time figuring out the Autograder and other course logistics, we had no other person of acknowledge, including the Prof. (beside the office hour) to answer our questions. Tyson is truly a nice and great guy, the problem is that we were the first to be used on this new autograder, which is going to be great for the student coming after us, but left us with other two TAs who are either absent or know almost nothing of importance.
(I mean, on time, a TA asked what OS stands for!!)
To improve this course, bring on TAs who are knowledgeable, not showing up the night of the exam (when there is already piazza silence period) to answer questions. If not, the Prof. have to show up on piazza every now and then and answer questions. 60% of the material is based on the Prof. papers, no one will know it as much as him.
The homework overall are not bad – there are some “language” issues as in how it is described. For example, Some TAs didn’t know the difference between Instruction and Operation until Tyson had to make a post. And this is an extremely important distinction when we talk about VLIW.
The summary:
The course is amazing, most students who join this course love this low level details. The lectures are long, but mostly organized and well done – though they could benefit from an update. The homework, Head TA did great job working on automating the grading, although we suffered but it will certainly elevate the course for next students. TAs are mostly don’t know more than those students – sometimes the student knew a whole lot more.
Project 1 is great, just another problem with wordings, and Project 2 is obsolete and needs to be either completely removed and replaced by homework 3 (homework 3 is harder than project 1) or a new project is even better.
The course is a complete to the compiler’s course by the same professor, if you take one, I recommend don’t take the other.
This was my first course, and my first actual engineering course. My formal education background is in social science, but I have been programming since 4th grade. I am currently a full-time Senior Software Engineer.
I loved this course. It was challenging, but most of that challenge came from my lack of graph algorithm experience. Graphs are EVERYWHERE here. Be sure to understand how to traverse, explore, and build graphs in C++ and Python.. Just about every optimization was a graph of some sort. With a good grasp on graphs and a decent background in Undergraduate Computer Architecture, you should be well prepared for this class. Basically if you can write some basic assembly (even theoretically), do a breadth or depth first search, and are prepared to see these things collide – you’re good to go.
Professor and TAs The professor was at every office hours and did a great job answering questions. He really is an expert in the field and a pretty good communicator. But, I never saw him on Piazza. The only communication with him you’ll get is in the office hours. If you have a question for him, you can mention it in Piazza and the TAs will bring it up during office hours. The office hours are also recorded for later use.
The TAs worked really hard and were timely in their responses. They were all active on Piazza. It was my first class, so I have no comparison, but I have no complaints about the TAs.
Instruction and Homework The videos were decent, though there are some errors in the quizzes. Be sure to check out the Errata repository on github for the correct quiz answers. Also, not all the material is really covered in the lectures. Especially the papers are important to read. The lecture may mention an algorithm, but the actual algorithm itself is in the paper. Read the papers.
Beyond the course videos, there is only Piazza and a weekly Office Hours.
The Homeworks/Labs are all over the place. Some coding, some reports, and some “work through the algorithm” where you can do it manually or coding. For the most part, I spent about 10 hours on each homework – EXCEPT for HW3. It involves a lot of coding (in python) and was challenging. This one homework was by far the biggest time commitment I had. Even more than the projects. There are 4 homeworks total.
The two projects are really interesting. One is all coding (in C++), building a very small part of an embedded compiler from scratch. The other is more like a research project – profiling some code, making modifications, and justifying your results. I enjoyed both and they both seemed to be generously graded.
The coding seemed evenly split between C/C++ and Python. Basic C/C++ is all that’s needed. I’m definitely not a C++ wizard and I got a 100 on all the C++ pieces.
Exam The final exam is a full third of your grade, and this is what caught me. Not that it was unfair – there were no trick questions or surprises. It was just difficult and time consuming. Be sure to actually work out the various algorithms. Be sure to know the concepts. Honorlock worked great (for me). I felt like the course prepared me for the exam, even if I didn’t prepare myself as well as I should have.
Overall I really enjoyed this class and it was a great first class. It doesn’t require so much background knowledge and is a medium workload (for me). The topics are interesting (to me).
Just recognize that is is really a “Compilers for Embedded Processors” class (as most of the optimizations have heavy compiler involvement). If you (like I was) are expecting this to be “optimizing applications for IoT” that’s not what this is. It’s a layer below the applications. It also helped me fall in love with compilers.
Good luck!
I got no background in computer science, how ever this is a very interesting class for learning about computer architecture and compilers, I certainly learned a lot. The TAs always reply to your question almost immediately and there is a 1 week class that is pretty good, it makes you feel like you are physically there. It is not an easy class, and for the projects and homework’s, it doesn’t used Bonnie (the software that gets you project graded before submitting, which allows you to catch dummie mistakes). I lost points in most of the homeworks for getting confused in dummy things, instead of not understanding the subjects and at least for me the material was overwhelming (although very interesting and well explained). I really recommend this class for someone that is up for a hard but introductory class.
This was my second course and overall, I liked the course as it covered computer architecture basics , Compiler basics and register allocation phase of compiler. The second half of the course covers papers presented by Dr.Pandey which includes different optimization techniques that embedded systems can apply for register allocation. The lectures do a good job of explaining the idea behind each paper. Homeworks and Project 1 are certainly challenging and will easily take entire weekend. Prior knowledge of C++ , Python and Computer Architecture is certainly required to succeed in this course. There are some inconsistencies in lectures and homeworks, so make sure that you clarify everything from TA. TA’s are usually responsive and Dr.Pandey holds office hours every week. I would recommend this course if you would like to learn more about compiler backend.
Absolutely fantastic course!! This was my 6th course and I easily rank it in my top two. For context, I am not coming from a CS background or career.
Content:
The first portion of the course is a quick review of computer architecture and VLIW code as they apply to embedded systems. The remainder of the course focuses on compiler based optimizations for embedded code.
Lectures/readings:
Very well put together and organized lectures with complimentary papers. There is a disconnect between the canvas and udacity organization/ordering due to some issues with udacity a few years ago but it shouldn’t be an issue as I’ve heard udacity is going away soon. The lectures are directly related to the homeworks and provide all the info you should need to complete them.
Homeworks:
There were four homeworks which tied together very well with the lectures and readings, probably better than any other course I have taken. Generally they had a coding portion (building out python functions) and a conceptual portion related to something in the lectures or readings. Not too hard but can take some time (10 - 15 hours each). Don’t wait until the last minute.
Projects:
Project 1 was building a vliw scheduler in C++ and was very time intensive (40+ hours). The instructions made it seem very overwhelming at first but once you get going, it makes a lot more sense. Know graphs and graph algorithms very well if you want to get a head start. I had a lot of fun with this project.
Project 2 was testing various optimization techniques on a raspberry pi. There is a lot of value in this project if you have never done a system optimization before - you really get to see how and why there is no “right answer” to optimization. If you’ve done what I’ll call “guess and check” type optimization, its very boring, tedious and you probably won’t get much out of it. But at least I learned a little more about how to communicate with and run my raspberry pi better. Time-wise, I lazily put together a test plan over a week or so and did the entire project on a Saturday. Don’t take that as a good timeline for yourself - I have years of similar (FEA) optimization experience.
Exam:
There was one exam at the end. It was hard but fair, no trick questions or anything you hadn’t seen before. It took about 2 hours. Just make sure to study the homeworks.
TA’s/Professor:
Excellent team of TA’s who were very active on Piazza. Professor held live office hours each week with recordings available after.
Overall:
One of my favorite classes in the CS specialization so far. I would highly recommend if you want to get a more through understanding of not only embedded systems, but compiler/architecture based optimizations as a whole. I would recommend taking HPCA before this course as it lays down a very good framework for what you work on in this class. As a summer course, it is fairly fast paced with an assignment due every ~2 weeks - during a regular semester it would have been paced perfectly. I would probably have marked this as medium difficulty during a regular semester.
My Background: I have a bachelors in Computer Science. I’m interested in topics like Operating Systems, Distributed Systems, and High Performance Computing. Going into this, I thought this would be a nice introduction to Embedded Programming.
Turns out, this was not exactly the case. It was much more than I anticipated.
Course Summary: Embedded Systems Optimization introduces one to the architecture design of Very Long Instruction Word (VLIW), with comparison to others, like RISC, CISC. DSPs and Superscalars were shown, and the latter was quite interesting, since most older video game consoles that I know of have a processor of this type! After that, software becomes the primary focus, explaining the very important role of Compilers when it comes to software-influenced architecture designs such as VLIW.
Understanding Graph Theory is crucial for the latter portion, since a lot of these optimization techniques use a form of a graph.
The Homework Assignments: Most of the assignments refer to the lectures in some way. However, just relying off of them for said knowledge was not an effective strategy. Two of the assignments had a programming portion with use of Python, and then one in C++. Nearly all of them required to draw a graph in some way. I would look into GraphViz if this continues to be the case.
The Projects: As the other reviews have stated, the first project entails writing a scheduler following the principles of VLIW. This is done in C++. The hardest part involved interpreting a required algorithm from the Compilers textbook.
The outcome of the first project provided enough incentive to pursue Test Driven Development, in addition to reconsidering my learning style. This was a good thing, since it prepared me well for what’s to come with the rest of the program. This likely won’t affect you, but I thought I’d mention it anyways.
The second project, however, was much easier. It was a matter of developing your own heuristics when analyzing the code’s size to performance when compiling between ARM and Thumb.
The Exam: It’s more or less like all of the homework assignments combined. Nothing was unexpected, thus I’d say it was a fair assessment.
Overall: 3.5/5. It was interesting, but I would not recommend this as a first course. I would recommend taking something like High Performance Computer Architecture and Compiler Design first before going into this course.
I’ve found this class interesting and useful. The class material covers low-level aspects of processor architecture and microarchitecture, including compiler basics and generated code optimization techniques like register allocation and others – all with the emphasis on embedded systems. As a background comparison – I did have quite a significant prior experience with various processor designs and architectures, but almost none related to compilers and other topics, so have learned a lot. The course also covers several papers by the professor Pande (the teacher) – some are pretty interesting, not everything would be applied in everyday practice, but they provide good overview of the applicable ideas and theory (e.g. graph theory applications etc.)
I do mark this course as “easy” – as I believe the material is very manageable difficulty wise, but it did consume a great amount of time, primarily for reading and assignments, so you can only make it easy if you invest a lot. This was my only course during the semester (first course into the program), working full time (albeit, 100% from home with rather flexible and independent work planning), and also with family/children etc. commitments. I repeat, this course consumed a lot of time for me.
Logistically, I think the course was run very well. There has been a substantial improvement in the time for getting the grades back (if compared to the reviews from the previous semesters), everything was graded within a couple of weeks, including the projects. There are weekly office hours (recorded), the teacher Dr. Pande attended almost all of them, he is very enthusiastic about the course and is keen to propagate his material and is very supportive to the students. There are weekly Piazza announcements suggesting the pacing for the current week – lectures, reading etc.; all looked very organized. There were occasional errors in those announcements seemingly from automation, not a big deal, I believe those will be rectified.
The lectures are OK, I found some lectures of the first part (processor architectures etc.) having too many small inaccuracies/ambiguities, and in general sometimes there was a feeling the lectures could be improved. However, they provided a good walkthrough and overview of the material – I always read the appropriate textbook parts/papers before the corresponding lecture, which I thought was the most efficient way.
There were 4 homeworks and 2 projects – won’t repeat what others have described, I found the homeworks mostly pretty useful for practicing the material. Not all the material was practiced in the homeworks, but the main aspects were. The last homeworks had extra credit for coding in Python (this is likely to be enhanced in the upcoming semesters), which was nice, and I did like the coding parts (mostly not difficult at all).
I did like the first project (basic VLIW compiler scheduler design based on a given algorithm), the only issue of significance was the VEX simulator used for profiling the results - non-determinism and other problems (hint - run several tries and choose a consistent metric from the log files). I didn’t like the second one (running profiling experiments on Raspberry Pi on ARM vs. Thumb code annotations) – but I accept it did have a purpose, it just wasn’t very interesting and didn’t appeal to me in terms of learning something new or designing something. There were no longer group projects in the course (they’ve reached the conclusion it was not that efficient for learning purposes), which was a very good thing for me considering time difference and the way I preferred it in general.
Some homework and project items contained a degree of ambiguity in terms of wording/definitions etc., so Piazza is your friend in this course. The TA-s were pretty active and responsive on Piazza, sometimes there were indeed windows of silence (days long) – could be improved, but in general I didn’t have anything unresolved up to the submission deadline, for example. Interaction between the students was useful as well.
The exam wasn’t easy (33% of the grade), and my mark there was worse than for any homework/project, but it wasn’t too bad either, overall no complaints and no real problems navigating to a good result, i.e. A in total.
I’ve planned this course as a first course into the program, and I’m happy I’ve done it this way.
Prerequisites: as others mentioned, basic Python, C++ for Project1 (don’t worry about inheritance etc. – what’s more needed is practical usage of containers like vectors/arrays/sets etc. to manipulate and navigate graphs and related structures), basic graph theory, basic processor architecture/micro-architecture concepts.
Overall, a pretty interesting and tough class. I would not recommend this as a first course unless you have a strong background on low-level concepts, or are interested in this kind of topic. This class touches on topics also covered in HPCA and Compilers. There may be a tiny bit of overlap with the Software Analysis and Testing class, too. None of these classes are prerequisites, obviously, but ESO seems to be in a similar realm as these other classes—low-level and a lot of theory. Topics include register conflicts, VLIW, VEX, encoding, dataflow analysis (liveness), parse trees/syntax grammar, differential register encoding/differential remapping, register/variable access graphs, etc. The class essentially covers ways to optimize executing a piece of assembly code.
Homeworks - There were 4, in total. For the most part, they reinforced the topics from the lectures and readings. In my semester, there were some extra credit opportunities due to the fact that they were trying to automate the grading process and make grading go faster. So, if you were able to implement some topic into code form, you get a couple of points. They asked that this be done in Python. It’s likely sometime in the future that writing code will be the main component of the homework. I would say that the algorithms to implement are what you’d expect a graduate-level CS student to be able to implement. You should know recursions/graph algos/etc.
Projects – There were 2, in total. The first project was to program a VLIW scheduler in C++. Personally, I think this project could’ve been in any programming language since the whole purpose is to parse in some text and do some fancy juggling and spit out an assembly file. Create some custom data structure classes and you’re good to go. The second project was not much coding; mostly just running programs that were compiled using heuristics on the Raspberry Pi (yes, you’ll need to get one; they tell you this first thing in the course).
Exams – There’s 1 cumulative final at the end. Personally, I think it would’ve been better to just structure this as couple of quizzes throughout the semester; or break it into 2 exams (midterm + final). It does feel hectic to reach the end of the semester and then have to jump all the way back to an early topic that I haven’t looked at in a while. Difficulty-wise, I’d say the exam is fairly difficult on the account that it’s quite comprehensive. Making sure you understand the homework throughout the semester is a big plus. There were a few conceptual questions (maybe 15%-20% of exam).
Lectures – Lectures were fine. There are some topics that feel rushed, but most of the lectures also have accompanying reading material. I normally am not a fan of papers, but I did feel that the papers assigned for this course were pretty interesting and easier to digest than some of the other courses I’ve taken (despite this being so low-level). Prof. Santosh seems to be really passionate about this topic and it shows. Fun fact, he also teaches Compilers: Theory and Practice, so if you’ve taken that class, or want to take it, there are some lectures that overlap with ESO.
Teaching staff – Office hours are hosted live every week to go over questions. Prof Santosh attends all of them. I’ve never attended any, but they offer students the opportunity to post questions ahead of time so they can touch on them during the OH, which is nice. OH’s are recorded, too, for later viewing. My only complaint is that it feels like the teaching staff is a super slow about responding to Piazza posts. Sometimes, it takes them almost a week to respond to questions—as if they only sign onto Piazza once a week. I felt like the other students were more helpful than the staff. Maybe they were trying to foster a learning environment between the students? Hmm.
Verdict – Take the class if you like this sort of stuff, otherwise don’t. It’s not a particularly easy class; it takes time to digest the topics and complete the assignments. With the way homework and projects are sprawled across the semester, some work times/due dates overlap. Truth be told, I only took this class because I needed to fulfill my requirements so I figured I might as well suffer through it. I took this class while taking two other classes (as I was trying to overload and complete the program early), and while working part-time. This was one of the few classes with openings/small waitlists by the time I got approval for my third course—which I suppose is not surprising given the course content. It’s probably not too bad taken on its own. I did feel like I learned a lot, though. I also appreciate that the class is very straightforward; you’re presented with solid information from lessons/readings and are expected to apply it. I did not feel like there was any subjective grading or surprises. This class definitely feels a lot more like a solid graduate-level CS class than some of the other classes I’ve taken. Some of my other previous classes felt disjointed—like the lessons did not quite correlate with the homework or projects (probably indicative of the teaching staff attempting to change up the course material in discrete parts, and it ends up not flowing very well), but this one was pretty solid.
Summer 2019:
I took this course for understanding compiler internals and the current optimizations in compiler design. This course covered my expectations and did a good job at it. I had completed HPA prior to this and found this course picked off from where HPA had completed (at lease in some of the concepts). So I would recommend some prior reading if you havent already taken HPA.
Like in the case of HPA, I found the HWs and exam tough (there was a single comprehensive exam). Although the concepts were straight from the lectures and reading material, and the questions were straight forward too, I tend to make mistakes during calculations and that reflected on the HW scores. I did scrape through to an A in this course, but it was only due to the projects. The projects were straight forward and helped solidifying the theoretical concepts and were all in python/c, so knowing these languages would be recommended.
I would not recommend this as a 1st course since it helps understand processor architecture and optimizations there before taking up this course.
CONTEXT: I took this class over the summer so there were only 30 students in the class. This was my first embedded systems class and my 3rd class at OMSCS.
OVERALL: 4.0 /5.0. The professor Santosh Pande has done quite a bit of research in the field and found him knowledgable with a deep understanding of embedded systems. He also is an effective teacher, building his concepts from the bottom up so when you get to higher-level topics you know exactly what’s going on. The first half of the course deals with getting the foundations of embedded systems under your belt. What are the special considerations needed, taking it from the microarchitecture to the ISA to the compiler. The second half of the course focuses on his own work and research in optimizations for embedded systems. The section of lecture roughly corresponds to a paper which he published.
PROS: Office hours every week.
Homework is straightforward and easily grasped if you pay attention in lecture.
TAs are very responsive and usually provide good insight into what you need more clarity on.
The first project really ensured that you had a firm understanding of how VLIW worked and felt was one of the highlights of the course.
The final was fair and asked questions which made you think and solve problems beyond just rearranging a few things from a homework question.
CONS:
Quizzes and homework were fairly easy and did not require a great deal of brain-power. There was a lot of manually filling in the blank rather than programming and coming up with algorithms.
The second project was more conducting an experiment and with a lot of repetitive measurement taking rather than actually programming.
Homework and projects are more academic and conceptual based.
I don’t know what other courses are like and I’m sure I need to lower my expectations coming from brick and mortar classrooms but I feel compelled to give this course a bad review. The homework was vague and the lectures were disjointed. The last homework didn’t even reference the lectures relevant to the questions so 50% of the time spent doing it was just searching for the right content. The final was done on proctortrack the security measures of which are incredibly debasing and only a small portion of the browser window was used for displaying the question, forcing you to scroll between as little as three sentences.
If my next class is similar, I’m not sure I’m cut out for this.
This course is 33% computer architecture, 33% compilers / software analysis, and 33% papers on various hardware optimizations for embedded systems. There is some overlap with SAT, HPCA, and probably Compilers, so it may be a useful survey course if you’d rather not take all of those individually.
I ended up liking this course after it was done, but it was pretty stressful to take during my first semester in the program. My background is all bare-metal embedded firmware, and I haven’t been in school for a while.
- Course Content:
- The course covered a lot of material - a variety of topics in computer architecture, compilers, and analysis, all focused on features that are attractive to embedded systems.
- The readings (excerpts from a couple textbooks, and several research papers) were generally pretty good.
- The lectures were relatively thorough but weren’t always clear. I found it most helpful to do the readings first and then watch the lectures - it seemed to click better that way.
- I took this with SAT, and the material in both classes paired well together.
- Homework
- There were 4 homework assignments, each took me around 4 hours. I wrote a lot of little Python programs to help find answers, and used Visio to draw all the graphs. They were hard but matched up well with the material
- Projects
- There were 2 projects, both pretty difficult
- Project 1 was a beast. It’s a group project, which always incurs some overhead. We had to write a program that would schedule VLIW assembly operations to improve performance. It was all in C++, and the output code could be tested on a VLIW simulator in the class VM. I put in around 60 hours on the project, and my teammates probably 30-40. The instructions weren’t always clear, but the TAs were available to clarify and provide direction on Piazza. It was super stressful, but in the end the code our tool produced ran clean, and we got a good grade.
- Project 2 was a bit easier but still tough. The goal was to optimize ARM code by deciding between ARM and THUMB modes for a set of benchmarks that run on a Raspberry Pi. You were free to do this project in any language (or even manually), so I chose Python. I spent ~30 hours on the project. It was extremely helpful to spend ~4 hours up front automating my test environment, so that I could deploy and test new heuristics quickly and safely. The heuristic they recommended you try was pretty difficult, and I’m still not sure I did exactly what they intended, but I managed to pull something together and got a good grade on it. Even if you don’t get the fancy heuristic running, I think it’s important to design, test, and clearly report on something, even if the heuristics you end up with are pretty simple.
- Exam
- There was only one final exam. I really didn’t like it - it was confusing and difficult, and didn’t fully match up to the course material. It wasn’t integrated with Canvas yet (it used ProctorTrack’s website instead), which wasn’t great. I thought the grading was pretty accommodating, and I got an A, but I left the exam feeling pretty nervous
This was a tough class. The material is properly complex (i.e. actual graduate-level thinking required) and the volume of material is high compared to some of the other classes. The tests are comprehensive, so you will actually need to pay attention to the lectures in order to be successful.
The projects are fun! The group project was fun, but I’m never a fan of group projects at school thanks to potential impacts on grades from other folks who don’t necessarily pull their weight or drop the class without telling you.
If you are interested in compilers at all, this is a good class and enjoyable. It is tough, so be prepared for the workload.
This is a compilers for embedded systems class. Nothing else. Also i took it Fall 18, doesnt seem to be a choice. Ended up with a B. The homework is often hard and long. Grading is super tedious, picky… etc. Half the time the assignments arent even close to clear on what should be done. They will release 4 revisions of the homework, sometimes the night before it is due. So even if you completed your homework the day it is assigned, you have to re do it the day before it is due. Group project was like 12k lines of code. One of my partners quit two weeks in accomplishing nothing, and the other one, made things more stressful. Awful class. Avoid at all costs. Avoid at all costs. Avoid at all costs. Avoid at all costs. Avoid at all costs. Avoid at all costs.
This is NOT an embedded software course. This is a course about compilers, and research that is over 10 years old which is not going to be helpful for anyone working in or wanting to work in the embedded world.
The logistics of the course is a nightmare, the lectures are all over the place and none of them do a good job of explaining anything. The grading is extremely slow a week before the final we only had received grades for 30% of the class total.
The course material is also questionable at best. We go over vliw architectures at the beginning which is interesting, then the remainder of the course is on old research in compiler optimizations which will be useless for anyone in industry.
The lectures are terrible, the homework and projects are vague and hard to understand what is being asked. Do not take this class. The final was terrible and took a full 3 hours
I would not recommend this course to anyone, it being my first course has seriously made me reconsider weather I want to go through this program.
First, the good. Professor Pande is very enthusiastic about the course, his lectures are clear and useful. He holds office hours regularly and is present on Piazza and participates in discussions. The readings cover the required material, and although difficult to understand at times are adequate to complete most of the homework and projects.
The course is extremely difficult. The grading is inconsistent (different TAs), and not timely in any way. Project 1 and 2 grades were not available until after the final exam. The homework grades for 3 and 4 were available a day or two before the final.
Project 1 is a relatively difficult assignment to write in C++ a scheduler to reschedule a VEX assembly file using a variety of different scheduling methods. Test early and often, as the testing is non-trivial and non-obvious. The grading was relatively reasonable, but as mentioned above it was not graded until the end of the course. This is also a group project and groups were formed and reformed as students dropped. An extension was given due to this.
Project 2 is an analysis project – basically take code provided by the course and run it on a Raspberry Pi and analyze it. Then adjust the mix of instruction types and test again and again using different methods. It’s non-trivial, but not difficult. Again, not graded until after the final exam.
The homeworks were difficult and grading was not timely.
The final exam is comprehensive, proctored with proctortrack, and very difficult.
Unfortunately we had little idea what our grades would be until after the final was graded and posted. You get no chance to figure out if you should drop the course until it’s weeks too late.
Learned a great deal, it’s a good course but a difficult one, hopefully better TAs in the future will resolve some of the grading issues and make it a little better to deal with.
Lectures
- They are well designed and walk through the problems in full detail
Course Content
The first half is great
- Learn about Vex and a VLIW architecture
- Learn about compiler and register allocation strategies.
The second half is purely based on the research conducted by the professor and his team. The lectures only provide an introductory base for the paper and it is upto to the student to learn more. This workload is quite much.
Assignments
Are straight-forward and easy to solve
Projects
The first group project requires coding ability in C++ and to make something worthwhile requires good understanding of the topic as we are working with a real life example.
But the grading is not tough and easy to score.
Final Exam
Was on ProctorTrack, questions mostly from the assignments. Exam had a high average.
This is NOT an embedded systems course. This is a compiler course with the word “embedded” thrown in loosely. 99% of the optimization techniques mentioned in the course apply to all kinds of computing systems. Optimization techniques other than compiler are not touched upon.
The concepts taught are fairly easy to understand. The instructors make the class a little tougher because of labor intensive homework assignments and projects. There is not much you can learn by doing those assignments but the grading is generous, so you can get an easy B.
The final exam was through Proctor Track and closed book. The questions were a bit vague in my opinion and did not do a good job of testing my understanding of the subject.
If you think this can be a light-weight course to pair with a heavy course, think again. The mid term project and the homework assignments are quite labor intensive. Average work load is fairly low but it peaks when the assignments are due.
CS-6291 Embedded System Optimization (see also: CS-8803 - Embedded Software)
Course
I enjoyed the course because I like the material, and I knew what to expect, but some may find the material formidable.
I have completed several OMSCS courses, and can review the course in context with other OMSCS courses. I have software development experience, so I was prepared to take this course. The course introduced new concepts, and reviewed compiler concepts.
Embedded systems are pervasive and their role can only expand. The course compares CISC and RISC, examines chip complexity for general purpose CPUs versus chip complexity for embedded processors. RISC and especially ARM are the primary focus for most lectures. Issues such as pipeline, register count, datapath, memory and register banks, instruction latency and code size are studied. The volume of material covered is vast.
The course is presented as three distinct parts. Part one, “Embedded Systems” places specific focus on VLIW and VEX and increased parallelism. Topics include Computer Architecture, VLIW, ISA, Datapaths, Registers and Memory, and Branches. Part two, “Compilers for Embedded Systems”, presents an overview of compilers, then examines Control Flow Analysis and Liveness Analysis. This part deals heavily with graph theory, and includes register allocation and liveness analysis (fairly complex topic).
Part three, “Compiler Optimizations”, is a deeper dive into Register Allocation, Optimizations for Code Size, Differential Register Allocation, Storage Assignment, and Parallelized Load&Store, optimizations which cooperate to improve performance, reduce code size, or decrease power consumption. Innovations expand addressable registers, improve data througput and instruction parallelism through banked memory and registers, DSP and NP specifics, et al. Network Processor optimizations are also considered.
Lectures & Readings
The lectures require substantial time, but are worth watching. Dr. Pande does a good job explaining the material in the lectures. The lectures are dense, and you will spend substantial time each week keeping up with the lectures. Lecture content is back-loaded, and once you complete the first project, the majority of the lectures (and readings) lie ahead. Plan to accelerate your viewing and reading midway through the course.
The papers (there are a large number of papers), the VLIW and VEX documentation, and the textbook readings provide an enormous volume of material to cover. Be prepared to read, a lot. The volume of readings was overwhelming, nearly abusive.
Projects
There are two substantial projects. Both projects are challenging and require that the student demonstrate understanding of the relevant embedded concepts. The first project took about 50-60 hours (average 60), the second about 30-40 (average 40). Students were given 4-6 weeks for each project.
The first project was a group project (3 students) to ‘schedule’ instructions on a VLIW (parallel) machine. The project required parsing the assembler for a substantial subset of the VEX instruction set, rescheduling instructions to preserve semantic behavior, reducing critical path length and thus improve runtime performance. The project required C++, parsing, and graph processing.
The second project was an individual project where students determine how to improve performance or code size for programs built to run on a Raspberry Pi. This project requires that the student profile code, determine hot functions, choose heuristics, and compile functions for both ARM and THUMB instruction sets based upon heuristics and measurements.
Students needed a Raspberry Pi 3+, needed to cross-compile for ARM, transfer programs to the Pi, run experiments, and produce a substantial report.
Homeworks
Lest you find time to sleep, there are four homework assignments to consume your weekends. Each homework consists of multiple parts and demands extensive work and precise attention to detail. The homeworks compel one to deep dive into algorithms presented in lectures and papers. Keep current with lectures and readings and the homeworks will be less painful. One homework required coding, the others merely benefited by writing optional code (write the scripts and automate the manual work, you will be glad you did). Expect to spend 10-20 or more hours on each homework.
Final Exams
The final exam was cumulative. Since the amount of material is enormous, you need to learn the material as you progress through the course. The exam is fair, and tests important concepts explored by projects and homeworks. If you understand the projects and homeworks, the exam holds few surprises. However, the exam is 33% of the course grade, closed book, proctored, and over 3 hours long, so it could be very stressful.
Overall
- The amount of work required was enormous.
- Grading on the first two homeworks was quite brutal.
- The course requires tons of reading and tons of work.
- Over half the students who started the course dropped.
- The high drop rate eviscerated project groups, and forced reorganization.
- Concepts were not hard to learn, well supported by lectures and readings.
- Piazza became calmer and the remaining students were very helpful.
- Office hours were excellent; TAs and Dr. Pande very involved and helpful.
- Grading was glacially slow. One cannot blame the TAs as the assignments are extremely detailed. Some revisions to organization could enable more automated grading.
The various optimizations can appear chaotic and unrelated, but when you consider them as a variety of approaches to improving various challenges in embedded systems architectures, the course is fairly logical and well organized.
Nomenclature aside the homeworks require more time than some projects in other courses. The course has essentially 6 projects. There are some rough patches to the projects and homeworks, so ask questions on Piazza. The TAs were above average, but they do not hold your hand.
Only one homework was graded by drop date (less than 8% of grade), the third and fourth homeworks were not graded until the middle of final exam week. Grading for the first project was not completed until after the final exam, and the second project and final (50% of grade) are not yet completed.
Class averages were low:
- homework: 77%, 85%, 80%, 84%
- project: 90%, ?
- final: ?
Update: The first project is now an individual project, and there are no team projects. Much of the grading has been automated, so the grades are returned much quicker.
This class was a logistical train wreck. Interesting concepts for the most part, but overlapping assignment due dates, snail’s pace feedback, scatterbrained lectures, and a single exam as a comprehensive final at the end of the course with no types of tests/quizzes before then made for a very poor experience.
Project 1 is quite involved (creating a scheduler for a compiler) and working in teams of 3 is not great when people are still dropping the course. This project is hard enough that if one of your team members drops out or goes AWOL, you are in for some extreme pain. Make sure you have a strong background in C/C++. I had a little bit of experience but still needed to learn a good bit for this project. At a minimum you’ll want to at least understand pointers and basic function writing in C++. Also, the instructions really gloss over a number of mundane details which means the project is going to take a lot longer than you might first expect.
The 4 homeworks were fair, but it took forever to get grades back. It wasn’t until the final week we got back assignments 3 and 4. That gives you just enough time to study for the final, which they say covers everything, which is great since there are no other exams in the course to give you an ide of how to study. Also regarding feedback, neither project 1 or 2 was returned to us, so going into the final 60% of the course grade was unknown or undetermined.
As far as the conceptual content, the material is somewhat interesting but the second half of the course is a bit messy and lost in tangents because it basically covers all the professor’s research. You get a bunch of 40 page journal papers to read in addition to watching the lectures. The lectures themselves have a bunch of spots where things aren’t adequately explained and sometimes it feels like the professor recorded the narration while he was driving for all the thought he put into the clarity of his words.
Overall, this course seemed promising but ended up being quite a disappointment.
I took this Fall 2018. Overall this course offered a good overview of
(1) Design choices at the instruction-architecture level to meet a tailored use (specifically embedded systems).
(2) Basic functioning of compilers.
(3) Practice reading and understanding academic papers that focused on compiler optimizations.
I took it as my first course, very manageable on its own, and looking back i could have paired it with an “easy” course. However, do not mistake this class for a give-me, it had some very difficult portions and was closer to Computer Engineering than Computer Science for some sections.
Assignments:
- 4 Homeworks, all were straightforward as long as you ask some questions and review the material.
- 2 Projects. First one is a group project, second was individual.
- 1 Test, the final. Not easy, but fair and tested very similar concepts from the graded assignments and lesson material.
Coding was only required for 2 of the assignments:
- HW2 involved coding, in C++ .
- Project 1: was very difficult for me, it involved coding with graph algorithms and C++ to build an instruction scheduler.
- Project 2: coding was not needed, but a few bash scripts and/or python dramatically sped up how fast you completed it.
Lectures & Course Material (Books):
- In my opinion, ok. The book is a little old, but the foundational concepts it teaches are certainly still applicable.
- The lectures had small errata/errors hear and there, but TAs were responsive in addressing them.
The advice I would give is go to the office hours! Professor Pande showed up to every single one, along with the TAs, and all were more than willing to answer questions or address concerns to point you in the right direction. Also, and this is probably every OMSCS class, but start the assignments as soon as possible, especially project 1!! It is very do-able, but the 2 week delay my team took to get started turned it into a semi-hell for the last 3 weeks of it.
About to finish up first semester only taking this class.
I am a Mechanical engineering BS with some limited CS experience. I found this to be a good transition course. Concepts were generally easy to pick up on. First project (only group project) was the only real issue, workload for someone without much background was very difficult and time consuming.
The homeworks and second project were all pretty easy and doable given the timeframe. A good transition to software concepts and work for me.
Good god. This class to me was hard. Background is BS in Electrical Engineering, minor in computer science. Currently working as a web developer at a big tech company.
Another note, this is my first class in the program; big mistake. Very hard, and my fundamentals for this low level was not where it needed to be. I felt like I could handle the challenge, but with working full time and the difficulty of transitioning to school with this class was too much to handle. Writing this with 2 weeks left before the final and I feel like I’m still drowning in this class. Our first project was a group one, and groups had to be reorganized because so many people withdrew from the class. Concepts are difficult and information feels scattered sometimes. Very difficult for me. Didn’t feel like I had time to complete everything and the material is so dry. Made a mistake taking it, made a mistake not dropping it.
I wasn’t sure what to expect coming into this class, though I was both happily surprised and disappointed. If you’re looking for a class about embedded systems/software, this isn’t for you. This class is really about code size vs execution, optimizations you can do, when it makes sense to do said optimizations, and coming-up-with/discussing/profiling several heuristics around those optimizations.
The lectures themselves were only alright, but the projects were phenomenal.
This was my 7th class in the program, and by far my least favorite. The homeworks were fine, straightforward enough but the answer keys were never given. This made it very difficult to study for the final when it was unclear what the correct answers were to some of the homework questions. The first project was building a scheduler for VLIW code and I think I learned more about C++ (had never used it before) than actually scheduling. The second project used a Raspberry Pi and to be honest - was incredibly pointless. If you do enough research into what the project is asking you do to, you’ll realize that it is completely obsolete. The exam had a lot of weird questions and typos that made the questions even more confusing and was pretty poorly written.
The biggest annoyance I had with this class was the lack of responses from the TAs on Piazza. It would take days to weeks to get a response to a simple question, and most questions were left unanswered past the due dates for projects or homeworks that they were asking about. Even at the end of the semester there were almost 40 unread/unanswered posts.
Overall, I would not recommend this course until the revamp the homework/projects/test.
Just finished up Embedded Systems for the Summer of 2018. As an embedded hardware engineer, and having a strong hardware background in school, I found this class absolutely fascinating. It sort of fills a lot of “low level gaps” that you don’t ever really think about when it comes compiling code for embedded hardware. You will definitely need a strong C/C++ background going into this class. Other classes that I had under my belt from undergrad that helped me were Digital Logic, Digital Design, and Microprocessors. Working as a full time professional, I found the work load manageable.
I am not sure how this class flows during a normal spring / fall semester, but the summer semester it did feel pretty condensed and very quick pace, there was absolutely no down time in between lectures, projects, and home works. The home works and projects overlapped. During the first project, i had to stop working it, get the one of the homeworks done, and then pick the project back up, which i found kind of annoying. If you think you might need a slower pace, I would recommend taking this class in the fall or spring.
The lectures were done very well. Dr. Santosh is very thorough, clear, and concise. There were a few errors in some of the lectures, but they were usually pretty obvious when you came across them, and there was an erratta provided to give you a heads up. The lectures followed the reading material very well, which included the textbooks, and the assigned academic papers (some written by the professor himself). The class is very well organized and broken down into 3 distinct sections:
- Review of Computer Architecture and crash course into VLIW design philosophy.
- Compilers Compilers Compilers. Front end and back end.
- Compiler Optimizations (my favorite part of the class).
The very first lecture you dive head first into assembly language, if you have never had any experience with assembly, you might have some catching up to do, but i dont think it would be too overwhelming. This class assumes you have a working knowledge with the fundamental processor architecture building blocks, such as ALU’s, IR’s, Registers, Memory, Program Counters ect… so the first section is a pretty quick refresher, but it doesn’t really go into the hardcore nuts and bolts of how an ALU works for example. Parts 2 and 3 use a ton of graph theory, and a ton of graph theory algorithms , which i found fascinating. I had almost NO background in graph theory, and I was able to manage just fine.
For the summer semester, we had 4 homeworks and 1 project broken down into two different parts. The projects were pretty distinct from each other, so it felt like two separate projects rather than 1 project. Both projects were group projects. The home works were pretty straight forward, they pulled from the reading material and lectures, but they were pretty involved. When the homeworks get into the graph theory, I found myself writing programs to help solve the problems as they are not very practical to do by hand. For this, i mostly used Python. Homeworks were “pen and paper” style.
The first project was the most intense part of the entire course. It was done in C++. I work mostly in C, so brushing up on my C++ was pretty quick, if you haven’t had either, you will be at a disadvantage. I easily spent more hours on this project than I did on all 4 homeworks and project 2 combined, and then some. Enter my first complaint of the course: the project 1 description. it was vague, ambiguous, impervious to clarity, and riddled with copy/paste errors. I am not saying this to just complain, it really was pretty bad. It needs to be revised (See other reviews of this class, they will say the same thing). The TA’s were basically absent from piazza to to provide clarification, which was pretty frustrating. I had asked for clarification on one of the requirements via the project description (which was unclear), and I did not receive a response until the night before the project was due, by then I had already “made an assumption”, which ended up being incorrect. I had also already turned the project in, which I had to redo a pretty good chunk of my code and resubmit, which was absolutely miserable. The Deepthought Clusters stopped working about 2 days into the project, and this issue was never resolved. To overcome this, I ended up just putting vagrant on my machine and avoided using Deepthought all together. Some students wasted a good bit of time with service tickets / requests to no avail and a lot of wasted time. Despite all of this, I absolutely loved the project, it makes practical, a lot of theory and gives you a lot of appreciation for it.
Project 2 was pretty straight forward, and had an open ended element to it, which opened the door for creativity, which i really appreciated. For this project you needed to purchase a raspberry pi board, as the focus of the project was around ARM processors. This project was mostly analysis and very little coding, it did, however, seem to be sort of dated, as we were not using the most up to date ARM compiler. Not as interesting as the first project. Project description again, lacked in clarity one certain parts, some of which were never clarified by the TA’s. Deepthought still was an issue, and by this point , I think everyone was just using Vagrant.
The final exam was pretty terrible. For being 33% of your entire grade, and the only exam, it was a little bit stressful. It was cumulative, so it was a ton of material that it covered. I didnt really know what to expect. It is done via Proctor Track, which i felt like was completely inadequate for how they expected you to enter your responses. There were also mistakes on the actual exam questions, which i was hoping they were going to throw out, but I dont think they did. It was 3 hours, and it took most of the time to complete.
My only other complaint with this class was the TA’s, as i hinted above. Im not sure if they were just super busy or what, but they were just not around at all. Being a smaller class size, the student to student interaction was definitely not as active as other larger classes I have had, but the TA’s EASILY averaged a 2-3 day turnaround time with questions. Probably the worse TA experience I have had in the OMSCS program to date.
Grading was done very fairly.
Overall, I thought this class was pretty great, and recommend it for any hardware guys out there. This class certainly has a lot of potential, and is certainly one of my favorites in the OMSCS program. I think if they were to clean up the project descriptions, and just avoid Deepthought all together, it could be improved.
Overview
This was my second class in OMSCS and with no prior experience in computer architecture, assembly, C++ or compiler theory, I found it challenging. As others have stated, the course starts with computer architecture with a focus on VLIW then moves to compilers and wraps up with optimization techniques. I found it very interesting to learn the differences between RISC and CISC processors as well as the VLIW processor design philosophy. Embedded processors are everywhere (cars, phones, network equipment, control systems, etc.) and their unique power and performance requirements drive a much different processor design. In particular, embedded processors rely the compiler to do many of the optimizations that would typically be done on-chip in a desktop processor. Professor Pande clearly has passion in this area and several of the optimizations presented in the last part of the class are based on research that he has published in collaboration with others.
Projects
There are 2 projects in the course, and they are both done with a partner. You will be asked to pair up on your own so be sure to jump on Piazza as soon as this process starts so that you don’t get left in the dust. The first project was to build a scheduler which would take assembly-like input (VEX), build a graph data structure and then produce a parallel schedule. This project required C++. The second project really required more analysis and little to no coding. You will be benchmarking a couple of programs on the Raspberry Pi and then determining which functions should optimized. Although I absolutely love tinkering with the Raspberry Pi, I didn’t find this project interesting at all. One of the whiz kids in my class gave a detailed post about how one of the design goals of recent ARM processors was to completely eliminate the need to perform the sort of analysis that we were asked to do. The instructions for the second project were particularly poor and several fundamental questions went completely unanswered by the TAs. This is maybe the biggest area that could be improved.
NOTE: As others have mentioned, the project instructions talk about using the DeepThought system to compile and run your code but this is a complete waste of time. The entire thing can be done from a VM on your local machine and DeepThought is fraught with issues. I strongly recommend that you do not waste a single second on DeepThought. I suspect the TAs were new this semester and will help you avoid this pitfall in the future by updating the instructions.
Homework
There are 4 homework assignments which each took a bit of time to complete. Homework 2 required C++ programming but all the other assignments were theory only. I found it helpful to have a good diagramming tool (Lucidchart in my case) since several of the questions asked us to produce visualizations.
Final Exam
I thought the comprehensive final was fair but there were a few mistakes in the instructions that left me hoping the question would be thrown out. We were given 3 hours and I needed the whole time to complete. I think the homework assignments and lectures helped to prepare me, although I didn’t read a couple of the assigned papers and I’m confident that hurt me.
Summary
The content of this class was interesting and helped me fill in some gaps from my undergrad (computer architecture, assembly and compiler theory). Project 1 was fun but Project 2 felt completely obsolete and poorly supported. The homework assignments were a bit time consuming but manageable. Overall I would recommend the course.
This course covers compiler optimizations for embedded systems.
The punchline is that when you compile a program for a desktop operating system, you’re not sure what exact processor the application is actually going to be run on. Because of this, desktop processors offer a fairly generic interface: your compiler creates machine code that can be run on a desktop processor in general, and specific processors then optimize that machine code dynamically according to the features of that processor. But when you’re developing an application for an embedded microprocessor you usually know the exact specs of the microprocessor that your code will be running on: your compiler can optimize your code to that particular microprocessor, taking that burden off of the microprocessor, allowing the microprocessor to run more quickly and consume less energy.
If you’re interested in that, then this course is very interesting and illuminating. Despite my issues with the course, I enjoyed it. And you can read other reviews under the former course number: “CS-8803-004: Embedded Software”.
For the summer class, we had four homework assignments, two group projects, and a final. The homework assignments took me 5-10 hours each. The first group project–scheduling 4-wide VLIW code from a 1-wide sample–took me about 30 hours. The second group project–compiling media benchmarks to a RaspberryPi target and profiling the results–took me 10-15 hours. The final focused on the material covered by the homeworks and projects: I didn’t focus any final-study on anything that wasn’t in the homeworks or projects and I did well on the final. Like other reviewers, I wrote Python scripts to help me solve a couple of homework problems that would have taken too long to solve manually: when the assignment would ask for a “best” solution and there were many possible permutations, I wrote scripts. Where the projects required an Ubuntu machine, I performed my work on a local VM rather than using the GATech Deepthought cluster.
In some cases, the TAs were very helpful, and in some cases they weren’t very helpful. Grading on a few of the homeworks/projects was very fast and efficient. In other cases, grading was slow and frustrating. In particular, the students disputed two or three “correct” answers in the first homework. To the TA’s credit, they followed up and credited the responses that we demonstrated to be correct.
But in general, especially in our first homework, both projects, and our final, we did a lot of puzzling out exactly what was being asked for, or sorting through incorrect instructions. The final in particular took me almost the entire three hours for trying to decipher the questions: there were grammatical errors, poor formatting, unclear instructions–especially about what parts of our work and/or solution needed to be written down–and actual errors in the questions that made it difficult to complete the test. I did well, so I’m confident that I wasn’t just misunderstanding the questions.
In general, the course feels “rough”. If you look back over all of the course reviews–under both course numbers–that’s the consensus. Well, that’s fine enough for the first couple of runs, but this course has now been running for a couple of years. So I’m a bit frustrated at that. But ultimately I did enjoy the course and I did feel like I learned a lot.
Just finished this course (Summer 2018). For me personally, I expected it to be challenging going in as it was only my second course in the OMSCS program and I have no formal background in CS, or relevant work experience for that matter (I am an Officer in the U.S. Navy with a nuclear engineering background). I did however, have a pretty solid background programming in C and Python, which proved useful. The workload was manageable while also working full time. The course was condensed (summer course), so it moved rather quickly. It was not crazy difficult, but it was not easy.
I found the course material very interesting. The online lectures almost go hand in hand with the books and were mostly strait forward to follow. If you are like me however, and have had no formal background in computer architecture (VLIW architecture specifically), assembly language, a good working knowledge of compilers (i’m talking under the hood of compilers), or C++, it can be a bit intimidating at first, but it is still very doable. With a lot of reading and some external research, I was able to overcome the rather steep learning curve within the first few weeks.
This course was broken up into three major topics. The first is a “review” of computer architecture, with the emphasis being on a VLIW design philosophy. The second is a deep dive into compilers. The third section focused on four different and unique compiler optimizations (specific to embedded systems) which is the main point of the class, and really the most interesting part. The optimization portion was pretty thick with register allocation being one the most fundamental and key concepts to grasp along with lots of graphs and graph theory.
For the summer course we had four homework assignments, which required a bit of time and effort to complete. For at lease two of the assignments, I had to write Python scripts to aid in executing some of the algorithms used, as doing them by hand was not practical. Overall, if you go through the lectures and use the textbooks to supplement, the homework assignments are not bad, they just take a little time to complete.
The project was a group project, so you will need to partner up with others in the class. The project was advertised as one project broken up into two parts, which were completely unrelated, so really its two separate projects, both done with the same groups. The first project was quite the monster. We effectively made our own scheduler, which was done in C++. I had to learn C++ and do the project in parallel, so it took a bit of time. Also, the project description as written was insufficient to do the project, and do it correctly. This is really my first complaint about the class. Once you start getting into the meat of the project, you will quickly discover that there is much more that has to actually get done then appears at first glance. My recommendation is get the exact expectations from the TA’s off the get go….for everything. The second project requires the use of a Raspberry Pi board which you will need to purchase if you don’t already have one, and a little bit of C programming. Again, had some issues with the project description and required lots of clarification from the TAs. Also, to make things a little stressful, project due dates overlapped with due dates for HW assignments (by only a few days in both cases), so you really can’t waste any time.
The projects also required the use of the Deepthought clusters at GaTech, which you will be given access to. For me, and just about the entire class, this worked for about one day after which, I lost access to and was never able to get on again. If this happens to you, don’t waste time while the TA’s go through the hoops of submitted trouble tickets and figure the issue out. My recommendation is to install and understand how to use Vagrant. I was able to do the projects using the Ubuntu Trusty32 box which is made available and by using the Raspberry Pi board with Raspbian installed.
The final exam was the only exam for the class, and was not easy. It was cumulative in nature and took a good bit of time for me to complete.
Lastly, second and really my main frustration for this course was the TA’s. Going into the final exam, Piazza at a glance looked something like 40 unread post, 17 unanswered questions, and 34 unresolved followups (actual stats). Piazza was like a ghost town, and the TA’s were the ghosts. Usually 2-3 day turnaround time to get a question answered, and it was usually some vague one sentence answer which wasn’t useful. You will rely on your classmates in Piazza to be successful. To be fair, the TA’s were very reasonable with grades and everything was graded fairly.
Overall, I actually did enjoy the class as I found the material quite fascinating. I think the class would be easier if you went in well versed in C++, have taken a computer architecture course, and are comfortable with assembly language and assembly notation. The class could be improved if the project descriptions were rewritten and the TA’s were a bit more involved on Piazza. If they fixed these issues, I think this class has the potential to be awesome. Also, for someone with such little prerequisite knowledge, I did very well in the class.
This class was very much a mixed bag. The course material is interesting and the professor understands it well, but the lectures often were a little convoluted and hard to follow. The assignments and projects seemed a little rough; most of them were updated to include clarification/correction after being initially assigned. I believe this is the first time this class has been offered online. After another semester or two, once the kinks are worked out, I could see this being a very good class.
My biggest complaint with this class was definitely with the first (group) project. It felt like my group spent as much time trying to parse the project description and figure out the project requirements as actually complete the project. On the last weekend before it was due, we probably spent a combined 45-50 man-hours (on a 3-person team) trying to complete it and still didn’t finish. I think the instructors realized that the project was more difficult than they anticipated, because they ended up grading it very generously (I received full credit even though the project was incomplete). The second project was also much more reasonable.
Enjoyable course, we got to look under the hood of compilers and learn about different optimization techniques as they apply to embedded systems. The projects were time consuming and interesting. My only complaint is that due to the nature of the projects they took a long time to grade so we didn’t know about 75% of our grade until the week of finals. But everything was graded fairly and carefully with good feedback so all’s well that ends well I suppose.
Looks like this is the first review of the course, but it’s just because it used to be 8803 - see the one with embedded in the name for some relevant reviews.
I really liked the course, and a lot of it had to do with the main TA’s involvement on Piazza. The assignments are pretty straightforward, and the projects are not too bad as long as you get ahead on them and don’t wait until the last minute. Exam was meh - ProctorTrack sucks but what else is new.