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


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

  • 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

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

    Contact: DI Schatzl