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.)
framework for implementing interpreters for programming languages. It is the key
component of the GraalVM
project which combines several such Truffle
language implementations into a single multi-language runtime. The framework also
provides an API for efficient instrumentation and debugging of programs executed
by a Truffle language implementation. Multiple debuggers already utilize this API
to implement their back-end. The goal of this project is to develop a plugin for
Visual Studio Code
that uses Truffle's instrumentation framework as a back-end
for the editor's integrated debugger.
Reference implementation of SOMns record and replay in GraaJS (Java)
SOMns is a research language similar to Smalltalk. It provides specialised
debugging support for its concurrency models, e.g. record & replay. Record
and replay debugging is based on the idea of recording a program trace that
allows one to deterministically reproduce an execution (including bugs). SOMns and
GraalJS are both implemented in Java with the Truffle framework and use similar
concurrency models. The goal of this thesis is to reimplement
the record and replay strategy from SOMns in GraalJS. In addition, recording
performance of the GraalJS implementation should be evaluated with benchmarks.
Enhancing the AcmeAir benchmark application
AcmeAir is a simple web-application that represents the booking system of an airline.
It is used to evaluate the run-time performance of debugging tools in our SOMns language
implementation. Currently, AcmeAir supports a limited set of operations that are very
database dependent. The goal of this project is to enhance AcmeAir with features one
could find in a real booking system, for example multiple options for finding flight
connections. Additionally, the JMeter configuration used to drive the benchmark needs
to be updated to use the new features.
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.
The Truffle Framework allows you to write code that interoperates between
different languages. In this project, you should prepare test cases to see how well-behaving
complete set of unit tests and an analysis of the failing behaviour.
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