CS-8803-O04 - Embedded Software
Toggle to Select Spcific Semesters
Reviews
Course discusses optimizations done by compilers for embedded processors such as ARM.
- Part 1: Architecture: weakest part teaching-wise. I think HPCA would be better here.
- Part 2: Compilers: very clear and interesting.
-
Part 3: Compiler Optimizations: each lecture dicusses an optimization idea/paper for compilers. Very clear and very interesting.
- Projects: 1 coding project (teams of 2) and 1 profiling/compilation project (individual-based). The first project was very nice and challenging. All in C++. You need to buy a raspberrypi for the second project.
- HWs: 4-5 total. Take time to complete, pen and paper based. Couple of them needed writing small code snippets. Not hard HWs, but not easy either. Just the right level.
- Final was medium difficulty.
- The main problem (a big one) with this course was the TAing. Hope it’s fixed now.
- The name of the course is a bit misleading. The course deals more with compiler optimizations for embedded systems than programming for embedded.
- Even so, the lectures were well done and the required reading adds to the course. You’ll learn a good amount.
- The concepts are not overly difficult. or time consuming. The TAs for this semester were not stellar - this was the only real negative about the class.
4 homework assignments - require about 5-10 hours each applying lessons/reading - fairly easy 2 projects (1 with a partner) - requires about 40 hours total work each - fairly easy if you put in the time 1 comprehensive (proctored) final exam - takes the full 3 hours, only hard because the questions are not well formed and the required syntax is not suited for an online exam
Overall, I liked it, and I could recommend it if you ever plan to work with embedded systems (the under the hood knowledge is valuable).
I liked the subject matter which is why I took the course. I found some of the material quite interesting and some just okay but that is all personal interest based rather than anything wrong with the material. The good news is that the professor does a good job explaining things, material is interesting, and grading was generous based on understanding concepts rather than rote memorization. The bad news is that one of the TA’s did not do a good job of interacting with students on Piazza: some questions were ignored, some were marked as answered but still ignored, some were answered with short unhelpful responses (even condescending ones), and maybe 25% got useful answers. There were also a couple issues with mistakes on assignment and project requirements (incorrect assumptions and documentation, missing or incorrect files, etc. ) that didn’t get addressed until just before the due dates. If you work hard in this class you will do a lot better than you might feel like you are doing due to the frustrations with trying to get questions answered and clarify buggy requirements. If you are interested in optimizations for compilers for embedded architectures this is quite an interesting course. You just need to be able to overlook the frustrating lack of Piazza support.
Very good course but not a entry level for a student like me that just start to learn computer science.
very interesting topics. I took the first offering of this class online and as a result some of the assignments/projects were vague in their requirements, but the professor and TAs were very helpful.
The course name clearly doesn’t do much justice to the content. It’s got nothing to do with embedded software/programming. Close to 1/3rd of the course is dedicated to ILP, VLIW etc which are more an computer architecture topic. CS6290 will provides a more solid foundation in this area (although not specific to VLIW based processors). The next part deals with different aspects of compiler optimizations for VLIW based processors which was clearly more interesting. The lecture videos give a decent introduction to the topic & rest of the details had to be uncovered in the research papers on the topics. The assignments were mostly appropriate to the topics covered in lectures. The TAs as well as Prof. were always active on piazza to that was helpful. They regularly had office hours so there was never a dull moment during the course. Overall I would recommend the course if you are interested in very low level working of embedded architectures & compiler optimization for embedded processors.
I agree with most of what has been said about the Summer semester. This is a “1. 0” or “1. 1” version of the class however. The professor and TA’s were very active and helpful in Piazza. The only frustrating part for me was the homework being so vaguely or inconsistently worded, so the advice of waiting a day or two and reading Piazza very closely I would also second. The grading was fair however, and the homework did become more clear after clarifications via Piazza, so in the scheme of things this isn’t the end of the world. I would still very much recommend this class if you want to learn more about pipelines, VLIW, etc.
This course is NOT an introduction to embedded software, it is a graduate level course in Embedded Computing with sole focus on pipe lined architectures like VLIW. Most of the assignments are related to compiler optimization and scheduling. The video course material is riddled with errors and inconsistencies, explanations of topics are pretty weak and assignments come in verbose long paragraphs of text walls which also have some errors in them. So to do any assignments the best thing is to wait it out on Piazza and have all the questions answered before you begin to solve one. The best way i found to go about this course is to ONLY read the text book and do one of the many other compiler lectures (from CMU online) to understand the text. They should really throw away all the material they have created and make a new one. Honestly, this is one course you can absolutely do without (or you can audit in your spare time if you wish) not because of the course content but the haphazard way of delivering content mired with errors.
The grading is lenient so at least that is a positive and once you cut through the clutter, the course material is moderate difficulty.
Reviewing near the end of the course. Great course that focuses on how classic CS concepts like graph theory can be practically applied by tailoring software for embedded systems.
This class isn’t a hardware course, nor is it a course on how to write software for an embedded system. It’s a class on how software is manipulated to run efficiently on power, hardware, and size limited devices.
It covers: embedded system instruction set architectures hardware support instruction level parallelism pipelining and compiler optimizations that take regular code and compile it such that it can run on embedded systems.
The course was condensed for summer but I think we still covered the same material. We had 4 homework assignments (initially 5), each taking about 5-15 hours to complete over 2 weeks. There was one project, taking about 20-25 hours to complete over a moth. There were also homework assignments due during this time. I think the full semester may have two projects, and two more homeworks that were smaller.
There was a proctored midterm and will be a proctored final, the midterm took an hour to complete (you get two hours). The level of difficulty was on par with the homework, but the test is closed notes.
In the condensed semester there were 2 lectures series and a reading per week for the first half, dropping to one of each after the midterm. The hardest thing to keep up with is covering the material in order to do the homeworks and take the tests, I recommend watching at 1. 25 speed due to reduce time spent.
The project and one homework were C++ programs. You can do this in your own environment, but you will run some code on GT’s deepthought cluster via SSH. There’s no GUI, but all you need are basic Linux commands. The assignments were straightforward implementations of concepts from the lectures/readings.
Overall I highly recommend this course. If you are taking CCA, this course will apply some of the Graph theory concepts covered there.
First and foremost, with respect to computing, this class is the low level. You must have a solid understanding of theoretical computing architecture. (i. e. von neumann, registers , clocks , etc) ALso, if you’re also comfortable with C / C++ stl , this should be a breeze (as of mar27). If you want to get a headstart on the class, purchase the book and get comfortable with the VEX toolchain. You’ll be required to work on ubuntu on top of vagrant on top of GATech’s deep thought cluster. You can create your own local env to work on but it probably isnt a good idea.
The project and homework workloads have been pretty much alike. In both cases, the assignment descriptions have been vague and piazza has been a great help. The video material is nice and concise. We haven’t had an exam as of March 17th 2016. The first project was insanely ambitious and the next one sounds exciting. Overall I think it’s been okay for a first run of the course. I’m having a good time.
[Edit, May 11 2016] The final exam showed great improvement from the project and assignments before it. It was, in fact a very well produced exam, which evaluated the student’s knowledge and insight, rather than plain memory.
Overall, I still think it was a good first run with an inevitable learning curve from the staff side. Next offering will no doubt be much better.
Again: A lot of compiler plumbing is present in this course… and not one ARM Cortex processor.