ICS-E4020 Programming Parallel Computers

Spring 2015 · Department of Computer Science · Aalto University

News Overview Exercises Material Additional reading


Please note that all information here is related to spring 2015. You can find the web pages of spring 2016 here.


This is a practical hands-on course on algorithm engineering for modern parallel computers. You will learn how to design programs that make the best possible use of the computing power of multicore CPUs and GPUs.



Teaching assistants

Passing the course



There are 6 programming assignments, one per week.


The deadline for each weekly assignment is on Sunday, at 23:59. For example, the deadline of the first exercise is on 19 April 2015. The deadlines are sharp; you will only get partial credit if you miss the deadline. In case of illness, please get a doctor’s certificate and contact the lecturer ASAP.

Remember to compelete the prerequisite test as soon as possible, preferably already before the first lecture — it should not take more than 15 minutes to solve it. You do not get access to the solution templates before you have passed the prerequisite test.

Required assignments

Optional assignments

There are optional, more advanced tasks that you can give a try if you need more challenges or extra points:

You can solve optional assignments at any time during the course, by the end of the last week of the course — the week numbers above are merely suggestions. To have them graded, just include it in any of your weekly reports.

What to return

Each week you will need to solve one or more programming assignments. You will need to write code, test it, benchmark it, and write a short report. For each assignment, you will need to return the following files:

The report can be informal and short. Do not waste too much time polishing it. The report should show how well your implementation performs. A description of the benchmarks that you used, a table that summarises your measurements, and a figure that shows plots of the performance (e.g., the running time as a function of the number of threads, and the running time as a function of the input size) is sufficient, unless the assignment explicitly asks for something more.

Focus on scalability in your report: for example, how does the running time change as a function of the size of the input, and how does it change as a function of the number of threads. If the assignment asks for an improved version of a previous assignment, your report should demonstrate what kind of improvements you actually got in comparison with the previous version.

Where to benchmark

Use the computers in Maari-A classroom, or equivalent:

For remote access, first open an ssh connection to one of the general-purpose Linux servers (kosh.aalto.fi, lyta.aalto.fi) and then ssh to one of the classroom computers (albatrossi, broileri, dodo, drontti, emu, fasaani, flamingo, iibis, kakadu, kalkkuna, karakara, kasuaari, kiuru, kiwi, kolibri, kondori, kookaburra, koskelo, kuukkeli, lunni, moa, pelikaani, pitohui, pulu, ruokki, siira, strutsi, suula, tavi, tukaani, undulaatti).

More information is available in Aalto Inside in Finnish.

How to return

We will use Github to return the assignments. To pass the course, you will therefore need to know or learn the basics of the Git version control system.

In brief, the setup is as follows:

After the initial setup, the workflow will be as follows:

The teaching assistants will have access to the private repositories, and the grading of the exercises will be solely based on what was there in your private repository at the time of the deadline. Your source code should be in the task-specific subdirectory (e.g., mf1/mf.cc for task MF1) and your report should be in report/week*.pdf.

See the detailed instructions for more information on how to set things up. You are encouraged to use your private repository for any course-related purposes; just make sure that you have a stable solution in your private repository in the right subdirectory on time. If there are any technical problems (e.g., Github is down), you can also email your solution to the teaching assistants.


The teaching assistants will grade the solutions; follow the news in Noppa.

Your solutions must be your own work. You are free to discuss solution ideas with your fellow students but all code that you return must be written by yourself, and the same applies to your report.

Unless otherwise mentioned, each week each individual task (required and optional) is graded on the scale 0–5, using the following guidelines:

If you miss the deadlines or if you want to resubmit your solution:

The course is graded as follows:

Note that writing correct code is necessary but not sufficient to pass the course; your code also has to perform well.


Your solutions have to be written in C or C++. You can use all features of the C and C++ standard libraries, up to and including the features of the standard versions C++11 and C11. You can also use OpenMP, CUDA, and GCC-specific extensions (e.g., vector extensions and intrinsic functions), as well as POSIX functions (e.g., posix_memalign). Make sure that your solution compiles fine on the classroom computers, using g++-4.9, gcc-4.9, g++-4.8, gcc-4.8, or nvcc.

Your report can be produced by whatever tool you prefer, as long as you can produce a readable PDF file with tables and plots (e.g., Latex + R or Word + Excel). However, in every report there has to be at least one plot that shows the performance of your software. Plain-text reports without any figures are rejected.

Course material

There is no textbook. Lecture slides and additional material will be posted here.



Other material

Additional reading


Programming: OpenMP and shared memory

Programming: SIMD

Programming: CUDA

Programming: other

Tools: version control

Tools: profiling and debugging