6 ECTS credits
150 u studietijd

Aanbieding 1 met studiegidsnummer 4016038FNR voor alle studenten in het 2e semester met een gespecialiseerd master niveau.

2e semester
Inschrijving onder examencontract
Niet mogelijk
Beoordeling (0 tot 20)
2e zittijd mogelijk
Faculteit Wetenschappen en Bio-ingenieurswetensch.
Verantwoordelijke vakgroep
Jennifer SARTOR (titularis)
Onderdelen en contacturen
26 contacturen Hoorcollege
26 contacturen Werkvormen en Praktische Oef.

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/

Digitaal cursusmateriaal (Aanbevolen) : A Sophomoric Introduction to Shared-Memory Parallelism and Concurrency, Dan Grossman, Learning platform, 2011
Handboek (Aanbevolen) : Introduction to Concurrency in Programming Languages, M. Sottile, T. Mattson, C. Rasmussen, CRC Press, 9781420072136, 2009
Handboek (Aanbevolen) : The Art of Multiprocessor Programming, M. Herlihy & N. Shavit, Morgan-Kaufmann, 9780123973375, 2008
Digitaal cursusmateriaal (Vereist) : Slides Multicore Programming, Tom Van Cutsem, Learning platform
Bijkomende 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.


Algemene competenties

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.


De beoordeling bestaat uit volgende opdrachtcategorieƫn:
Examen Mondeling bepaalt 30% van het eindcijfer

WPO Praktijkopdracht bepaalt 70% van het eindcijfer

Binnen de categorie Examen Mondeling dient men volgende opdrachten af te werken:

  • projectverdediging met een wegingsfactor 1 en aldus 30% van het totale eindcijfer.

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

Binnen de categorie WPO Praktijkopdracht dient men volgende opdrachten af te werken:

  • programmeerprojecten met een wegingsfactor 1 en aldus 70% van het totale eindcijfer.

    Toelichting: Student is assigned programming projects throughout the semester. These must be solved individually.

Aanvullende info mbt evaluatie

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.

Academische context

Deze aanbieding maakt deel uit van de volgende studieplannen:
Master in de toegepaste informatica: Standaard traject
Master in de ingenieurswetenschappen: computerwetenschappen: profiel artificiƫle intelligentie
Master in de ingenieurswetenschappen: computerwetenschappen: profiel multimedia
Master in de ingenieurswetenschappen: computerwetenschappen: Profiel Software Languages and Software Engineering
Master in de ingenieurswetenschappen: computerwetenschappen: profiel web- & informatiesystemen
Master in Applied Sciences and Engineering: Computer Science: Profile Artificial Intelligence (enkel aangeboden in het Engels)
Master in Applied Sciences and Engineering: Computer Science: Profile Multimedia (enkel aangeboden in het Engels)
Master in Applied Sciences and Engineering: Computer Science: Profile Software Languages and Software Engineering (enkel aangeboden in het Engels)
Master in Applied Sciences and Engineering: Computer Science: Profile Web & Information Systems (enkel aangeboden in het Engels)