Project in Software Engineering
Lengauer + members of SSW/CDL MEVSS/Oracle
||Introduction: Mo 6.3.2017, 16:00, S3 218
||Presentations: Mo 26.6.2017, 13:15, S3 218
The goal of this course is to do a non-trivial software project over a whole semester and to go
through all its phases (requirements definition, design, implementation, testing,
documentation). The projects should be done in teams of 2 persons. At the end of the semester, the
results should be presented in a 15 minutes presentation.
Basic Java Source Code Editor for AntTracks (Java)
AntTracks is an offline memory monitoring tool that allows users to analyze heap memory by classifying heap objects based on various properties. Beside pre-defined classifiers, the user is able to define custom classifiers at run-time within AntTracks' UI. This is currently done in a default Java Swing text component, without sophisticated text highlighting support and no code completion. The goal of this project is to develop a text control that supports basic IDE functionality like Java Syntax highlighting and simple code completion with the help of a pre-existing Java Compiler.
Student: Christine Atzmueller
JavaFX for AntTracks (Java, JavaFX)
AntTracks is an offline memory monitoring tool for Java that is currently implemented in Swing. The goal of this work is to incrementally port the UI in a top-down manner from Swing to JavaFX and refactor it based on an Model-View-ViewModel approach. Components with custom rendering can still be embedded as Swing components.
Student: Daniel Pucher
An Online Tool for Handling Student Exchanges at IAESTE Austria
The goal is to develop a tool (from the front end to the database) that supports IAESTE Austria in handling their student exchange program.
The project consists of 2 parts: (1) Handle registrations of outgoing students; upload project descriptions for which the students can apply.
(2) Handle the projects of incoming students. A complete specification of both parts is available. A certain financial support is possible.
Student: Christopher Warmbold
Implementation of Interference Region Spilling for a Graph-Coloring Register Allocator in Graal
Graal is a just-in-time (JIT) compiler for Java bytecode that is itself
written in Java. Like many other JIT compilers Graal uses the linear scan algorithm for
allocating registers, which is fast but does not produce the best quality code.
In course of a Master's Thesis a graph-coloring register allocator was added to Graal.
The goal of this project is to replace the simple spilling mechanism of the initial implementation with a
region spilling approach that reduces number of required spills and loads.
Students: Florian Schröckeneder
benchmark suites test the performance of the core runtime, this set should facilitate the characteristics of typical Node.js applications,
such as parallel request handling, IO performance, VM-level performance (e.g. garbage collection).
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.
Safely Combining Shared Memory Concurrency with Message Passing (Graal & Truffle)
With the wide availability of multicore systems, concurrent programming becomes increasingly necessary to achieve the
desired performance for a wide range of applications. The actor programming model provides a safe model for such programs, avoiding many
of the pitfalls of shared-memory concurrency based on threads. In the past, we explored ideas to bring the safety of the actor model
to shared-memory programming as well. The goal of this project is to apply these ideas to a new programming language called SOMns
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.
Improve G1 concurrent marking
The G1 garbage collector in the Java HotSpot VM uses concurrent marking to determine which objects are live and which not. It is serviceable, but
its memory usage is very conservative: it statically sizes a few very large in-memory structures so that it will never need to reallocate. This
wastes a lot of memory and time to initialize them in many applications.
The goal of this project is to improve average memory usage of the concurrent marking by lazily allocating und using these data structures.
Implementation of a Register Allocation Verifier for the Graal Compiler (Graal, Java)
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.
Please see here
The results of every project have to be presented by all team members in a 15 minutes presentation.
The presentation should mainly consist of a demo, but you should also shortly explain the
problems tackled in this project and how you solved them.
The mark is derived from the quality of the implemented software (functionality, user friendlyness, robustness,
readability and maintainability, documentation) as well as from the final presentation and
the commitment during the semester.