Hide menu
PELAB

OPEN MASTER THESIS PROJECTS

Research Group on Compiler Technology and Parallel Computing

Prof. Christoph Kessler

Internal Thesis Projects

Note:

All projects in this list require a solid background in either compiler construction or parallel programming (some 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.

  • Mapping high-level parallel DSL programs to HPC clusters using GPI-Space (30hp)

    SkePU is a modern C++ based, domain-specific high-level programming framework targeting heterogeneous and parallel systems, developed at Linköping University, Sweden. SkePU provides powerful generic programming constructs (called algorithmic skeletons) such as Map, Reduce, Stencil etc. that implement common patterns of computationally intensive computations, that can be customized by plugging in sequential problem-specific code, and for which efficient parallel implementations are available. While SkePU was originally developed for portable computing on heterogeneous single-node systems, the current development version of SkePU also supports execution on multiple nodes in high-performance computing (HPC) clusters, however using a specific version of two-sided MPI message passing.
    GPI-Space is a new task-based runtime system for HPC clusters, developed at Fraunhofer ITWM in Kaiserslautern, Germany. It provides flexible one-sided communication (i.e., direct remote memory access) between tasks through the PGAS communication library GPI, which is an implementation of the GASPI standard. However, GPI-Space has a library-based programming API and lacks a high-level programming frontend with specific support of concise HPC constructs.
    We thus expect that SkePU and GPI-Space will complement each other well, and suggest a master thesis project that should investigate:
    - What are different possible ways to combine the two technologies, and which one is most suitable to achieve high efficiency and scalability of the resulting code? This version should be prototypically implemented.
    - Which application program patterns benefit most from the integration, compared to the existing SkePU MPI backend prototype?
    - How does the integration with SkePU improve programmability compared to equivalent code written directly using the GPI-Space API?
    This master thesis project will be jointly supervised as a cooperation between Fraunhofer ITWM and Linköping University, and likewise between the EU H2020 research projects EPIGRAM-HS and EXA2PRO. The project can be performed at either site.
    Prerequisites: Some course in parallel programming, such as TDDC78 (LiU). Very good knowledge of modern C++, esp. template metaprogramming. Program development under Linux.
    Contact:
    Dr. Valeria Bartsch, R&D Manager, Competence Center High Performance Computing at Fraunhofer ITWM, Kaiserslautern, Germany. firstname.lastname@itwm.fraunhofer.de
    Prof. Christoph Kessler, IDA/PELAB, Linköping University, Sweden. firstname.lastname@liu.se

  • [TAKEN, B.] Skeleton Computing for Reconfigurable Architectures (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 several EU 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 systems with multicore CPUs and GPUs as well as clusters.
    In this master thesis project you will extend the SkePU programming framework by a back-end targeting a reconfigurable (FPGA-based) architecture using the toolchain of an international cooperation partner. For further information please contact me directly.
    Prerequisites: Some background in parallel computer architecture and FPGA architecture. A course with completed programming labs in parallel and GPU programming (e.g. TDDD56), advanced C++ programming skills, basic knowledge of Java.
    Contact: Christoph Kessler.

  • Smarter Containers in SkePU (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 several EU 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 systems with multicore CPUs and GPUs as well as clusters.
    An important feature in SkePU are the so-called smart containers, currently Vector and Matrix, which are generic, STL-like abstractions of aggregate data that transparently perform optimizations of data transfer and memory management at runtime, implementing a generalized software caching scheme with sequential memory consistency. For details, see a recent article or Chapter 4 of Dastgeer's PhD thesis.
    In this project you will extend the smart container idea and implementation to include multiple different representations of data that have different performance implications on different types of execution units (e.g. CPU, GPU). For further information please contact us directly.
    Prerequisites: Multithreaded (OpenMP) and GPU (CUDA, OpenCL) programming (e.g. TDDD56), advanced C++ programming skills, interest in data structures, algorithms, and parallel computer architecture.
    Contact: Christoph Kessler.

  • Smart Copying Techniques for Smart Matrix Containers in SkePU (30hp)
    An important feature in SkePU are the so-called smart containers, currently Vector and Matrix, which are generic, STL-like abstractions of aggregate data that transparently perform optimizations of data transfer and memory management at runtime, implementing a generalized software caching scheme with sequential memory consistency. For details, see a recent article or Chapter 4 of Dastgeer's PhD thesis.
    At read or write accesses to vector/matrix elements, smart containers may trigger data copy operations to update stale local copies of elements before being accessed. For that, a copy plan is calculated to reduce transfer costs. However, the current solution and implementation for 2D data (Matrix container) still has ample room for improvements. In this project you will develop, implement and evaluate smart copying techniques to speed up the coherence copying operations at submatrix accesses.
    This is a research-oriented project. If the result looks publishable, we will encourage you to jointly write and submit a research paper to a conference and support your presentation.
    Prerequisites: Multithreaded (OpenMP) and GPU (CUDA, OpenCL) programming (e.g. TDDD56), advanced C++ programming skills, interest in optimization.
    Contact: Christoph Kessler.

  • Software Testing Methodology and Framework for High-Level Parallel Programs (30hp)
    This thesis project will develop a methodology for systematically testing programs using skeletons and other high-level constructs for execution on heterogeneous parallel systems.
    This is a research-oriented project. If the result looks publishable, we will encourage you to jointly write and submit a research paper to a conference and support your presentation.
    Prerequisites: Multithreaded (OpenMP) and GPU (CUDA, OpenCL) programming (e.g. TDDD56), advanced C++ programming skills; good background in software engineering, esp. software testing. Linux.
    Contact: Christoph Kessler.

  • [TAKEN, V.] Python Interface for SkePU (30hp)
    SkePU is a skeleton programming extension of modern C++. This project will investigate how to efficiently integrate SkePU skeletons in the Python programming ecosystem, and provide a prototype implementation partly based on SkePU's clang-based pre-compiler.
    Prerequisites: Advanced C++ (esp., template metaprogramming) and Python programming skills; compiler construction. Some familiarity with Linux, git, cmake.
    Contact: Christoph Kessler.

  • Parallel I/O for skeleton programs in SkePU (30hp or 16hp)
    The C++ based portable skeleton programming framework SkePU for heterogeneous multicore systems and clusters is designed to work on data types usually residing in main memory, so-called data-containers.
    This thesis project will investigate how SkePU data-containers can efficiently interface with the Hadoop Distributed File System HDFS in order to provide distributed parallel I/O on large distributed files. The solution will be prototypically implemented in the open-source SkePU framework and evaluated with several simple big-data analytics computations.
    The project can be configured for Master or Bachelor thesis level.
    Prerequisites: Advanced C++ (esp., template metaprogramming), Big-Data Analytics and/or parallel programming courses, some familiarity with Linux, git, cmake, HDFS.
    Contact: Christoph Kessler.

  • [TAKEN] Evaluation of SkePU on multicore systems with heterogeneous CPUs (30hp or 16hp)
    Heterogeneity is here to stay. Today, CPUs are usually complemented by various types of domain-specific accelerators such as GPUs, and heterogeneity also enters on the CPU side: multi-core CPUs with cores of different types on the same chip, such as ARM big-LITTLE, are getting more and more common.
    SkePU is a C++ based portable high-level programming framework for heterogeneous systems that has originally been designed for CPU-GPU heterogeneous systems.
    This project will investigate how SkePU can be extended to also support heterogeneous multicore CPUs, and perform an evaluation on a concrete such system.
    The project can be configured to match Master (30hp) or Bachelor (16hp) level.
    Prerequisites: Advanced C++ (esp., template metaprogramming), a parallel programming course (TDDD56 or TDDC78), some familiarity with Linux, git, cmake.
    Contact: Christoph Kessler.

  • [TAKEN, A.] Evaluation and Optimization of Interprocessor Communication in the Cluster Back-End of the SkePU skeleton programming framework (30hp)
    Today's top supercomputers are often clusters with nodes equipped with accelerators such as GPGPUs. This thesis project is about evaluating and extending the MPI cluster back-end implementation of the SkePU skeleton programming framework by automated optimizations of the inter-process communication in the generated code. The overall problem includes developing methods for determining the optimal partitioning of the problem, automated performance tuning for the best use of resources, possibly in a non-dedicated environment; also, devising new SkePU skeletons for some computations / communication patterns. Several benchmark programs and a large application from material science will be used as a case study.
    Begin: ASAP.
    Prerequisites: A course in programming of parallel computers, such as TDDC78 or TDDD56. Good background in MPI, C/C++, algorithms, Linux.
    Contact: Christoph Kessler.
The following project could be configured either as a bachelor or master thesis project:
  • Visualization of skeleton execution and data movement for SkePU (16hp or 30hp)
    SkePU is a C++ based framework for portable high-level programming for heterogeneous parallel systems, developed in our group as an open-source effort.
    The purpose of this thesis project is to investigate suitable ways of visualizing skeleton program execution on heterogeneous and cluster systems, and then to extend SkePU to generate a suitable graphical visualization of SkePU program execution over time (as in VAMPIR or Paraver for MPI execution or VITE for heterogeneous systems). This could be technically done by extending SkePU to add target code that generates log files during execution, and converting these to the required input format for an existing visualization tool. The generated visualization must be target-platform-independent and ideally have only few/lightweight UI framework dependencies. It should allow to relate runtime events (skeleton instance executions, data transfers) to source code lines and variables, and provide means to properly display such information for cross-referencing.
    Prerequisites: Advanced C++ programming, Linux. Some background in parallel/GPU programming is useful but not absolutely required.
    Contact: Christoph Kessler.

Further thesis projects for LiU-based students with interest in compiler technology and/or parallel programming are available on request, please contact me.


External Thesis Projects

in cooperation with partners in industry or research institutes

  • For parallel computing related external thesis projects centered around real-time signal processing of LHC sensor data at CERN, Switzerland, please contact me for further information.
  • Binärt reproducerbara mjukvarubyggen (16hp/30hp)
    Externt projekt på SECTRA, kort beskrivning (PDF), vg. kontakta mig för ytterligare information.


Back to my master thesis students page

More thesis projects at PELAB



Responsible for this page: Christoph Kessler, IDA

Page responsible: Webmaster
Last updated: 2022-04-04