Collection of projects for students

On this page you will find a summary of all open projects for study/bachelor and diploma theses.

Models of Computation

Programming models and toolflows for cyber-physical systems (Reactors)

A current main research interest is applying the reactor model of computation to the programming of cyber-physical systems (CPS). The goal is to develop a toolflow that helps to build safer and more reliable software for CPS. An overview of this research topic can be found here. Int his context, possible topics could be:

  • Development of a realistic demonstrator application for the existing toolflow. Experience or interest in the development of automotive applications and programming experience in C++ would be useful  for this task.
  • In order to evaluate our toolflow, we require many different test applications. An alternative to the costly development of realistic applications, is random generation of test applications. The task would be to develop such a random code generator from scratch or based on similar previous work. No specific programming language is required for this task.
  • While we have proven the existing approach to work correctly, there is room for improvements and in particular for optimization of the resulting applications. This task would consist of two parts: benchmarking of the current approach to identify bottlenecks and improvement of the existing algorithms. Programming experience in C++ and possibly Java are useful for this task.
  • Our toolflow is polyglot. This means that it is independent of the target language. Currently we have backends for C, C++ and TypeScript, but many more could be build. Particularly interesting would be a Rust implementation. 

There are many more things that could be done. Just let me know if the general topic appeals to you.

Contact: Christian Menard

Tools for modeling and analyzing dataflow applications (Mocasin)

We are developing the open-source python-based framework Mocasin for modeling and analyzing dataflow applications. In particular, our ongoing research focuses on large dynamically reconfigurable applications such as typical workloads in 5G base band processing. Since Mocasin is a large framework that can be extended and improved in manifold ways, we always appreciate help and a suitable task for a student thesis can always be found.

Contact: Christian Menard

A higher-level syntax for controlling quantum computers

In a collaboration with Riverlane, we are currently investigating programming concepts and higher-level models for the interaction of software with quantum computing circuits. In particular, we are interested in Deltalang, which is a domain specific language (DSL) embedded in python. In Deltalang, applications are modeled as dataflow graphs where nodes represent components in a quantum computer and edges represent computation. While such an abstraction is very useful, explicitly defining components and connecting edges is often tedious and can be error-prone. For this reason, we are looking for students interested in developing a higher-level syntax that is easier to use by programmers and that allows a compiler to implicitly derive the required dataflow graph. If applicable to deltaflow, this work could be based on our group's prior work in Ohua.

Contact: Christian Menard

Machine Learning and Heuristics
  • Modeling Source Code for Machine Learning

Central to ML-Methods is the way how to represent and model data, with the goal to learn meaningful features for the given task. In compilers, knowledge from analysis can be exploited to construct better models. So far, we have explored representations at different levels and modeled them using Graph Neural Network (GNN) models. Your task will be to work on new models with additional compiler-internal semantics.

Requirements: C/C++, Python
Beneficial: Machine Learning, Graph Algorithms
Related Work: [1], [2], [3]


  • Self-supervised Learning in the Compiler domain

Labeled datasets are expensive to obtain, whereas semantic knowledge from static analysis can be computed cheaply and automatically. The idea is to pretrain a model with such semantic information, later fine tune it on a relatively smaller dataset on a given task to enable better performance in heuristics of optimization tasks.

Requirements: C/C++, Python
Beneficial: Machine Learning


  • Compiler Optimization Tasks

Due to hardness or computational intensitivity, many compiler optimizations rely on heuristics. The goal is to evaluate sophisticated models of source code from our recent work in the use case of concrete heuristics in the LLVM compiler framework.

Requirements: C/C++, Python
Beneficial: LLVM compiler framework
Related Work: [1]

Tools for Emerging Memory Technologies
  • Compilation for unconventional architectures:

Emerging non-volatile memory technologies have the potential to compute various logic and compute operations in place. They, however, have their own limitations. In this project, you will work on developing/extending a compiler that hides/mitigate these limitations and exploit the full potential of these novel architectures. As a target system, you will work on compute-in-memory (CIM) systems using various nonvolatile memory technologies.

Requirement(s): You should be motivated and have some C++ background (LLVM/MLIR background is preferred).

  • Simulation infrastructure for CIM systems:

To quickly characterize and understand the various tradeoffs in CIM systems (see the description of the project above), it is imperative to have simulation tools that can model them. In this project, you will work on developing a gem5-based simulation infrastructure for CIM systems (similar to the following). The tools will enable the exploration of different NVM technologies at different memory hierarchy levels. Feel free to ping me for more details.

Requirement(s): C/C++ (basic computer architecture knowledge is preferred).

  • Intelligent Data Movement in the Memory Hierarchy:
Data movement in the memory hierarchy is expensive and memory systems, generally, are blind to running applications. In this project, you will analyze the applications statically to find out which hierarchy level best suits the memory requirement of the current input program (there are tools that can be used) and place it accordingly. If done correctly, you may guarantee a 100% cache hit rate.

Contact details and further tasks description can be found here.

Hybrid mapping methodology for energy-efficient computation

At the Chair for Compiler Construction, we are developing a hybrid system called TETRiS, which aims at energy-efficient and predictable execution of multiple applications. The system exploits inherited symmetries in hardware and software to reduce the design space exploration. The approach consists of two parts, at design-time, the set of Pareto-optimal configurations is generated, and then depending on the current workload, the configurations are selected and transformed at runtime.

Possible project topics include:

  • Runtime adaptivity of Kahn Process Networks with implicit parallelism

Kahn process networks (KPN) are an abstraction for modeling computation which makes communication patterns explicit. An extension of implicit parallelism for KPN allows applications to change the number of used resources at runtime in a malleable way, which allows applications to adapt to the changes in the environment and, therefore, achieve better energy efficiency. In this project, you will develop this application model in the Mocasin framework, extending the hybrid methodology for this class of applications.

  • Frequency scaling in hybrid mapping methodology

Dynamic Voltage Frequency Scaling (DVFS) allows reducing the energy consumption of the system further. A naive approach to adapt DVFS in the hybrid methodology would be to generate the operating points for each available frequency configuration of the platform. This, however, would lead to a blow-up of operating points and a complex runtime algorithm. In this research project, you will develop an interplay of the hybrid methodology with frequency scaling.

  • A hybrid approach for mixed-critical applications

In this work, you will refine the hybrid methodology approach for non-real-time application and mixed-criticality applications.

  • Runtime scheduling in Linux

In this work, you will develop the runtime algorithm in the prototype in C++ for scheduling applications running on Linux.

This list is open-ended. Feel free to approach me and discuss these or other ideas.

If you are interested, please contact Robert Khasanov.

Go back