Multicore Programming

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.

Semester

2nd semester

Enrollment based on exam contract

Impossible

Grading method

Grading (scale from 0 to 20)

Can retake in second session

Yes

Taught in

English

Faculty

Faculty of Sciences and Bioengineering Sciences

Department

Computer Science

Educational team

Janwillem Swalens (course titular)

Activities and contact hours

26 contact hours Lecture
26 contact hours Seminar, Exercises or Practicals

Course Content

In this course, we study different programming models, techniques and patterns for writing concurrent and parallel programs on multicore processors. We cover the following topics in the course:

An overview of multicore hardware and the laws of concurrent programming (Moore's law, Amdahl's law)
Core concepts: parallelism vs concurrency, shared memory vs message passing, speedup vs throughput
Traditional shared-memory models: locks, mutual exclusion, race conditions, deadlock, atomic variables
Software transactional memory
Message-passing models: the actor model; processes and channels
General-purpose programming on a GPU
Benchmarking: approach, pitfalls, statistics, reporting

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

Course material

Digital course material (Required) : Lecture slides and exercises, Janwillem Swalens, Canvas
Digital course material (Recommended) : Related papers and book chapters, Available on the course website

Additional info

This course is taught in English.

Comparison with the course "Practical parallel programming" (Jan Lemeire):

Practical parallel programming focuses on low-level approaches to parallel computing. Multicore programming focuses on high-level approaches to concurrent and parallel programming.
Practical parallel programming discusses the traditional, well-established techniques for multithreading (Java) and message-passing (MPI) which have proven their value. Multicore programming discusses cutting-edge, innovative approaches (e.g. actors, STM) using higher-level programming languages (e.g. Erlang, Clojure).
Practical parallel programming concentrates on scientific computing, such as algorithms allowing data-parallelism (e.g. matrix algorithms). Multicore programming focuses on concurrent applications with irregular concurrency, distributed systems, and their corresponding software architecture. Focus on parallelizing general-purpose software and exploring a wide range of novel techniques.

Comparison with the course "GPU computing" (Jan Lemeire):

GPU computing 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.

Learning Outcomes

Algemene competenties

Knowledge and understanding:

The student understands the context that lead to the development of multicore hardware and other types of parallel hardware.
The student can define common problems that occur in parallel programs, such as race conditions and deadlocks.
The student can describe a range of (established and novel) programming techniques for parallel and concurrent programming. The student can categorize these techniques (e.g. shared memory vs message passing) and understands their characteristics (e.g. serializability).
The student can explain how several of these techniques are implemented. The student understands the benefits and trade-offs of these techniques.
The student can define common metrics used to evaluate parallel programs, such as speedup and throughput.

Application of knowledge and understanding:

The student can analyze a program to detect errors or unwanted properties related to parallel programming, and can remedy them using the techniques seen in class.
The student can analyze sequential programs to find the appropriate technique for parallelization. The student understands the benefits and drawbacks of their solution.
The student can apply the techniques seen in class to larger programs, correctly and efficiently.
The student can measure the performance of parallel programs experimentally. The student can analyze and interpret the results in a statistically correct manner. The student can present them using the appropriate technique.

Communication:

The student can communicate the design of a parallel program, in the form of a report and an oral defense. The student uses the correct terminology.
The student can describe experimental results, both textually and visually, using the appropriate plots and visualizations, and in a statistically correct manner.
The student can defend design choices in an oral defense.

Skills:

The student learns several programming languages or libraries for parallelism and concurrency.
The student learns how to perform statistically correct performance experiments, and how to interpret and visualize the results.

Attitudes:

The student understands that different techniques have different benefits and drawbacks, and can compare them.
The student understands that different designs for parallel programs have different benefits and drawbacks, and can compare them.
The student can understand experimental performance results and examine them critically.

Grading

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:

projectverdediging with a relative weight of 1 which comprises 30% of the final mark.

Note: Oral project defense during which the student defends and explains the programming projects.

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

programmeerprojecten with a relative weight of 1 which comprises 70% of the final mark.

Note: A number of assignments are specified for which the student is expected to independently implement a concurrent program, with deadlines throughout the semester. The student should submit code and a report for each project.

Additional info regarding evaluation

Throughout the semester, a number of programming projects are presented which the students are expected to solve individually. Students will need to submit code and a written report on their projects. This report contains details about both the design and the performance of the code written for the project. Students should run their code on multicore hardware (which will be provided if necessary) to measure and evaluate the performance, the results of which will be included in the 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.

The assignments are mandatory and the deadlines are strict. Failing to hand in a project implies an absent mark for the whole course. Students need to obtain a minimal score of 8/20 for each of the projects separately. Otherwise, they will receive their lowest score as the end result for this course.

Allowed unsatisfactory mark

The supplementary Teaching and Examination Regulations of your faculty stipulate whether an allowed unsatisfactory mark for this programme unit is permitted.

Academic context