logo of the SSW institute ;)
Computer Science
System Software




PhD Theses
Go Abroad



Research Projects of the Institute for System Software

Current Projects

Some Previous Projects

Reactive View Updates

Kooperationsprojekt mit CELUM GmbH, Linz

Das Projekt untersucht die Verwendung von neuen Java-Technologien, inbesondere Lambda-Expressions und funktionale Streams, für die Realisierung von reaktiven Server-Architekturen. Konkret sollen Mechanismen für ereignisorientierte Updates von Benutzersichten erforscht werden.

Contact: Prähofer

Meta-Level Engineering and Tooling for Complex Concurrent Systems

Collaboration with the Software Languages Lab at the Vrije Universiteit Brussel, Belgium.
This project is funded by the Austrian Science Fund (FWF) as project I 2491-N31 and by the Research Foundation Flanders (FWO).

In the last decade, multicore processors have become widely used for devices such as phones, tablets, and high-end servers. As a result, concurrent programming has become more important and complex software systems started to mix a wide range of concurrency models to solve both functional and non-functional requirements. Concurrency has, however, a pervasive influence on the whole system rather than being nicely confined to subsystems. This makes concurrent programs hard to understand and debug. Software tools for concurrent programs work on the lowest abstraction level, e.g., memory accesses, instead of the high-level concurrency concepts.

To support the development of such complex systems, we develop language implementation support in the form of a meta-level interface, which can capture the interaction amongst concurrency models to deliver the concepts needed to support tools. The research challenge is to identify a common meta-level interface that captures the essential properties of concurrency models, with a minimal performance overhead. A second major challenge is to investigate tool support, in particular, debugging tools that assist developers in finding errors, and improving program comprehension. Classic approaches can affect the way a program behaves. We work on minimizing such interference with program execution to avoid hiding concurrency issues.

Contact: Marr

Static code analysis of programmable logic controller programs

Kooperationsprojekt mit Software Competence Center Hagenberg GmbH (SCCH)

Static code analysis techniques analyze programs by examining the source code without actually executing them. In common, it is used to increase the quality of software by finding bad code smells and potential defects in early development stages. Today, they are widely spread and intensively used in general purpose programming and tools are numerous for established programming languages like C/C++, Java, C# and others. However, in the domain of programmable logic controller (PLC) programming static code analysis tools are generally not available yet.

In this project we therefore develop methods and tools for static code analysis of PLC programs. The tool allows parsing the source code files of PLC software and builds an internal representation of the programs in form of an abstract syntax tree (AST) augmented with type information. Based on the AST, the tool executes a set of user-definable rules to check for violations, which are written to an XML output file. Issues which can be detected in this way range from naming conventions, program complexity issues, bad code smells, incompatible configuration settings, problematic task interleaving and race conditions, possible performance problems, and violations of dynamic statement dependencies.

Currently the tool works for the KemroIEC which is a proprietary dialect of the IEC 61131 standard from Keba AG and is used by Engel Austria for analyzing their automation software solutions for their injection molding machines.

The project is a joint project with Software Competence Center Hagenberg and is conducted within the competence centres programme COMET of the Austrian Research Promotion Agency (FFG).

Contact: Prähofer

CGI-Designer DSL - Development of a domain-specific language for modelling reactive MMI behavior

Kooperationsprojekt mit Fujitsu Semiconductor Embedded Solutions Austria GmbH (FEAT)

Im Automotive Bereich ist ein Trend zu grafisch immer anspruchsvolleren Benutzerschnittstellen erkennbar. Ein Beispiel für diese Entwicklung ist das Kombiinstrument. Langsam werden die mechanischen Zeigerinstrumente teilweise oder zur Gänze durch elektronische Displays ersetzt. Dabei wird auch der Inhalt des Kombiinstruments vielfältiger und informativer.

Bei Fujitsu Semiconductor Embeddes Solutions Austria GmbH (FEAT) wurde für die Entwicklung solcher vollgrafischen Kombiinstrumente (Cluster Displays) eine Softwareplattform entwickelt. Diese Plattform besteht aus einer 2D- und einer 3D-Engine sowie der dazugehörigen Entwicklungsumgebung (CGI-Studio) und erlaubt die Erstellung von Mensch-Maschine-Schnittstellen (MMI) mit zwei- und dreidimensionaler Inhalten für eingebettete Systeme im Bereich Automotive, insbesondere für Kombiinstrumente.

