6 ECTS credits
150 h study time

Offer 1 with catalog number 4016038FNR for all students in the 2nd semester at a (F) Master - specialised level.

2nd semester
Enrollment based on exam contract
Grading method
Grading (scale from 0 to 20)
Can retake in second session
Taught in
Faculty of Science and Bio-engineering Sciences
Computer Science
Educational team
Jennifer SARTOR (course titular)
Activities and contact hours
26 contact hours Lecture
26 contact hours Seminar, Exercises or Practicals
Course Content

Central to this course are a number of programming models, techniques and software patterns for structuring concurrent and parallel programs on multicore processors. For a number of these models, concrete implementations are described in the form of programming languages or libraries. A brief overview of the course content follows:
- Laws of concurrent programs: Moore's Law, Amdahl's Law, ...
- Multicore Architectures, distributed versus shared memory, memory hierarchy, GPU architecture
- Quick overview of concurrent models based on shared memory: locks, mutual exclusion, atomicity, data races, deadlocks
- Structured programming models and languages based on message-passing (actors, processes, channels)
- Programming shared mutable state using software-transactional memory on top of a functional programming language 

- General purpose programming with OpenCL using the data parallel programming paradigm (also for GPU)
- Benchmarking: approach, pitfalls, reporting

- Comparing and contrasting the different concurrency and parallelism models

More details about the course can be found at http://soft.vub.ac.be/teaching/multicore/

Course material
Digital course material (Recommended) : A Sophomoric Introduction to Shared-Memory Parallelism and Concurrency, Dan Grossman, Learning platform, 2011
Handbook (Recommended) : Introduction to Concurrency in Programming Languages, M. Sottile, T. Mattson, C. Rasmussen, CRC Press, 9781420072136, 2009
Handbook (Recommended) : The Art of Multiprocessor Programming, M. Herlihy & N. Shavit, Morgan-Kaufmann, 9780123973375, 2008
Digital course material (Required) : Slides Multicore Programming, Tom Van Cutsem, Learning platform
Additional info

This course is taught in English.

Comparison with the course "Parallel Systems" (Jan Lemeire)

Both this course as well as the course "Parallel Systems" treat the parallel execution of programs. To help you compare these courses, here is a short summary of the most important differences between these courses:

Parallel systems: focuses on low-level approaches to parallel computing.
Multicore programming: focuses on high-level approaches to concurrent and parallel programming.

Parallel systems: discusses the well-established techniques for message-passing and multithreading which have proven their value. Standard thread creation and synchronization is treated in-depth, showing the threats of this technique to the student.
Multicore programming: discusses cutting-edge, innovative, scientific approaches using higher-level programming languages.
Considers alternative approaches to multithreading, since standard multithreading is not scalable and not robust.

Parallel systems: concentrates on scientific computing, such as algorithms allowing data-parallelism (‘regular concurrency’), although all applications can be parallelized with the techniques. Focus on dedicated parallel algorithms, and optimization.
Multicore programming: focuses on concurrent applications with irregular concurrency, distributed systems, influence of concurrency on software architecture. Focus on parallelizing general-purpose software and exploring various languages.

BOTH discuss the current trend of using GPUs for high-performance computing.

Parallel systems: concentrates on understanding the low-level details of performance, parallel overheads, and the efficiency of the memory system when doing GPU programming, using a simulator.
Multicore programming focuses on the language side of GPUs.  We explore OpenCL and how it has to be general to support various hardware architectures.  

For Multicore: Slides as well as the code of all discussed models will be distributed through the learning platform or via the course website. References will be given to the relevant literature pertaining to each topic on the course website.

Learning Outcomes

General competences

Knowledge and Understanding: The goal of this course is the teaching of programming skills for the concurrent execution of programs on so-called multicore (and GPU) processors. The architecture of contemporary computer chips has changed significantly since the turn of the century, such that commodity computers today contain more than one computing core. If one wants to exploit the full compute power of these architectures, the programmer is forced to parallellize programs. First and foremost, this course provides a reference framework with which students can better understand what the differences are between sequential and concurrent programs. Within this framework, multiple abstract computing models, techniques and software patterns are explained.

Application of Knowledge and Understanding: a selection of the above computing models is explained in-depth by means of concrete programming languages or libraries based on these models. The goal is to have students acquire concrete and technical know-how on how to solve the problems regarding concurrent programming effectively and efficiently. We also focus on novel, cutting-edge techniques discussed in recent scientific literature. The student is also taught how to characterize the performance of a concurrent program and how to quantify it experimentally.

Making Judgements:
- The student should be able to parallelize a piece of software by using the appropriate programming techniques and/or by applying the right software patterns.
- The student should be able to independently make judgements on the quality of a concurrent program, should be able to detect errors or unwanted properties, report them and be able to remedy them.
- The student should, by means of experiment, be able to judge the perormance of a concurrent program on a multicore architecture.

Communication: An important part of this course entails the comprehension of precise and unambiguous terminology to describe problems and solutions in the domain of concurrent programming and multicore architectures. The taxonomy of discussed programming models should also make it easier for the student to communicate correctly about concurrent programming of multicore architectures. The course also devotes special attention on how to correctly communicate about benchmarks to describe the performance of concurrent programs.

Learning skills:
- The student acquires the skill of correctly using terminology to unambiguously describe a problem or solution to a problem.
- The student is taught the importance of classifying varying models with the goal of being able to compare them within a unifying frame of reference.
- The student acquires concrete programming skills that will remain useful beyond the specific field of study of this course.


The final grade is composed based on the following categories:
Oral Exam determines 30% of the final mark.
PRAC Practical Assignment determines 70% of the final mark.

Within the Oral Exam category, the following assignments need to be completed:

  • project defense with a relative weight of 1 which comprises 30% of the final mark.

    Note: Oral project defense during which the student should defend and explain the programming projects.

Within the PRAC Practical Assignment category, the following assignments need to be completed:

  • programming projects with a relative weight of 1 which comprises 70% of the final mark.

    Note: For the practical part, a number of problems are specified for which the student is expected to independently implement a concurrent program. The student has to be able to report both on the quality of the code as well as on its performance.

Additional info regarding evaluation

Throughout the semester, a number of programming projects/tasks are presented which the students are expected to solve individually. Students will need to submit code and will need to submit a written report on their projects. This report contains details about both the quality (design) and performance of the code written for the project.  It is expected that students will run their code on multicore hardware to measure and evaluate the performance in various experiments for this report.

The final exam consists of an oral project defense. During this defense, students will need to explain and defend their programming projects. They need to be able to relate concepts used during the projects with concepts seen in the lectures.

The final grade is determined based on the quality of the submitted programming projects (including source code and written reports) and the interview during the final oral project defense. Students must pass each individual project in order to pass the course as a whole.

Academic context

This offer is part of the following study plans:
Master of Applied Computer Science: Default track (only offered in Dutch)
Master in Applied Sciences and Engineering: Computer Science: Profile Artificial Intelligence (only offered in Dutch)
Master in Applied Sciences and Engineering: Computer Science: Profile Multimedia (only offered in Dutch)
Master in Applied Sciences and Engineering: Computer Science: Profile Software Languages and Software Engineering (only offered in Dutch)
Master in Applied Sciences and Engineering: Computer Science: Profile Web & Information Systems (only offered in Dutch)
Master of Applied Sciences and Engineering: Computer Science: Profile Artificial Intelligence
Master of Applied Sciences and Engineering: Computer Science: Profile Multimedia
Master of Applied Sciences and Engineering: Computer Science: Profile Software Languages and Software Engineering
Master of Applied Sciences and Engineering: Computer Science: Profile Web & Information Systems