The following master thesis projects are currently available in my group:
All projects on this page require a solid background in either compiler construction or parallel programming (preferably both); at least one major course (preferably at master level including programming labs) in these areas should be passed successfully.
Note to non-LIU students (FAQ): If you want to do a thesis project with us, you must be registered on a master (or bachelor) program at Linköping university. It is generally not possible to do such projects remotely.
SkePU extensions and optimizations for the Myriad1 back-end (30hp)
SkePU is a C++ based open-source skeleton programming library for portable high-level programming of heterogeneous multicore systems, being developed by our group at Linköping University in the context of two EU FP7 projects. The different back-ends (basically, implementation variants) provided for the SkePU skeletons allow it to support different types of processing units (PUs), which also opens for automated tuning of the execution flow by selecting the expected fastest implementation at runtime depending on the execution context. The public SkePU distribution currently supports multicore CPUs and GPUs, and there are also experimental back-ends for MPI and for Movidius Myriad1 developed in previous thesis projects.
Myriad is a low-power embedded processor family developed by Movidius for high-throughput image processing on mobile devices. Efficient code for this platform needs to leverage its specific hardware features such as the SIMD instructions, code loading and memory mapping, and to optimize the data transfer between host, master and slave cores.
This project will develop generic extensions to the SkePU API and specific improvements of the current SkePU backend for Myriad that together will allow to improve performance considerably while not harming performance on other platforms.
Requirements: TDDD56 Multicore and GPU Programming. Advanced computer architecture. Good programming skills in C++ and assembler language. We also highly recommend a course in compiler construction.
Contact: Christoph Kessler, Lu Li.
Language embedding and compiler support for
performance-portable skeleton programming (30hp)
SkePU is a C++ based open-source skeleton programming library for portable high-level programming of heterogeneous multicore systems, being developed by our group at Linköping University in the context of two EU FP7 projects. SkePU skeletons (map, reduce, mapoverlap, scan etc.) are templated generic functor objects that are parameterized in sequential user functions; by instantiating them with problem-specific user code, customized multi-variant code is generated automatically. In this way, SkePU hides all platform specific coding details internally, exposing only a sequential-looking programming interface to the user.
The different back-ends (basically, implementation variants) provided for the SkePU skeletons allow it to support different types of processing units (PUs), which also opens for automated tuning of the execution flow by selecting the expected fastest implementation at runtime depending on the execution context. The public SkePU distribution currently supports multicore CPUs and GPUs, and there are also experimental back-ends for MPI and for Movidius Myriad1 developed in previous thesis projects.
The current parametrization mechanism in SkePU uses ad-hoc constructs such as preprocessor macros for defining and generating user functions. This should instead be better integrated in the C++ language. In this project you will re-design the API for SkePU user function specification, using a combination of template metaprogramming and compiler frontend extensions. The implementation will be based on the ROSE C++ source-to-source pre-compiler. This redesign will not only provide a cleaner, more type-safe programming interface but also enable new optimizations in generating platform-specific code, which is to be developed as a second step in the project, and which we will discuss further in our first meeting.
Requirements: TDDB44 Compiler construction or similar course. TDDD56 Multicore and GPU Programming (OpenMP, CUDA, OpenCL). Good programming skills in C++ (esp. template programming).
Contact: Christoph Kessler, Erik Hansson, Lu Li.
[prel. taken] Design and toolchain for a system architecture description language
enabling holistic energy optimization (30hp)
XPDL is a novel XML-based system architecture description language that allows to express high-level descriptions of the structure and relevant properties of computer systems (hardware components and system software) in order to support generic tools that access this information e.g. for target-specific code generation or run-time optimizations. A particular focus of XPDL is on modeling hardware and system software features that are relevant for the energy efficiency of an application.
The purpose of this project is to elaborate the design of XPDL, in particular to specify its XML schema and semantics, and to develop a toolchain (esp., a compiler) for parsing, representing, processing and querying XPDL models.
The development is done in the context of a running international research project concerned with portable, holistic optimization of energy efficiency across the entire application and system software stack.
Prerequisites: Background in XML technology e.g. XSD, XSLT; compiler construction (TDDB44 or similar); component-based software (TDDD05 or similar); some background in modern computer systems architecture and programming, including accelerator technology (e.g. TDDD56, TDDC78 or similar); good skills in C/C++ programming, Linux.
Support for generalized stencil computations in SkePU (30hp)
SkePU is an open-source C++ template library for portable and efficient high-level programming of GPU-based systems, using so-called skeletons. A skeleton is a generic software component modeling a specific pattern of computation; its implementation encapsulates platform-specific technical details such as parallelism and accelerator handling, communication, synchronization etc., while exposing a sequential programming interface to the programmer. SkePU currently provides one task-parallel and a number of data-parallel skeletons, including one that models stencil computations, i.e., computations that update each element of a matrix or image as a filter operation applied to its nearest neighbor elements.
This project will, as a case study, consider an open-source high-performance computing application from medical image processing that is currently implemented in C++ and CUDA, investigate the requirements for expressing its performance-critical parts with existing (SkePU) skeletons, and develop the possibly required extensions to the SkePU library that allow to more conveniently express the application with SkePU skeletons.
Prerequisites: TDDD56 Multicore and GPU Programming, or similar course on parallel programming. Advanced C/C++ programming skills.
Contact: Christoph Kessler
Systematic Concurrent Debugging (30hp or 2x30hp)Ahmed Rezine or Christoph Kessler
Further thesis projects in compiler technology and
on request (chrke at ida.liu.se).
Back to my master thesis students page
More thesis projects at PELAB
Responsible for this page: Christoph Kessler, IDA