Research

Our research activities are centered around the architecture of computing systems: From hardware over system software up to languages and compilers. We target special-purpose systems that have to cope with tight demands regarding nonfunctional properties, such as noise reduction, timeliness, robustness and hardware resources. We mostly do fundamental research with auxiliary funding provided by the DFG. Our Focus is on constructive methods for the design and development of versatile (real-time) operating systems that provide an extreme degree of (automatic) tailorability towards concrete (nonfunctional) application requirements and hardware properties.

Topics

We investigate application-specific system software that provides fine-grained static/dynamic adaptability to specific functional requirements and, thereby, also indirect control over its emergent nonfunctional properties. Towards this end, our research topics include:

Adaptable System Software
that excels with respect to many nonfunctional properties, such as noise, timeliness, latency, predictability, or footprint due to its tailorability towards both ends, application and hardware (see our USENIX '09, RTSS '09, RTSS '12, ECRTS '14, and RTAS '15 papers). In the same manner, our RTOS implementations also provide excellent robustness aginst soft errors and other single-event upsets (see RTAS '15, EDCC '15, and SQJ 24.1). Recently, we have also started to investigate the domain of HW-RTOS co-design by instantiating the application-specific RTOS functionality directly into the processor pipeline (LCTES '17).
Static and Dynamic Analysis
of applications and their utilization of the system software in a whole-system approach for the fully automatic configuration and tailoring, but also the tightening of worst-case response times, attack surface, and footprint. Examples include the finding of configurability-related bugs in Linux (EuroSys '11, USENIX '14), application-specific tailoring and attack-surface reduction of Linux (HotDep '12, NDSS '13, and GPCE '14), the automatic optimization and formal validation of application-tailored RTOS instances (TECS 16.2, FMCAD '17 ), and the tightening of end-to-end WCRTs across the RTOS boundary (RTAS '17).

Compilation and Generation
as well as language-based approaches to implement, automatically instantiate, and test versatile system software and deal with the practical challenges of high configurability and adaptability, as described in our EuroSys '06, AOSD '11, GPCE '15, GPCE '16, and USENIX '17 papers.

Philosophy and Approach

System software provides no business value of its own. Its utility and sole purpose is to serve a concrete application's needs, that is, to map the functional and nonfunctional requirements of a particular software precisely and efficiently to the functional and nonfunctional properties of the employed hardware.

Goal
Adaptable System Software

Hence, system software development is caught between a rock and a hard place: On the one hand, the operating system must not stand in the way by overly abstracting from the hardware and providing unneeded functionality. On the other hand, it has to serve each application's very specific needs by offering a broad set of abstractions. This is particularly challenging in the case of highly heterogeneous, but special-purpose systems, such as embedded systems: Efficiency calls for specific, hand-crafted system software; reuseability demands generic, versatile solutions. System software has to be adaptable to both ends.

Method
Static and Dynamic Analysis

To overcome this dilemma and systematically provide for adaptability, we understand system software (and partly also the underlying hardware) as a (software) product line described by their configurable features implemented by means of fine-grained static (and partly also dynamic) configuration. Application-tailored instances are derived by selecting from this set of features.

In practice, however, the set of available features and their constraints quickly becomes unmanageably large: Linux, for instance, already provides more than 15,000 configurable features, implemented in over 100,000 files and #ifdef blocks. This imposes big challenges not only for development and testing of system-software product lines, but also the process of deriving a concrete, tailored instance for a specific application itself – how to choose the right ones from thousands of available features?

Automation is the key! We investigate static (and, where necessary, also dynamic) analysis techniques to come up with a detailed model, how a particular application uses and interacts with the operating system, that is, which features and parts of the system software are actually needed.

Technique
Compilation and Generation

In the case of existing system software, like Linux, we then use this model to automatically generate a tailored configuration for this particular application. For the much finer-grained tailorability offered by our own system software, we exploit this knowledge directly inside the compiler to automatically generate application-specific instances of the required RTOS functionality (we mostly target OSEK and AUTOSAR, but also ARINC and other standards), which, in the extreme cases, could also be pushed down into the hardware.

Research Projects

Map of our research activities with projects and selected publications.
The "key publication" for a particular project is depicted in bold face.
Papers marked with an * asterisk have received a Best Paper Award.
Most projects have been funded by the DFG

Running Projects

AHA: Automated Hardware Abstraction in Operating-System Engineering
Goal of AHA is to improve nonfunctional properties of system software by a very deep, but fully automated specialization of the application-hardware bridge represented by the operating system. We investigate, how alternative implementations that are mapped more directly to hardware features, can be generated from a concrete application and their actual interactions with the operating system.
CADOS: Configurability-Aware Development of Operating Systems (DFG: LO 1719/3-1)
In the CADOS project, we investigate scalable methods and tools to deal with the implementation of variability across all implementation layers of modern system software.
Sloth: Minimal-effort kernels for embedded systems
The main research goal in the Sloth project is to investigate how to make better use of given hardware abstractions in (embedded) operating systems.
cHash: Avoid redundant build operations by AST-based hashing
Building software can include many redundant compiler invocations. With the AST hashing mechanism developed in this project, compiler invocations can be aborted before wasting the developers time.
dOSEK: A dependability-Oriented Static Embedded Kernel (DFG: LO 1719/1-3)
dOSEK is developed from scratch with dependability as the first-class design goal. Targeting safety-critical, embedded applications, the system provides an OSEK/AUTOSAR-conform interface. dOSEK is part of the danceOS project.
danceOS: dependability aspects in embedded Operating Systems (DFG: SPP 1500)
Future hardware designs for embedded systems are expected to exhibit an increasing rate of intermittent and permanent errors in exchange for smaller device sizes and lower energy consumption. The DanceOS project aims at providing dependability by the fine-grained and tailorable application of software-based fault-tolerance techniques.
iRTSS: invasive Runtime Support System (DFG: SFB/TRR 89, Project C1)
Operating-system support for massively parellel systems running self-aware applications under the paradigm of invasive computing.

Finished Projects

AspectC++: An aspect-oriented extension to the C++ programming language
AspectC++ is a set of C++ language extensions and compiler support to facilitate aspect-oriented programming with C/C++.
CiAO: Aspect-oriented operating-system product lines
RTOS kernels that provide configurability of even fundamental, architectural kernel policies, like synchronization or protection by means of aspect-aware software development.
ISEco: Internal Software Ecosystems
In software ecosystems, organizations open their platform to external businesses in order to leverage a variety of externally developed functionality. We investigated two large-scale software projects (about 500 and 950 developers) within Siemens that have become internal software ecosystems.
PLiC: Decomposition and Composition of Software Product Lines (Siemens CT)
Software Product Line Development has achieved multiple benefits within the last decades, as it facilitates systematic reuse of various assets throughout the software development lifecycle, but so far only in settings with a rather narrow scope. In the PliC project, we investigated a systematic approach for the decomposition and composition of software product lines.
SiHeB: System-software infrastructure for hegerogenous image systems (DFG GRK 1773)
To enhance the throughput of image processing applications, hardware coprocessors can help to offload computational tasks. The host CPU is responsible for the main scheduling of threads that start computations to be run on the coprocessor, which often uses a distinct instruction set architecture and manages its own local memory. Thus, such systems with coprocessors inherently form heterogeneous architectures.
VAMOS: Variability Management in Operating Systems
In the VAMOS project, we pioneered the issue of variability-induced issues in Linux and investigated methods and tools to mitigate the problem. Our findings have led to more than 100 accepted patches in the Linux mainline kernel.