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


Project in Software Engineering

339.018 Mössenböck, 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

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

  • Executing Mozilla JavaScript Testsuite with Graal.js (Java, Python, JavaScript)
    Graal.js is a JavaScript interpreter, implemented in Java. The implementation is verified by executing 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 testcases.
    Contact: Dr. Wirth
    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.
    Supervisor: Dr. Grimmer
    Student: Markus Wagner

  • SIMD-API für Graal.js
    Graal.js ist ein Interpreter für JavaScript (ECMAScript 2015), implementiert in Java als Interpreter eines Abstrakten Syntax-Baumes (AST). Es benutzt die Technik der Baum-Spezialisierung um die Ausführung zu optimieren. Im Rahmen dieses Projektes soll die Graal.js-Engine den für eine zukünftige ECMAScript-Spezifikation geplante SIMD-API (Single Instruction, Multiple Data) unterstützen. Basierend auf den derzeitig vorliegenden Entwürfe der Spezifikation soll Support für diese API in Graal.js implementiert werden. Diese API ist basierend auf bestehenden Implementierungen, zum Beispiel durch Google V8, zu testen. Im Rahmen dieser Arbeit ist vorrangig die API zu unterstützen. Die Implementierung besteht im wesentlichen in der Portierung bestehender Polyfills von JavaScript nach Java. Die Ausführung der Befehle durch Vektor-Hardware-Instruktionen oder sonstige Optimierungen übersteigen den Rahmen dieser Arbeit.
    Supervisor: Dr. Grimmer
    Student: Dominik Aumayr

  • Extended G1 Support for AntTracks
    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.
    Supervisor: DI Lengauer
    Student: Christina Rammerstorfer

  • Heap Diffing
    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.
    Supervisor: DI Lengauer
    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.
    Supervisor: DI Lengauer
    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)
    Graal.js is a JavaScript interpreter, implemented in Java. To execute regular expressions (RegExp), it 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.
    Contact: Dr. Wirth
    Student: ?

  • Node.js benchmark suite (JavaScript, Node.js)
    Node.js is a JavaScript-based runtime environment (mostly) for server-sided web applications. To track the performance of engines executing Node.js applications and compare them, a set of Node.js specific benchmarks should be written. While existing JavaScript 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).
    Contact: Dr. Wirth, Dr. Bonetta
    Student: ?

  • 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 language-indepentent.
    Contact: Dr. Wirth, Dr. Bonetta
    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.
    Contact: Dr. Wirth, Dr. Bonetta
    Student: ?

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

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

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

  • 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, ...)
    Supervisor: DI Schatzl
    Student: ?

  • 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)
    Supervisor: DI Schatzl
    Student: ?

  • 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.
    Supervisor: Dr. Rabiser
    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. 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.