System Software
|
Home General Staff Contact Partners Alumni Research Areas Projects Papers Books Reports Awards Teaching Lectures Exams B.Theses M.Theses PhD Theses Go Abroad Misc Talks Library Gallery Links Search Webmaster |
Research Projects of the Institute for System SoftwareCurrent Projects
Some Previous Projects
eInformatics@Austria
Das Projekt eInformatics@Austria ist ein vom Bundesministerium für Bildung, Wissenschaft und Forschung im Rahmen der Initiative "Digitale und Soziale Transformation" gefördertes Projekt mit dem Ziel, MOOCs (Massively Open Online Course)
für die Grundausbildung in Informatik zu erstellen. Das Projekt wurde unter Führung der Technischen Universität Wien (Professor Futschek, Institut für Information Systems) federführend beantragt. Contact: Prähofer Scalable and Reactive Instantiable StatemachinesKooperationsprojekt mit Swiftlox GmbH, Linz
Das im Rahmen des Projektes "Passwort- und emailloser Online Account" der Firma Swiftlox GmbH werden Konzepte für reaktive Zustandsmaschinen
und Konzepte zum Monitoring und Tracing dieser Maschinen untersucht. Der passwortlose Account von Swiftlox zeichnet sich durch die Life-Verbindung
zwischen mehreren beteiligen Geräten aus. Die beteiligten Geräte besitzen dabei spezifische Aufgaben, die durch den zentralen Server gesteuert werden.
Durch die hohe Anzahl an parallelen Vorgängen und damit parallelen Verbindungen zum Server ist eine reaktive Architektur sinnvoll.
Ziel dieses Forschungsvorhabens ist daher die Untersuchung von Konzepten, wie eine sehr hohe Anzahl an zustandsbehafteten Vorgängen mit
nicht-trivialen Abläufen und Prüfungen mittels reaktiver Methoden realisiert werden kann, sodass die Geräte in quasi Echtzeit mit dem Server
kommunizieren könnnen.
Contact: Prähofer Reactive View UpdatesKooperationsprojekt 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. 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 programsCooperation with the 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 behaviorCooperation with Fujitsu Semiconductor Embedded Solutions Austria GmbH (FEAT) The Automotive area shows a trend towards sophisticated graphical user interfaces, e.g. for general-purpose displays. Mechanical displays are replaced by electronic displays, which makes them also richer and more powerful. Fujitsu Semiconductor Embeddes Solutions Austria GmbH (FEAT) has developed a software platform for designing such digital general-purpose displays (Cluster Displays). This platform consists of a 2D and a 3D engine together with a development environment (CGI Studio). It allows the development of MMIs with 2D and 3D elements in the Automotive area. In cooperation with Fujitsu we are adding a domain-specific language (CGI Designer DSL) which allows controlling the MMI elements of the Cluster Display using the sensor inputs of the car. 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. 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. DEMION / ISOP: Visualization and Interactive Manipulation of Optimized SchedulesThis 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. LaFO: "Lagerfahrtenoptimierung" for Hödlmayr Logistics GmbH / SchwertbergThe 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. Generalization of Just-in-Time Trace Compilation for JavaJava 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 DevicesThis 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 MachineObject-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 DeoptimizationEscape 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:
Contact:
Mössenböck,
Automatic Elimination of Cyclic Dependencies in Software SystemsCyclid 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 SotographThe 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. 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).
Contact: Mössenböck, Wimmer see also here Software Infrastructure for Pervasive ComputingIn 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 Eclipse Annotation PluginAn Eclipse Plugin for the annotation of Java files.
Contact:
Löberbauer 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.
Contact:
Birngruber
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).
Contact:
Wöß
Flexible Notification Semantics in Distributed Objects SystemsNotifications 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 LanguagesA 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
Composable Message Semantics in OO Programming LanguagesThis 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,
Oberon-D: On Adding Database Functionality to an OO Development EnvironmentWe 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,
REFORM: A Reusable Framework for Rolling MillsThis 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,
An Email Gateway that can be Used From Every HTML BrowserWe 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 DocumentationThis 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
A Virtual Walk Over the CampusWe 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.
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.
Contact:
Mössenböck
A Run-Time DebuggerIn 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
ReflectionA 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
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
Dynamic Program VisualizationWe 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 |