Praktikum aus Software Engineering

Ziele

Ziel dieses Praktikums ist es, ein größeres Softwareprojekt während eines Semesters eigenständig zu bearbeiten und durch alle Phasen (Anforderungserhebung, Entwurf, Implementierung, Test, Dokumentation) zu begleiten. Das Projekt sollte in Teams zu maximal jeweils 2 Personen bearbeitet werden und ist am Ende des Semesters in einem Vortrag zu präsentieren.

Themen

• Interaktive Sortieralgorithmen zu Präsentationszwecken
  Um Schülern die Arbeitsweise von Sortieralgorithmen nahezubringen, soll ein Demonstrationsprogramm entwickelt werden, mit dem verschiedene Sortierverfahren interaktiv durchgespielt werden können (z.B. durch Anklicken von zu vertauschenden Werten). Als Ergebnis soll eine visuell ansprechende Oberfläche entstehen, die zum Beispiel benutzt werden kann, um mehrere Schüler in einem "Sortierwettrennen" gegeneinander antreten zu lassen.
  Betreuer: Prof. Blaschek, Dipl.-Ing. Lengauer
  Bearbeiter: Wolfgang Küllinger


• Bibliotheksverwaltung
  The SSW institute library is currently managed by an application that is written in MS Access. The goal of this project is to port this application to a web-based Java solution with a MySQL database. The existing data must be migrated and several new features should be added.
  Betreuer: Prof. Mössenböck, Dipl.-Ing. Lengauer
  Bearbeiter: Johannes Pichler


• Allocation Tracing for the Hotspot VM
  The goal of this project is to build a tracing mechanism for allocations into the Hotspot VM. More precisely, each allocation of the interpreter, the client compiler and the VM itself must be written to dedicated a trace file. The information of such an allocation event (i.e., thread, type, allocation site) must be represented as compact as possible in order to allow for fast serialization. Furthermore, the event should be designed in such a way so that it can be precomputed at compile-time, enabling the compiler to inline the event as a constant value.
  Betreuer: Dipl.-Ing. Lengauer
  Bearbeiter: Verena Bitto, BSc


• Visualization of Abstract Syntax Trees with HTML5
  Abstract Syntax Trees (AST) are used as an internal representation in an interpreter. For the purpose of debugging, analysis, profiling, or program understanding, such trees should be visualized using HTML5. We envision a system that is independend of the language represented in the AST and presents all available information in a configurable way.
  Betreuer: Dr. Wirth
  Bearbeiter: Helmut Rohregger, Rumzucker Stefan


• MongoDB front-end for Truffle
  The Truffle language execution framework supports multiple languages, including Ruby and JavaScript. The goal of this project is to develop a front-end for the MongoDB database engine in order to use Truffle-based languages to query the database. The integration with Truffle and MongoDB will enable new, high-performance, and potentially parallel data processing with Truffle.
  Betreuer: Dr. Wirth, Bonetta, MSc
  Bearbeiter: Katalin Fazekas, Gergely Kalapos


• Function Inlining Heuristics for Dynamic Languages
  Function inlining is an important optimization for interpreters and compilers to improve performance of the guest program and to enable further optimizations. The inlining heuristics and supporting features (e.g. tree duplication) for an existing interpreter that executes a dynamic language should be further optimized. As a result the optimized inlining heuristic should improve peak performance compared to the previous heuristic.
  Betreuer: Dr. Würthinger
  Bearbeiter: Christian Humer

Offene Themen

• Neuentwicklung des Institutswegweisers
  Im Rahmen des Praktikums im SS2013 wurde der Institutswegweiser des SSW entwickelt. In einem Folgeprojekts sollen Schwachstellen und Verbesserungsvorschläge gesammelt und dokumentiert werden. Auf der Grundlage dieser Informationen soll ein Redesign vorgenommen und der Wegweiser neu implementiert werden.
  Betreuer: Prof. Blaschek, Dipl.-Ing. Lengauer
  Bearbeiter: ?


• Analyse von Git-Repositories auf Source-Code Ebene im Hinblick auf Change Patterns
  Anhand von Clustering Arlgorithmen sollen vorliegende Änderungen in Git Repositories analysiert werden um Änderungsähnlichkeiten und Änderungsmuster abzuleiten. Dazu muss für jedes Commit der Stand davor bzw danach extrahiert werden. Diese Commit-Pairs sollen mittels eines verfügbaren Parses in AST Repräsentation transformiert werden um sie dann paarweise zu vergleichen und mit Hilfe von verschiedenen Clustering Algorithmen zu klassifizieren. Die Ergebnisse sollen mit bereits manuell extrahierten Änderungsmuster verglichen werden.
  Betreuer: Dipl.-Ing. Lettner, Dipl.-Ing. Angerer
  Bearbeiter: ?


