logo of the SSW institute ;)
Computer Science
System Software

Home

General
Staff
Contact
Partners
Alumni

Research
Areas
Projects
Papers
Books
Reports
Awards

Teaching
Lectures
Exams
B.Projects
M.Theses
PhD Theses
Go Abroad

Misc
Talks
Library
Gallery
Links
Search

Webmaster


Open Projects

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 und 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.
    Contact: Dr. Marr

  • 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.
    Contact: Dr. Marr

  • Implementation of a Register Allocation Verifier for the Graal Compiler
    Graal 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.
    Contact: DI Josef Eisl

  • 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

  • Multi-Language Console
    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 language-indepentent.
    Contact: Dr. Wirth, Dr. Bonetta

  • 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.
    Contact: Dr. Wirth, Dr. Bonetta

  • 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.
    Contact: DI Schatzl

  • 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.
    Contact: DI Schatzl