Project in Software Engineering

339.018 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

Goal

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.

Topics

  • 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.
    Supervisor: DI Markus Weninger
    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).
    Supervisor: DI Markus Weninger
    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 error messages.
    Supervisor: DI Manuel Rigger
    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
    Supervisor: DI Manuel Rigger
    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.
    Student: ?

  • 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.
    Student: ?

  • 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.
    Student: ?

  • 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.
    Supervisor: DI Manuel Rigger
    Student: ?

  • 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.
    Supervisor: DI Manuel Rigger
    Student: ?

  • 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.
    Student: ?

  • 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.
    Student: ?

  • 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 Infrastructure.
    Student: ?

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

    Supervisor: DI Thomas Schatzl
    Student: ?

More Topics

Please see here

Final Presentation

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.

Marking

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.