Project in Software Engineering
Lengauer + members of SSW/CDL MEVSS/Oracle
||Introduction: Mo 7.3.2016, 16:00, S3 218
||Presentations: Mo 27.6.2016 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.
several public test suites. In this project, the test suite of Mozilla's spidermonkey engine should be added. The tool
should execute the existing tests with Graal.js, record whether tests are passed/failed, and report all passing or failing
Student: Gerald Aistleitner
Graph Visualization for Performance Monitoring
Performance monitoring is critical when developing a compiler or language implementation. The Graal and Truffle team uses a web platform to track benchmark results over time. The task of this project is to improve/replace the current benchmark visualisation charts to improve usability and performance.
Student: Markus Wagner
SIMD-API für Graal.js
Student: Dominik Aumayr
Extended G1 Support for AntTracks
supports G1 in a very basic manner only, i.e., only basic moves and the creation of an off-line heap state is supported. However, the AntTracks VM cannot trace pointers and the AntTracks Tool cannot visualize concurrent non-mutating GC phases. The goal of this project is to extend the AntTracks VM as well as the AntTracks Tool to bring the G1 to the same support level as the already fully-supported ParallelOldGC. This includes visualizing all GC phases, tracing pointers, and visualizing the heap state.
Student: Christina Rammerstorfer
The goal of this work is to extend the AntTracks Tool
to visualize the difference between two heap states. This includes selecting two points in time, running an already-implemented comparison algorithm, an visualizing the most prominent differences in a useful fashion. It also includes comparing the heap states of two different traces.
Student: Markus Weninger
Java Control Flow Analysis
The goal of this project is to build a control flow graph based on Java bytecode. It must then be determined which execution path is the most frequent one. This project is preliminary work for a Master Thesis about a lightweight allocation sensor.
Student: Stefan Fitzek
Program Analysis with Frama-C
Frama-C is a code analysis tool for analyzing C code which is based on an abstract interpretation. In this project Frama-C shall be used for extracting abstract representations of C code to support software documentation and program comprehension.
Student: Thomas Böhm
Product derivation in FORCE
FORCE is an Eclipse-based, feature-oriented modeling environment which is developed in the Christian Doppler Laboratory MEVSS to support software development in industrial software ecosystems. In this project, the FORCE modeling and development environment shall be extended to support derivation of concrete products from a selection of features.
Student: Daniel Hinterreiter
ECMAScript 2015 support for JONI RegExp Library (mostly Java)
uses the open-source JONI library. This library lacks support for some of the advanced features of the ECMAScript 2015 specification,
most prominently, the support to parse and execute Unicode. In this project, the implementation should be improved and tested.
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).
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
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 Netbeans (Netbeans, 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 or Netbeans is still rare. The goal of this project is to
debugging support for actor libraries and languages for instance for Netbeans to help developers to understand the dynamic behavior
of their code better.
Eagerly Merge Remembered Sets
During garbage collection, one main task of a garbage collector is to find heap references into the area to be garbage collected, the collection set. G1 uses remembered sets for this task, that record approximate locations of these references. Due to the organization of these remembered sets, there can be a significant amount of duplicates in them. Currently G1 spends a significant effort on duplicate detection during this garbage collection phase. The proposal for this task would be to create a prototype that extracts out this duplicate detection into a separate parallel phase. This phase would first create a single duplicate-free remembered set, which is then processed without any further time-consuming duplicate checking.
Improve existing G1 concurrent marking
The G1 garbage collector uses concurrent marking to get current liveness information about the heap contents. There are several known existing shortcomings of the current implementation that could be addressed as part of this practical: (1) objects are currently always marked as a single unit, G1 can not suspend marking after it started processing e.g. a single large object. This may delay a pending attempt to bring all threads to a halt significantly. Further it impedes scalability of the marking across multiple threads. The goal here would be to attempt to make object scanning interruptible like it is done elsewhere for processing large objects. (2) when the stack that individual threads use to record progress about the current marking fills up, G1 currently aborts and retries the marking. Only at the end of the entire marking, G1 may increase that memory allowance. This is suboptimal, because aborting and retrying does not guarantee progress, i.e. G1 might be stuck in a loop of aborting and retrying the marking. The goal is to change the behavior so that G1 allocates more memory during marking before bailing out. (3) the mark bitmaps used during marking eat up a significant amount of fixed memory. Look at alternatives for this and create a prototype. (E.g. JDK-8065402, JDK-8057003, ...)
Dynamically adjust parallelism in G1 phases
Some phases in the G1 garbage collection are either performed with a single thread or with all available threads depending on user options. The former is is slow, and the latter may be even slower in some cases because of overhead imposed by thread startup and shutdown. Investigate and implement some schemes that dynamically adjust the number of threads used according to e.g. amount of work available. (E.g. JDK-8076584, JDK-8076462, JDK-8043575)
Graphical DSL for the REMINDS Monitoring Framework
REMINDS is a tool-supported framework for monitoring systems of systems at runtime. The goal of this project is to develop a graphical DSL for specifying constraints and to evaluate its benefits.
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.