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.)
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.
Self-specializing language-independent JSON parser (Java, Graal & Truffle)
The Truffle Framework leverages partial evaluation to produce highly-optimized machine code. The goal of this project
is to develop a self-rewriting JSON parser in Truffle to speed up JSON parsing. In particular, the parser should be optimized to speed up
parsing of large JSON documents where only a subset of the JSON objects is actually used. The parser developed in this project should be
Parameter space exploration to optimize compiler settings (Python and/or additional languages)
VMs such as V8 and the JVM can be fine-tuned to optimize for specific workloads. The GraalVM multi-language virtual machine
is no exception, and fine-tuning heuristic-based runtime components such as inlining and splitting can greatly affect the VM performance.
Moreover, the VM is multi-language, and the best configuration for a language is not necessarily acceptable for another language. In this project,
you will develop a software tool to perform automatic exploration of the configuration parameters of the GraalVM, to identify how each parameter
affects the performance of the engine in a cross-language setup. The goal is to identify one or more VM configurations that are suitable for
cross-language workloads via automatic performance testing. The software artifact will be integrated in Oracle Labs' CI infrastructure.
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.