Project in Software Engineering
||Mössenböck + members of SSW/CDL MEVSS/Oracle
||Introduction: Mo 5.3.2018, 16:00, S3 218
||Presentations: Mo 2.7.2018, 10:00, 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's UI. This is currently done in a default JavaFX 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: Michael Jäger
Graph Visualization in AntTracks (Java, JavaFX)
AntTracks is an offline memory monitoring tool that collects various information about heap objects
during an application's execution, such as an object's type or allocation site, alongside references
between these objects. This allows reconstructing the heap object graph for a given point in time,
yet AntTracks currently lacks a convenient way to visualize graphs.
The goal of this project is to develop a graph visualization system for JavaFX that allows the
rendering of arbitrary graphs, e.g., heap object graphs. Functionality should include
(but is not limited to): Visualizing nodes (variable shapes, icons, expandable information, variable colors),
visualizing edges between nodes (edge labeling, variable thickness, variable styles), lazy loading of
child nodes on first parent node expansion, automatic layout of nodes (e.g., hierarchical).
Student: Jakob Faschinger
Partial Evaluation Benchmark Infrastructure
Truffle is a programming language implementation framework ontop of the GraalVM. Language implementers write an abstract
syntax tree (AST) interpreter, which is registered in the Truffle ecosystem to be part of the polyglot GraalVM world.
To this day, one of the primary goals of the Truffle project is to deliver automatic near-native performance for AST
interpreters based on partial evaluation. Partial evaluation, based on the 1. Futamura projection is a process of
specializing an interpreter with compilation constant source code to produce an executable. Truffle's implementation
of partial evaluation is compile time intensive as it involves parsing the bytecodes of the involved AST nodes and
inlining them into the root compilation unit.
The goal of this thesis is to develop a benchmarking framework for Truffle's partial evaluation framework. The
framework should measure runtime of a partial evaluation as well as memory usage.
Student: Florian Latifi
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
Student: Simon Eilmsteiner
Visualization of Tree Algorithms
In courses about algorithms and data structures, tree algorithms play an important role, but advanced trees and
algorithms for balancing and traversing trees are difficult to understand. In particular, these algorithms are
typically recursive, and it is not easy to keep track of the various recursion levels.
The goal of this project is the development of an interactive application that illustrates and animates various
types of trees and algorithms for building, searching, traversing and balancing such trees. Which types of trees
and which tree algorithms are to be covered will be defined at the beginning of the project.
Student: Mileta Milincic
Mac-O Support for Sulong
Student: Raphael Mosaner
Time Series-based Event Prediction in Heterogeneous Large-Scale Systems
Dynatrace provides rich monitoring data of their customers’ systems including detailed time series
data and event data. The time series data is available in 1-minute resolution and covers various
metrics such as CPU utilization, disk latency, number of worker threads, etc. The event data
comprises several types of problems and events such as process crashes, increased error rate events,
service slowdown events, etc.
The goal of this project is to develop a supervised machine learning predictor which takes as input
time series data and predicts the likelihood and time of a specific event (time-to-event prediction).
This includes appropriate data processing, data selection and parameter tuning.
Tool Development for Integration of Existing Crash Analysis Approach
We developed a crash analysis approach for our industry partner Dynatrace which automatically
extracts interesting cases of crashed software frameworks based on multi-system monitoring data.
The goal of this project is to develop a tool which allows users to continuously apply this crash
analysis approach (periodically on new monitoring data), create crash-analysis reports and visualize
specific crash properties (e.g., occurrences of exception messages) over time to detect possible trends.
Visualizing Infrastructure Architecture Graphs Including Time Series Metadata
Dynatrace provides rich monitoring data of their customer’s systems, including system components and their
connections, detailed time series data and event data. The goal of this project is to develop an visualization
of such a system as an interactive graph, which should include visualizing nodes, edges and time series for
a given node, setting a filter on the time interval to be observed, setting a filter on the time series
metrics to be observed and visualizing events in the time series graphs.
Exposing the Reliance of Binary Programs on x86 Implementation-Dependent Behavior
Some processors produce implementation-dependent or undefined values for certain inputs.
For example, on x86, the bsr instruction (which scans an input value for the least
significant set bit) produces an undefined output value if 0 is given as input.
While undefined output values are usually predictable for a certain architecture,
future architectures might behave differently. The goal of this project is to
investigate whether undefined behavior in x86 instructions affects the observable
program behavior (i.e., the output of a program printed to the console).
To this end, an emulator (such as QEMU) or a dynamic binary instrumentation framework
(such as DynamoRIO) should be modified to generate a random output value for an
operation that is given undefined input.
A Feasibility Study on Executing Binary Code on 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.
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.
Documentation System for SOMns
SOMns is a Newspeak based language for concurrency research and its runtime modules are currently not documented.
The goal of this project is to develop a comment-based (like in JavaDoc) documentation system for SOMns, and integrate
it into the SOMns plugin for VS Code.
Code Formatting for SOMns
SOMns is a Newspeak based language for concurrency research. The goal of this project is to develop a code
formatting tool for SOMns using SOMns. The Parsing infrastructure of Newspeak should be ported to SOMns as a
basis for the tool. The formatting is then implemented using the Abstract Syntax Tree provided by the Parsing
Region pinning for G1
The G1 garbage collector in the HotSpot VM is a region based incremental garbage collector that can evacuate (move)
around objects at will. While this allows you to fight fragmentation, moving around objects does not help with
interfacing with non-garbage collected code like C.
For this reason, while some C code accesses Java memory, the VM prevents the garbage collector to perform its task.
This does not work well in situations where memory is already tight. One alternative approach usable with G1 would
be to, instead of preventing any garbage collection work, only prevent garbage collection work for heap areas which
contain Java objects that are currently in use with native code.
Goals of this work are a working implementation of region pinning in the G1 collector. Consider implementing
techniques to mitigate wasting complete regions for a few pinned objects by allowing simple allocation into them.
Evaluate the change and compare it to the existing mechanism of providing non-moving memory.
Please see here
The results of every project have to be presented by all team members in a 15 minutes presentation
on Monday, July 2, 10:00-12:00 in room S3 218.
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.