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.
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.
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.
NUMA support for the G1 Garbage Collector
On multi-socket systems memory access time depends on the memory location relative to the processor (locality group): "closer" memory access latency is significantly smaller than memory that is located with a different processor.
Currently G1 does not exploit this by improving or at least keeping access locality the same.
Goals for this task could include implementation of the common heuristics used in literature that keep objects in the same locality group as long as possible, like a) let G1 keep data in the same locality group in the young generation and try to evenly spread data across locality groups in old generation; or b) try to keep locality in both young and old generation. Measure the impact of these strategies across a set of industry benchmarks and analyze other areas in the garbage collector that might benefit from NUMA awareness and potentially suggest changes.