• Use serial/waiting time to perform independent tasks during young gc in G1
  In the Oracle HotSpot Garbage First (G1) collector, young GC often contains periods of time where worker threads are waiting for others (termination time) or executes something serially. This time could be used to perform some tasks that have no dependencies on other tasks and otherwise consume a significant amount of time. Prominent examples for such tasks are a string table and symbol table cleanup that take a significant (i.e. most) amount of time during other pauses, but could be scheduled at any time during a stop-the-world pause.
  Betreuer: Dipl.-Ing. Schatzl
  Bearbeiter: ?


• Improved collection failure handling in G1
  Collection failure, when there is not enough space to evacuate objects from the young generation to somewhere else, is a rare occurrence. For this reason, the mechanism to recover from these failures is extremely unoptimized, taking seconds on larger heaps. The existing handling should either be parallelized, or a better algorithm devised.
  Betreuer: Dipl.-Ing. Schatzl
  Bearbeiter: ?


• Automatic adaption of marking threshold
  Garbage First (G1) collector full heap compaction takes a lot of time, depending on live heap size taking a few seconds to minutes, so the situation where we need to perform a Full GC should be avoided. This is possible, if so-called mixed collections where parts of the heap are incrementally collected are scheduled early enough to start before application memory runs out. Preceding this mixed collections is a concurrent full-heap object graph traversal. At the moment this full heap traversal is triggered by statically setting a heap occupancy threshold. This is very rigid and inflexible. The task would be to implement a prototype that automatically determines this threshold according to evacuation rate, and how long it takes from the start of this full heap object graph traversal until the heap can be effectively defragmented.
  Betreuer: Dipl.-Ing. Schatzl
  Bearbeiter: ?


• Throughput G1 modifications
  There are many workloads in a VM that are inherently throughput-oriented: they need to complete as fast as possible, but it does not matter if there are longer pauses during processing. The Garbage First (G1) collector in the Oracle HotSpot VM on the other hand tries to provide consistent small pause time, sacrificing total performance in the process. A large part of that throughput is lost within the application, in code parts called barriers that are executed every time a reference is modified. The goal of this task would be to prototype a throughput oriented variant of G1 that changes (simplifies) the barriers and related code during garbage collection to compare performance with the original variant. The relevant code in the other, existing collectors in the Oracle HotSpot VM can be ported for this purpose.
  Betreuer: Dipl.-Ing. Schatzl
  Bearbeiter: ?


• NUMA for G1
  There have been a few attempts at adding NUMA support (exploiting locality of memory in multi-socket systems) of varying complexity into older versions of the Garbage First (G1) collector. The goal is to look at existing proof of concept implementations, try to unify them and measure impact. A NUMA system can be easily emulated on Linux for development, for performance tests suitable machines are available.
  Betreuer: Dipl.-Ing. Schatzl
  Bearbeiter: ?


• Visualization of Program Executions with HTML5
  Comprehending the execution of programs is a hard task, that can be enhanced by appropriate visualizations. We envision a HTML5-based system where a user can type in source code, the system executes this code, and annotates the source code with information collected during the execution (e.g., classes of nodes in the AST, or profiling information).
  Betreuer: Dr. Wirth
  Bearbeiter: ?


• Visualization of Execution Benchmarks with HTML5
  An existing benchmarking suite prints its results in textual form. This data should be stored in a database, and then visualized for easier comprehension. The visualizations should show all available information, e.g. the resons for improvements or regressions in performance.
  Betreuer: Dr. Wirth
  Bearbeiter: ?


• Instrumentation of Abstract Syntax Trees using Pattern Matching
  AST interpreter can use AST-level instrumentation to implement dynamic profiling, parallelism support, or language-level extensions. The goal of this project is to develop a general purpose AST instrumentation framework based on AST-level pattern matching. The framework shall allow language developers to specify modifications to existing ASTs using a syntax similar to the one of Scala's pattern matching.
  Betreuer: Dr. Wirth, Bonetta, MSc
  Bearbeiter: ?

Benotung

Die Note wird aus der Qualität der erstellten Software (Funktionalität, Benutzerfreundlichkeit, Robustheit, Klarheit der Architektur und des Programmierstils, Dokumentation) ermittelt. Am Semesterende ist das Ergebnis in einem kurzen Vortrag zu präsentieren. Der Vortrag sowie der persönliche Einsatz während des Projekts fließen ebenfalls in die Note ein.

Abschlussvortrag

Termin: ?
Raum: S3 218