Research Projects of the Institute for System Software

Current Projects

• Christian Doppler Laboratory for Automated Software Engineering
  - Software Product Line Engineering
  - Domain-specific Languages for Industrial Automation
  - Plug-in Component Architectures
• Automatic Object Inlining in a Java Virtual Machine
• Escape Analysis in the Context of Dynamic Compilation and Deoptimization
• Automatic Elimination of Cyclic Dependencies in Software Systems
• C# Frontend for the Sotograph
• Recursive Descent Parser Generators for non LL(1) Grammars
• Compiler Generator Coco/R

Some Previous Projects

• Prof-It For C#: A Profiler For C#
• Eclipse Annotation Plugin
• Static Single Assignment Form and Register Allocation in a Java JIT Compiler
• Microsoft SSCLI (Rotor) Project: Compiler Generation Tools for C#
• Software Infrastructure for Pervasive Computing
• Component-Based Programming: Tools and Languages for Component-Assembly
• A Single-Workspace Java Environment
• Flexible Notification Semantics in Distributed Objects Systems
• Program Slicing for OO Programming Languages
• Composable Message Semantics in OO Programming Languages
• Oberon-D: On Adding Database Functionality to an OO Development Environment
• REFORM: A Reusable Framework for Rolling Mills
• Framework Design and Documentation
• An Email Gateway that can be Used From Every HTML Browser
• A Virtual Walk Over the Campus
• Several Projects in the Context of the Oberon System
  - Active Texts and Active Pictures
  - A Run Time Debugger
  - Reflection
  - Zero-Overhead Exception Handling
  - Dynamic Program Visualisation

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

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

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

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

Reflection

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