Im Rahmen dieses Kooperationsprojektes wird die Entwicklungsumgebung um eine domänspezifische Sprache (CGI-Designer DSL) und dazugehörige Entwicklungsumgebung ergänzt. Die DSL soll es ermöglichen, die Ansteuerung der MMI-Elemente des Cluster Displays ausgehend von den Sensordaten des Fahrzeuges einfach zu programmieren. Entwicklungsplattform für DSL und Entwicklungsumgebung ist Eclipse RCP, EMF und xText.

Contact: Prähofer

RaSCH: Routing & Scheduling - A descriptive language for solving routing problems

Routing problems deal with transportation of goods from a source (the "depot") to multiple destinations (the customers). In the real world, a single order is less than a truckload, so multiple order (up to the truck's capacity) can be combined.
Variations of the problem include multiple trucks with different capacities, multiple depots, customers with time windows (e.g. opening hours), limited availability of trucks, etc.
In addition, the length of the routes and the time required can be determined or given in a number of ways. The places can be given by their coordinates, or they can be addresses on a map. Typically, the goal is to fulfill all orders with minimal costs.

In the RaSCH project, routing problems shall be solved by means of the OptLets optimization framework. The goal is to develop a programming language for describing the characteristics of a routing problem. A compiler then translates the description into the source text of an optimization system.

The RaSCH project is funded by Siemens AG, Munich.

Contact: Blaschek, Scheidl

DEMION / ISOP: Visualization and Interactive Manipulation of Optimized Schedules

This projects deals with different yet related topics in the context of optimization for scheduling problems. In previous projects, we developed the OptLets framework - a general basis for the efficient implementation of arbitrary optimization systems. Several cases studies already demonstrated the practical usability of the framework; one of these case studies showed how an OptLets-based optimizer can be used to solve scheduling problems.

In the DEMION project, visualizations of schedules are used to compare the OptLets approach with other heuristic optimizers. The visualizer allows interactive inspection of schedules and comparison of the objective functions.

The ISOP project attempts to combine interactive manipulations and (possibly contradicting) constraints of multiple users with automatic optimization. The goal of the optimizer is to reduce the total costs while respecting as many user-specified conditions as possible.

Both DEMION and ISOP are funded by Siemens AG, Munich.

Contact: Blaschek, Scheidl

LaFO: "Lagerfahrtenoptimierung" for Hödlmayr Logistics GmbH / Schwertberg

The goal of "Lagerfahrtenoptimierung" is to optimize effort, time and costs required to move vehicles in and out of the various storage spaces at Hödlmayr's compound in Schwertberg. This is a pilot project that is intended to demonstrate the practical usability of the OptLets framework in a real-life environment.

LaFO is part of a larger project, in which geographic positioning techniques are employed in order to locate and trace vehicles.

Contact: Blaschek, Scheidl

Generalization of Just-in-Time Trace Compilation for Java

Java source code is compiled to machine-independent bytecodes that are interpreted by a virtual machine. At run time, modern Java VMs use a just-in-time compiler (JIT compiler) to compile the most frequently executed methods to machine code while other methods continue to run in the interpreter. This leads to a good trade-off between execution speed and compilation overhead. As a further step in the same direction, it has been recently proposed to compile only certain paths through frequently executing loops while the rest of the program is interpreted. This is called trace compilation. It further reduces compilation times, allows for simpler and more aggressive optimizations, and makes compilers simple enough to run on resource-constrained devices.

Currently, trace compilation is restricted to paths through loops. However, there are also paths outside of loops which are executed frequently enough to justify their compilation to machine code. In other words, the concept of trace compilation can be generalized. The research goals of our project are therefore (1) to generalize the concept of the trace compilation by allowing traces to start and end anywhere in a program and by using techniques to split, merge, and glue traces together, (2) to abolish methods as execution units in compiled code and to replace them by traces that call each other using appropriate trace calling conventions, and (3) to investigate how traditional optimization techniques can be adapted and simplified for trace compilation.

We plan to integrate trace compilation into the Java HotSpot VM of Oracle, which is available from the open-source project OpenJDK.

Contact: Häubl, Mössenböck, Wimmer       see also here

Garbage Collection for High-End Mobile Devices

This research investigates garbage collection techniques targeted at multi-tasking client Java environments for high-end mobile devices, i.e. smartphones, MIDs and consumer devices. Although these are the primary target platforms, the results should also scale to moderately equipped desktop platforms.

These high-end mobile devices are expected to have a relatively low amount of memory available for Java applications, with a much decreased memory bandwidth and less processing power than regular desktops. This, in conjunction with other platform peculiarities requires consideration during garbage collector design.

Further, we expect that the target runs from two to three dozen applications, mostly interactive ones, potentially simultaneously, ranging from small widgets to larger applications. Garbage collection of these tasks should be isolated from each other, and it should promote short, regular pause times for high interactivity.

The main research platform is Oracle's Java HotSpot virtual machine with support for multi-tasking.

Contact: Schatzl       see also here

Automatic Object Inlining in a Java Virtual Machine

Object-oriented Java applications allocate many small objects linked together by field references. Object inlining tries to reduce the number of objects and therefore the number of pointer indirections by merging the referenced object with the referencing one. In programming languages like C++ and C#, this merging can be performed by the programmer with explicit value objects, but Java does not offer this possibility in favor of a simpler object model.

Automatic object inlining transforms reference objects to value objects when it can be proven that the semantics are not affected. This provides the access speed of value objects without complicating the object model. Typical examples that can be optimized by object inlining are collections: The highly reusable collection classes can be automatically embedded into the users' data objects, eliminating the reference from the data object to the collection object.

We develop an extension of the Java HotSpot Virtual Machine so that inlinable objects are detected and optimized at run time.

Contact: Mössenböck, Wimmer       see also here

Escape Analysis in the Context of Dynamic Compilation and Deoptimization

Escape analysis is used in compilers to identify and optimize the allocation of objects that are accessible only within the allocating method or thread. We developed a new intra- and interprocedural analysis for a dynamic compiler, which has to cope with dynamic class loading and deoptimization. The analysis was implemented for Sun Microsystems' Java HotSpot client compiler. It operates on an intermediate representation in SSA form and introduces equi-escape sets for the efficient propagation of escape information between related objects. Analysis results are used for scalar replacement of fields, stack allocation of objects and synchronization removal. The interprocedural analysis supports the compiler in inlining decisions and allows actual parameters to be allocated in the stack frame of the caller. A lightweight bytecode analysis produces interprocedural escape information for methods that have not been compiled yet.

Contact: Mössenböck, Kotzmann       see also here

Compiler Generator Coco/R

Coco/R takes a compiler description in the form of an attributed grammar and generates a scanner and a recursive descent parser. The user has to add semantic routines (e.g., symbol table handling and code generation) in order to get a full compiler. The benefits are a more compact and better readable compiler implementation as well as a speedup in development time. Coco/R is not only useful for building true compilers but also for doing any kind of syntax-directed translation. Examples include program analyzers, program instrumenters and browsers for structured input data. Coco/R is available under the GNU General Public License from the following sites:
- Java version
- C# version
- C++ version
- Oberon version
- Delphi version
- Modula-2, Pascal, and C versions

Contact: Mössenböck,
Documentation: User Manual, JMLC'03 paper, CC'90 paper
Pat Terry published a book on Compilers and Compiler Compilers which also describes the use of Coco/R. He also compiled a Coco resource page.

Automatic Elimination of Cyclic Dependencies in Software Systems

Cyclid dependencies between software components impede the readability, extensibility, and maintainability of a software system. A component that is cyclically dependent on others cannot be viewed in isolation but affects other components and is affected by them. The goal of this PhD project is to detect cyclic dependencies and to eliminate them in a (semi-) automatic way by transforming the software system according to various patterns.

Contact: Savernik

C# Frontend for the Sotograph

The Software Tomograph (Sotograph) is a tool for flexible static software analysis. Currently the Sotograph is able to analyse C/C++ and Java programs. The goal of our cooperation with Software Tomography is to enable the Sotograph to analyse C# source code. Therefore a scanner, a parser and a symbol table is needed for C#. The produced front end must be able to submit the accumulated symbol table information to the Sotograph. Furthermore the front end must be able to calculate reference information between the classes, like what element gets called, read or written from where.

Contact: Löberbauer

Recursive Descent Parser Generators for non LL(1) Grammars

Recursive descent parser generators like Coco/R have the advantage of generating fast and lightweight parsers for LL(1) grammars. Their mode of operation is well understood. Non LL(1) grammars however need additional handling to resolve LL(1) conflicts. Coco/R solves this problem with semantic lookahead expressions. Such a semantic lookahead is called a Conflict Resolver (resolver), and can be described as a boolean expression written by the user. As soon as the user writes such a resolver, Coco/R does not care about the lookahead symbol, but simply executes the given resolver to select the right alternative.
Certainly this approach works and is very powerful, as the user can use all features of the target language. However Coco/R can't verify the solution of the user. The user can easily overlook conflicts, or wrong resolvers may survive grammar changes. Our idea to solve this problem is to generate the conflict resolvers automatically via table controlled techniques.

Contact: Löberbauer

Microsoft SSCLI (Rotor) Project: Compiler Generation Tools for C#

For a detailed description and other information about the project see dotnet.jku.at/Projects/Rotor.

Contact: Wöß

Static Single Assignment Form and Register Allocation in a Java JIT Compiler

The HotSpot Java Client Compiler from Sun Microsystems is a just-in-time compiler that translates Java bytecodes to Intel machine code. In cooperation with Sun Microsystems we try to improve the quality of the generated code by load/store elimination, common subexpression elimination and register allocation. Our compiler is based on static single assignment form as an intermediate program representation. One of the challenges of this project is to find a reasonable tradeoff between code quality and compilation speed (which is highly important in JIT compilation).
We recently exchanged our graph coloring register allocator with a linear scan allocator, which is nearly as good as graph coloring but several times faster. We exploit lifetime holes and use instruction weights to improve the quality of the allocation.

Contact: Mössenböck, Wimmer       see also here

Software Infrastructure for Pervasive Computing

In combination with evolving technologies, such as small embedded devices and radio enabled Internet connections, new forms of software infrastructures are needed to support this new direction. This new software infrastructure should effectively handle context information of embedded devices in order to enable the development of "Personalized Computing", "Location Based Computing" and "Smart Computing" in general. An embedded device should be able to sense its environment, communicate with embedded devices and should support a more natural way of interaction between humans and digital devices.

Contact: Beer

Prof-It For C#: A Profiler For C#

Prof-It is an easy-to-use standalone profiler for C# that measures execution frequencies for each statement while keeping the instrumentation of the source code to a minimum.

Contact: Mössenböck
Further information

Eclipse Annotation Plugin

An Eclipse Plugin for the annotation of Java files.

Contact: Löberbauer
Further information

Component-Based Programming: Tools and Languages for Component-Assembly

The composition of binary software components divides the development process into two parts. First, component developers write new component libraries and second, application programmers use them to compose their applications.
This project introduces the idea of component plans and their description in Component Plan Language (CoPL) and the idea of a component technology independent composition language as an XML application, called Component Markup Language (CoML). The languages combined with tools for component composition try to bridge the knowledge gap between component developers and component assemblers and to automate the composition itself by remaining platform independent and as flexible as possible.

Contact: Birngruber
Publications and further information

A Single-Workspace Java Environment

Developing Java applications is often slowed down by being forced to restart a Virtual Machine (VM) after each modification of the code in order to test it. There is no way to explicitly unload single classes or small interdependent groups of classes, instead of unloading everything (by shutting down the VM).
In this project (which is part of an ongoing PhD thesis work) we try to keep one single VM running all the time, so that start-up delay will occur only once. From within the single "application manager" application, we start and stop other applications and allow explicit unloading of classes. All applications that are executing within this environment share all loaded classes entirely, i.e. all code and data is loaded only once and then reused (shared).
This not only reduces the class loading effort tremendously, it also paves the road for a (to Java) unique way of interaction and cooperation between different applications, because they can all see and modify each others' state.

Contact: Wöß
Publications: OOPSLA 2001 poster
Further information

Flexible Notification Semantics in Distributed Objects Systems

Notifications will be used to keep distributed data on different computers consistent. In most cases it is not possible to use only one approach of notification handling to model different aspects of distribution, consistency, optimizations, data mapping, etc. . The goal is to implement a framework which controls the flow of notifications between (distributed) components. The flow of notifications is specified in a flexible way by composition of different connection types and data mappings.

Contact: Rammerstorfer

Program Slicing for OO Programming Languages

A slice of a program with respect to a certain variable value is the smallest subset of this program which still produces the same variable value. Program slicing reduces the size of a program and can be used for reverse engineering and error tracing. We developed new techniques for inter-modular slicing of object-oriented programs based of data flow analyis. Special challenges in these kind of programs are the alias effects introduced by pointers and reference parameters as well as the dynamic binding of messages to methods, which requires one to consider all possible methods that could be invoked by a message. We developed new user guidance techniques to reduce the set of possible target methods. We implemented our techniques in a fully operational program slicer for Oberon programs.

Contact: Steindl
Further information

Composable Message Semantics in OO Programming Languages

This system emerged from the PhD thesis of Markus Hof. It allows one to introduce new or to modify existing invocation semantics of OO methods in an (almost) arbitrary manner. Using this mechanism one can add semantic actions (e.g. synchronisation, visualisation) to invocations. On top of this framework we implemented distributed objects which offer the same funtionality to a distributed system. One can set the semantics according to ones own needs (at-most-once, best-effort, ...).

Contact: Hof,
Further information

Oberon-D: On Adding Database Functionality to an OO Development Environment

We designed and implemented an object-oriented database system and integrated it with the Oberon system, blurring the difference between object-oriented programming and object-oriented databases. The basic idea is to give the user the illusion of an infinitely large memory on which all objects live and cooperate using object pointers and messages. Some objects can be specified as persistent roots. This causes all other objects that are reachable from the roots to be persistent as well. The system manages the internalization and externalization of persistent objects in a transparent way so that the programmer is not even aware that he is working with a database system. Oberon-D also includes automatic schema evolution, OQL queries (either as separate commands or as embedded OQL), as well as a basic recovery mechanism. So far, the system does not support concurrency and transactions because these facilities would be difficult to integrate with the Oberon environment which is a single user system.

Contact: Knasmüller,
Papers: JMLC'97 paper, ECOOP'97 paper
Further information

REFORM: A Reusable Framework for Rolling Mills

This was an Esprit project performed together with Siemens (D), Voest Alpine Stahl (A), Mandator (S), Uni Software Plus (A) and the university of Hamburg (D). The goal of this project is to develop an object-oriented framework for the process automation of hot rolling mills. The framework captures the invariant aspects of measured value processing, material tracking, mill pacing, machine learning, mathematical modeling, and process visualization, which are common to all kinds of hot rolling mills. It can be adapted for a specific rolling mill by adapting general framework classes and by plugging in custom-specific parts.

Contact: Mössenböck,
Further information

An Email Gateway that can be Used From Every HTML Browser

We implemented an Email gateway that can be used from any standard HTML browser to read or send electronic mail. All you need to know is the POP account on which your mail is stored as well as the password to access it. This tool is quite useful if you want to check your mail when you are away from home and do not want to configure a mail tool for this purpose.

Contact: Ertl

Framework Design and Documentation

This research is supported by two FWF grants(P10271-TEC and P11350-TEC). During the first period we developed a framework design technique that we called "design by stepwise generalization". Starting from a problem specification we suggest to generalize the problem to its most abstract form. In a second phase we suggest to implement the generalizations in reverse order using a sequence of frameworks that are refinements of each other. This not only leads to a solution of the original problem but also to a set of frameworks (at different abstraction levels) that can be used to solve similar problems.

Contact: Mössenböck, Koskimies
Papers: ESEC'96 paper
Further information, Project description

A Virtual Walk Over the Campus

We implemented an Email gateway that can be used from any standard HTML browser to read or send electronic mail. All you need to know is the POP account on which your mail is stored as well as the password to access it. This tool is quite useful if you want to check your mail when you are away from home and do not want to configure a mail tool for this purpose.

Contact: Schrank

The Oberon System

Oberon is both a programming language and a runtime environment, both designed by Niklaus Wirth and Jürg Gutknecht at ETH Zurich. It is an object-oriented system with garbage collection, dynamic loading and so-called commands. Commands are procedures that can be called like programs from a shell. They provide multiple entry points to a software system.
The Oberon System is simple and efficient, and provided a good "working horse" for many of our projects. For more information see here.

Contact: Mössenböck

Active Texts and Active Pictures

Traditionally, documents are passive -- they can just be read. Active documents, on the other hand, contain also active objects that react on user input and help or even guide the user in browsing the document and perform document-related tasks. Hypertext documents are a first step in that direction but we are trying to go beyond them.
Based on an active text framework, we developed a text editor that helps the user to structure and document source code by inserting active objects (so-called text elements) into the text. Current element kinds support mechanisms such as folding, linking and annotating, but new kinds of elements can add almost arbitrary functionality to the editor. The research was done in the Oberon system but there is also an implementation of active texts for SNiFF+, a commercial programming environment for C++ and Java.
We extended an existing graphics editor so that it stores a picture not as a whole but as a sequence of drawing steps that can be played forwards and backwards like a film. The user can see how the drawing evolves. At every step, he can get explanatory comments so that he can understand what goes on. He can even explore different alternatives which lead to different pictures. We use animation to show how a data structure changes as a result of some algorithm. Active pictures can be included in texts and even in the source code of programs so that they can be combined with code and documentation. The reader of a program text can use them as graphical comments and can look at a film to learn about dynamic aspects of the code.

Contact: Mössenböck
Papers: SPE paper, Softwaretechnik Trends, Reverse Literate Programming, TOOLS'97 paper
Further information

A Run-Time Debugger

In this project, a run time debugger was developed for Oberon. It allows the inspection of the program state (variable values, procedure activations) as well as single stepping and the definition of breakpoints. It also includes a post mortem facility. The debugger does not rely on reference files generated by the compiler but obtains the necessary reference information by recompiling modules on demand. This is an appropriate technique on fast machines and simplifies the compiler which does not have to generate reference information any more. The debugger is included in the Oberon System for the Power Macintosh (requires at least System 7.5) and has been ported to Oberon for Windows as well as Oberon for Linux.

Contact: Hof
Further information


A programming system is reflective if programs can obtain run-time information about themselved or about other programs. Information includes the names and values of variables, the structure of types, the current contents of the activation stack, etc. This information can be used for example to implement debugging services, embedded command languages, general print routines, or exception handling mechanisms. We implemented a set of Oberon modules which allow programs to use reflection.

Contact: Mössenböck
Further information

Zero-Overhead Exception Handling

We present a novel approach to exception handling which is based on metaprogramming. Our mechanism does not require language support, imposes no run time overhead to error-free programs, and is easy to implement. Exception handlers are implemented as ordinary procedures. When an exception occurs, the corresponding handler is searched dynamically using the type of the exception as a search criterion. Our implementation was done in the Oberon System but it could be ported to most other systems that support metaprogramming.

Contact: Mössenböck
Further information

Dynamic Program Visualization

We have implemented a tool that shows the message flow between the objects of a program using UML-style object interaction diagrams. The visualization in produced in two steps. First, the program to be visualized is instrumented so that it produces a trace when it is running. This trace is then visualized. In order to handle hundreds of objects and thousands of messages on a small-size computer screen, we use hypertext facilities to show the information on various abstraction levels. The user can zoom into messages to see the inner message flow, he can exclude certain objects from the diagram or restrict the diagram to certain other objects. There are links from the diagram to the source code, to class interfaces and even to class diagrams.

Contact: Mössenböck, Koskimies