Parallel and Concurrent Programming

Software systems are becoming highly concurrent and parallel to utilize modern multicore architectures and increasing speed and bandwidth in networks. In the multicore era, all performance-critical software employs some form of concurrent programming; typically shared memory concurrency. In this setting, parallelism and concurrency are the dominant programming paradigms for performance gains. Writing correct and efficient parallel and concurrent programs is challenging, and requires understanding the behaviors of the primitives and reason about them. This course aims to explore parallel and concurrent programming approaches along with their analysis techniques.

This course aims to give students a deep understanding and hands-on experience of parallel and concurrent programming and analyzing them.

Lecture plan

In this course, we will cover three parts: parallelism, concurrency, and automated analysis techniques for concurrency.

Parallelism can bring significant performance improvement as multiple independent components execute in parallel and thereby achieve (almost) linear speedup to the number of processing units.

In the second part, we will focus on concurrent programs. Concurrency is another paradigm for efficiently programming shared memory hardware. In concurrency, multiple threads execute independently with occasional communication via the shared memory. However, concurrent programs demonstrate many subtle complexities and thereby developing correct and optimal concurrency programs is a challenging problem.

In the third part we will focus on the automated analysis approaches for concurrency. We will focus on concurrency bugs and analysis techniques for various properties such as data race, consistency checking, and so on.

Outline of Lectures:

Parallelism (3 lectures):

Parallel programming

Automatic parallelization

Dependency analysis

Concurrency (5 lectures):

Concurrent programming

Correctness of concurrent programs

Relaxed memory concurrency

Automated analysis techniques (2 lectures):

Property checking e.g. data race, consistency

The final grade of the course consists of the following components:

• Group Assignment: Research project - implementation (weighting 40%)

• Group Report (weighting 20%)

• Group Presentation (weighting 20%)

• Individual Assignment 1: parallel en concurrent programming (weighting 10%)

• Individual Assignment 2: reasoning about concurrency (weighting 10%)

Final grade calculation = 0.4 * Group Assignment + 0.2 * Group Report + 0.2 * Group Presentation + 0.1 * Individual Assignment 1 + 0.1 Individual Assignment 2

A passing final grade for the course can only be earned when for all components at least a 5.0 is earned, and the weighted final grade is at least a 5.8.

In case of an insufficient final result, repair options may exist in accordance with Article 17A, Times and number of examinations, sub 1, of the Teaching and Examination Regulations, for:

• Research project implementation: Repair opportunity

• Research project report: Repair opportunity

• Research project presentation: Resit opportunity

• Individual Assignment 1: Repair with 10% penalty

• Individual Assignment 2: Repair with 10% penalty

Disclaimer: information may change depending on unforeseen circumstances or measures (see: TER Art 2, sub 5).