Open Projects

For Master's theses, Bachelor's theses or for Software Engineering projects in the Master's program

(Most topics can be adapted in scale to fit any of the above categories)

  • 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.

  • Test language interoperability between JavaScript and Ruby (JavaScript, some Ruby and Java)
    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 JavaScript is when executing on foreign (here: Ruby) objects. What happens when you try to execute methods from JavaScript's core library on Ruby objects? The project should result in a complete set of unit tests and an analysis of the failing behaviour.
    Contact: Dr. Wirth

  • Humongous Object Aware Region Allocation (C++)
    The Hotspot G1 garbage collector is a regional collector: the Java heap is strictly split into same-sized regions. Objects larger than a single region ("humongous regions") are allocated using separate contiguous sets of regions, and are unmovable for performance reasons. This poses a few problems, for example:
    • at the end of such a humongous region there is often a significant amount of space that is effectively wasted and unavailable for allocation.
    • region level fragmentation due to never moving these objects can cause unexpected Out-of-memory situations if there are not enough contiguous regions left for a given new allocation.
    This project could lessen the problem by implementing one or more changes to the existing strategy in heap management by for example better region selection for evacuation and placement, automatic region level defragmentation efforts, over-provisioning the heap area, more aggressive reclaimation of humongous objects and regular object allocation at the end of a humongous object.
    Contact: DI Schatzl

  • G1 garbage collector Full GC improvements (C++)
    Only in JDK10 the Hotspot G1 garbage collector received a parallel full-heap collector. It uses a parallelized mark-sweep-compact algorithm. While its performance is on par with the Parallel GC Full GC algorithm, there are opportunities to improve the algorithm related to work distribution, exploiting pre-existing work and handling various edge cases better.
    Contact: DI Schatzl