For Bachelor's theses or for Software Engineering projects in the Master's program
(Some of these topics can also be extended for a Master's thesis. Please ask.)
Automatic Evaluation of C Bug Finding Tools
Buffer overflow vulnerabilities, use-after-free errors, NULL dereferences, and other errors are omnipresent in C.
Bug-finding tools such as LLVM's AddressSanitizer, Valgrind, and Safe Sulong enable programmers to tackle this issue by executing the system under test with the respective tool. The goal of this project is to automatically determine the distribution of error categories and evaluate state-of-the-art bug-finding tools on Github projects. The outcome should be a tool that downloads projects from Github, builds the projects, and runs their test suites with different bug finding tools. The bug finding tools must be capable of classifying execution errors by their error messages.
A Feasibility Study on Executing Binary Code on Sulong
is an execution environment for C and other low-level languages on the JVM. C programs often rely on third party libraries that are only available as binary code, which cannot be executed by Sulong. However, Sulong executes a low-level intermediate representation, called LLVM IR, that can be produced by tools from binary code. Such tools include QEMU, MC-Semantics, and LLBT; using one could enable Sulong to execute binary code. The goal of this project is to evaluate whether these tools are complete enough to translate common code and determine if the produced LLVM IR is suitable for execution on Sulong. As a subgoal, unimplemented features that are exercised by such code should be implemented in Sulong.
Running a C Standard Library on Sulong
is an execution environment for C and other low-level languages on the JVM. C programs typically use the C standard library to perform common tasks such as string manipulation, memory management and I/O. The goal of this project is to run an existing libc (such as musl libc
) on Sulong. Likely, bugs in Sulong (and potentially in the libc) will be found that should be fixed or documented.
Graal Collections (Graal and Truffle)
Graal is a just-in-time compiler for the JVM platform that is itself written in Java.
Graal's code base makes heavy use of Java Collections such as List, Map and Set with their
standard JDK implementations ArrayList, HashMap and HashSet. Using the standard JDK
container implementations has certain disadvantages. The goal of this project is to implement a specific Graal collection type, e.g., the List interface that is optimized for run-time and memory efficiency as well as for the usage patterns in Graal.
Architekturanalyse reaktive Systemplattform bei CELUM GmbH
CELUM GmbH (http://www.celum.com) ist ein führender Hersteller von Digital Asset Management Systemen.
In einem aktuellen Forschungsprojekt soll eine neue Kollaborations-Lösung aufgebaut werden, mit der die Erstellung
von digitalen Inhalten in weltweit verteilten Teams unterstützt wird. Bei der Gestaltung des Systems sind noch wesentliche Entwurfsentscheidungen im Detail zu klären. In zwei Bachelorarbeiten, die in enger Kooperation durchgeführt werden können, sollen zwei wesentliche Aspekte des Systems untersucht werden: Inkrementellen Updates von Benutzersichten
Datensynchronisation in einer verteilten Systemumgebung
Die Arbeit wird im Rahmen eines Institutsprojektes durchgeführt und wird von CELUM GmbH finanziell unterstützt.
Debugging Actor Programs with Visual Studio Code (VS Code, Graal & Truffle)
While the actor programming model is increasingly popular with languages such as Scala and Erlang, its support for
debugging in classic IDEs such as Eclipse, NetBeans, or Visual Studio Code is still rare. The goal of this project is to
add debugging support for actor libraries and languages for instance for VS Code to help developers to understand the dynamic behavior
of their code better.
Automated Debugging: Learning Actor Protocols from Correct Executions (Graal & Truffle, Actor Concurrency, Testing, Debugging)
Debugging concurrent programs is hard. While problems in sequential code often manifest as errors deterministically,
in concurrent systems, we have the additional challenge of non-deterministic schedules and race conditions.
To facilitate debugging and correctness of concurrent programs based on the actor model,
we can use so-called contracts, state-machine-like definitions of how actors are expected to communicate.
However, constructing such contracts for complex systems can be a lot of effort.
In this project, we want to explore generating them based on observed executions that lead to correct results.
Implementation of a Register Allocation Verifier for the Graal Compiler
is a new just-in-time compiler for Java
that is itself written in Java. It is based on a port of the HotSpot client compiler from C++ to Java.
Due to its modular design it is easy to add new register allocators but creating a new allocator, or improving an existing
one, is a tedious and error prone task. The goal of this project is to implement a register allocation verification
framework based on static analysis.
Automatisches Software-Testen im .NET-Umfeld (Fa. Doka)
Die Firma Doka aus Amstetten hat in den letzten Jahren ein Softwaresystem mit den
Microsoft-Technologien C#, .NET 4.5, VisualStudio 2013, WPF, WCF und MVVM aufgebaut. Dadurch ist es möglich,
alle Systemkomponenten und sogar die Programmoberflächensteuerung durch Verwendung von MVVM vollautomatisch
zu testen. Erste Unit-Tests sind bereits implementiert. Im Rahmen dieser Arbeit sollen weitere Tests
für die Oberfläche sowie für den Workflow geschrieben werden.
Safe Data Structures for C
C does not have automatic memory management, every memory access is "unsafe", and there is also no type checking.
This project aims to introduce memory and type safe data structures for a Truffle-based C interpreter (similar to what Java provides).
The goal of this project is: investigate feasibility of safe data structures for C wrt. implementation effort; determine restrictions of safe data structures compared to regular raw-memory allocations in C; develop a prototype implementation of safe data structures for a given C interpreter.
Contact: DI Grimmer
The Truffle platform allows programmers to execute programs that are written in multiple languages.
This project aims to implement a multi-language command line tool for Truffle-based language implementations.
The goal is to allow programmers to select the language for each statement and therefore write multi-language applications.
Contact: DI Grimmer
CUDA/OpenCL integration via Truffle interoperability
Truffle is a framework for implementing language runtimes on a Java VM.
There are existing implementations for many languages on top of Truffle (JS, Ruby, R, etc.), and they can communicate
with each other through Truffle's interoperability layer.
The goal of this project is to create a Truffle language implementation for CUDA or OpenCL, so that other languages
can transparently call code that is executed on the GPU. The implementation should handle the communication with the
GPU and the data marshalling, so that it is as easy as possible to integrate GPU code into applications written in
other Truffle languages.
Use serial/waiting time to perform independent tasks during young gc in G1
In the Oracle HotSpot Garbage First (G1) collector, young GC often contains
periods of time where worker threads are waiting for others (termination time) or executes something
serially. This time could be used to perform some tasks that have no dependencies on other tasks and
otherwise consume a significant amount of time. Prominent examples for such tasks are a string table
and symbol table cleanup that take a significant (i.e. most) amount of time during other pauses,
but could be scheduled at any time during a stop-the-world pause.
NUMA for G1
There have been a few attempts at adding NUMA support (exploiting locality of
memory in multi-socket systems) of varying complexity into older versions of the Garbage First
(G1) collector. The goal is to look at existing proof of concept implementations, try to unify
them and measure impact. A NUMA system can be easily emulated on Linux for development, for
performance tests suitable machines are available.