A Bibliometric Approach for Detecting the Gender Gap in Computer Science - Mattauch, Sandra; Lohmann, Katja; Hannig, Frank; Lohmann, Daniel; Teich, Jürgen (Communications of the ACM, 2020)
Keywords: Gender gap; Computer science; Frauenanteil; MINT; Informatik

Advances in AOP with AspectC++ - Spinczyk, Olaf; Lohmann, Daniel; et al. (New Trends in Software Methodologies Tools and Techniques, 2005)
Often declared dead or at least dying, C/C++ is still the lingua franca of many application domains. Aspect-Oriented Programming (AOP) is a programming paradigm that supports the modular implementation of crosscutting concerns. Thereby, AOP improves the maintainability, reusability, and configurability of software in general. Although already popular in the Java domain, AOP is still not commonly used in conjunction with C/C++. For a broad adoption of AOP by the software industry, it is crucial to provide solid language and tool support. However, research and tool development for C++ is known to be an extremely hard and tedious task, as the language is overwhelmed with interacting features and hard to analyze. Getting AOP into the C++ domain is not just technical challenge. It is also the question of integrating AOP concepts with the philosophy of the C++ language, which is very different from Java. This paper describes the design and development of the AspectC++ language and weaver, which brings fully-fledged AOP support into the C++ domain.
UnivIS-Import:2015-04-16:Pub.2005.tech.IMMD.IMMD4.advanc
Keywords: AspectC++

A Generalization of the Hyperspace Approach using Meta-Models - Lohmann, Daniel; et al. (Early Aspects 2003: Aspect-Oriented Requirements Engineering and Architecture Design, 2003)
UnivIS-Import:2015-04-16:Pub.2003.tech.IMMD.IMMD4.agener
Keywords: AOSD; Design Language; Hyperspace

A JVM for Soft-Error-Prone Embedded Systems - Stilkerich, Isabella; Strotz, Michael; Erhardt, Christoph; Hoffmann, Martin; Lohmann, Daniel; Scheler, Fabian; Schröder-Preikschat, Wolfgang (Proceedings of the 14th ACM SIGPLAN/SIGBED International Conference on Languages, Compilers, Tools and Theory for Embedded Systems, 2013)
The reduction of structure sizes in microcontollers, environmental conditions or low supply voltages increase the susceptibility of embedded systems to soft errors. As a result, the employment of fault-detection and fault-tolerance measures is becoming a mandatory task even for moderately critical applications. Accordingly, software-based techniques have recently gained in popularity, and a multitude of approaches that differ in the number and frequency of tolerated errors as well as their associated overhead have been proposed. Using type-safe programming languages to isolate critical software components is very popular among those techniques. An automated application of fault-detection and fault-tolerance measures based on the type system of the programming language and static code analyses is possible. It facilitates an easy evaluation of the protection characteristics and costs as well as the migration of software to new hardware platforms with different failure rates. Transient faults, however, are not bound to the application code secured by the type system, but can also affect the correctness of the type system itself. Thereby, the type system might lose its ability to isolate critical components. As a consequence, it is essential to also protect the type system itself against soft errors. In this paper, we show how soft errors can affect the integrity of the type system. Furthermore, we provide means to secure it against these faults, thus preserving its isolating character. These measures can be applied selectively to achieve a suitable tradeoff between level of protection and resource consumption. Copyright © 2013 ACM.
UnivIS-Import:2015-04-16:Pub.2013.tech.IMMD.IMMD4.ajvmfo
Keywords: KESO; DanceOS; AORTA; Java; RTSJ; Embedded Systems; Real-Time Systems; Reliability

A Memory Management Library for CT-Reconstruction on GPUs - Wu, Hao; Berger, Martin; Maier, Andreas; Lohmann, Daniel (Bildverarbeitung für die Medizin, 2016)
UnivIS-Import:2016-06-01:Pub.2016.tech.IMMD.IMMD5.amemor
Keywords: GRK-1773

Analyzing the Impact of Feature Changes in Linux - Ziegler, Andreas; Rothberg, Valentin; Lohmann, Daniel (Proceedings of the Tenth International Workshop on Variability Modelling of Software-intensive Systems, 2016)
In a software project as large and as rapidly evolving as the Linux kernel, automated testing systems are an integral component to the development process. Extensive build and regression tests can catch potential problems in changes before they appear in a stable release. Current systems, however, do not systematically incorporate the configuration system Kconfig. In this work, we present an approach to identify relationships between configuration options. These relationships allow us to find source files which might be affected by a change to a configuration option and hence require retesting. Our findings show that the majority of configuration options only affects few files, while very few options influence almost all files in the code base. We further observe that developers sometimes value usability over clean dependency modelling, leading to counterintuitive outliers in our results.<br
UnivIS-Import:2017-12-18:Pub.2016.tech.IMMD.IMMD4.analyz
Keywords: CADOS; Linux

An Asynchronous Nonblocking Coordination and Synchronization Protocol for a Parallel Robotic Control Kernel - Stellwag, Philippe; Lohmann, Daniel; Schröder-Preikschat, Wolfgang (Proceedings of the 2nd Workshop on Isolation and Integration in Embedded Systems (IIES 2009), 2009)
Over the last 25 years, performance improvements by the steady increase of CPU clock frequencies were the driving factor for innovations in the domain of computationally intensive embedded applications. Now the free lunch is over [12] - developers have to parallelize their systems in order to achieve further improvements by integration of multi-core platforms. In embedded systems, this is even more challenging than in the domain of desktop computers, as safety properties and hard real-time constraints impose a much stronger demand on determinism. In this experience report, we present a concrete coordination and synchronization problem for a double buffering procedure that arose on our ongoing attempts to parallelize a robotic control kernel. This double buffering procedure used by two tasks must as-sure a consistent data flow without data losses. Therefore, we approach a fast bounded wait-free solution, which does not suffer from priority inversion. Copyright 2009 ACM.
UnivIS-Import:2015-04-16:Pub.2009.tech.IMMD.IMMD4.anasyn
Keywords: pCtrl; multi-core; many-core; robotic control kernel; real-time; embedded; safety-critical; parallelization

An Infrastructure for Composing Build Systems of Software Product Lines - Elsner, Christoph; Lohmann, Daniel; Schröder-Preikschat, Wolfgang (Proceedings of 15th International Software Product Line Conference (SPLC 2011), Volume 2, 2011)
Deriving a product from a software product line may require various build tasks, such as model transformations, source code generation, preprocessing, compiling, as well as linking and packaging the compiled sources. Usually implemented using simple scripting languages, such as Apache ant or GNU make, build systems tend to become monolithic entities, which are intricate to adapt and maintain. This makes developing the build system for a multi-product-line, which is composed of several sub-product-lines and maybe other configurable components, particularly challenging. Several, previously independent build systems- possibly implemented using different build tools (ant, make, etc.)-need to be integrated. In this paper, we approach this by using models to describe the involved build tasks (including their input and output parameters) as well as their composition. An interpreter evaluates the models and executes the tasks in the composed order with the configured parameters to produce the final product. Our approach enables the interaction of build systems implemented with different tools with only little development effort, whereas the build order and parameter flow is made explicit in the models. We have started to apply our tooling to model the build system of two multi-product-lines, where it reveals sufficient expressiveness and clarifies the build system interaction. Copyright © 2011 ACM.
UnivIS-Import:2015-04-16:Pub.2011.tech.IMMD.IMMD4.aninfr
Keywords: Build system integration; Software product line

An Infrastructure for Model-Driven Hierarchical Product Lines (in german) - Elsner, Christoph; Lohmann, Daniel; et al. (GI Proceedings 150 "Software Engineering 2009 - Workshopband": 02.-06. März 2009, Kaiserslautern, 2009)
UnivIS-Import:2015-04-16:Pub.2009.tech.IMMD.IMMD4.einein
Keywords: Hierarchical Software Product Line; Model-Driven Software Development

A Practitioner's Guide to Software-based Soft-Error Mitigation Using AN-Codes - Hoffmann, Martin; Ulbrich, Peter; Dietrich, Christian; Schirmeier, Horst; Lohmann, Daniel; Schröder-Preikschat, Wolfgang (Proceedings of the 15th IEEE International Symposium on High Assurance Systems Engineering (HASE '14), 2014)
Arithmetic error coding schemes (AN codes) are a well known and effective technique for soft error mitigation. Although coding theory being a rich area of mathematics, their implementation seems to be fairly easy. However, compliance with the theory can be lost easily while moving towards an actual implementation - finally jeopardizing the aspired fault-tolerance characteristics. In this paper, we present our experiences and lessons learned from implementing AN codes in the Cored dependable voter. We focus on the challenges and pitfalls in the transition from maths to machine code for a binary computer from a systems perspective. Our results show, that practical misconceptions (such as the use of prime numbers) and architecture-dependent implementation glitches occur on every stage of this transition. We identify typical pitfalls and describe practical measures to find and resolve them. Our measures eliminate all remaining SDCs in the Cored voter, which is validated by an extensive fault-injection campaign that covers 100 percent of the fault space for 1-bit and 2-bit errors. © 2014 IEEE.
UnivIS-Import:2015-04-16:Pub.2014.tech.IMMD.IMMD4.apract
Keywords: DanceOS; CoRed; Operating Systems; Embedded Systems; Real-Time Systems; Dependability; Safety; Coded Processing

A Quantitative Analysis of Aspects in the eCOS Kernel - Lohmann, Daniel; Scheler, Fabian; Tartler, Reinhard; Spinczyk, Olaf; Schröder-Preikschat, Wolfgang (Proceedings of the EuroSys 2006 Conference, 2006)
Nearly ten years after its first presentation and five years after its first application to operating systems, the suitability of Aspect-Oriented Programming (AOP) for the development of operating system kernels is still highly in dispute. While the AOP advocacy emphasizes the benefits of AOP towards better configurability and maintainability of system software, most kernel developers express a sound skepticism regarding the thereby induced runtime and memory costs: Operating system kernels have to be lean and efficient.We have analyzed the runtime and memory costs of aspects in general, on the level of μ-benchmarks, and by refactoring and extending the eCos operating system kernel using AspectC++, an AOP extension to the C++ language. Our results show that most AOP features do not induce a intrinsic overhead and that the actual overhead induced by AspectC++ is very low. We have also analyzed a test case with significant aspect-related costs. This example shows how the structure of the underlying kernel can have a negative impact on aspect implementations and how these costs can be avoided by an aspect-aware design.Based on this analysis, our conclusion is that AOP is suitable for the development of operating system kernels and other kinds of highly efficient infrastructure software.
UnivIS-Import:2015-04-16:Pub.2006.tech.IMMD.IMMD4.aquant
Keywords: AOP; AspectC++; CiAO; eCos

Architecture Challenges for Internal Software Ecosystems: A Large-Scale Industry Case Study - Schultis, Klaus-Benedikt; Elsner, Christoph; Lohmann, Daniel (Proceedings of the 22nd International Symposium on Foundations of Software Engineering (FSE '14), 2014)
UnivIS-Import:2015-04-16:Pub.2014.tech.IMMD.IMMD4.archit
Keywords: Distinguished Paper Award; Architecture; Software Ecosystems; Experience; ISEco

Architecture-Neutral Operating System Components - Lohmann, Daniel; Spinczyk, Olaf (SOSP '03: Work-in-Progress Session, 2003)
UnivIS-Import:2015-04-16:Pub.2003.tech.IMMD.IMMD4.archit
Keywords: AOP; OS Design

Architecture-Violation Management for Internal Software Ecosystems - Schultis, Klaus-Benedikt; Elsner, Christoph; Lohmann, Daniel (Proceedings of the 13th Working IEEE/IFIP Conference on Software Architecture (WICSA 2016), 2016)
UnivIS-Import:2016-06-01:Pub.2016.tech.IMMD.IMMD4.archit

A Resource-Aware Nearest Neighbor Search Algorithm for K-Dimensional Trees - Paul, Johny; Stechele, Walter; Kroehnert, Manfred; Asfour, Tamim; Oechslein, Benjamin; Erhardt, Christoph; Schedel, Jens; Lohmann, Daniel; Schröder-Preikschat, Wolfgang (Proceedings of the 2013 Conference on Design & Architectures for Signal & Image Processing, 2013)
Kd-tree search is widely used today in computer vision - for example in object recognition to process a large set of features and identify the objects in a scene. However, the search times vary widely based on the size of the data set to be processed, the number of objects present in the frame, the size and shape of the kd-tree, etc. Constraining the search interval is extremely critical for real-time applications in order to avoid frame drops and to achieve a good response time. The inherent parallelism in the algorithm can be exploited by using massively parallel architectures like many-core processors. However, the variation in execution time is more pronounced on such hardware (HW) due to the presence of shared resources and dynamically varying load situations created by applications running concurrently. In this work, we propose a new resource-aware nearest-neighbor search algorithm for kd-trees on many-core processors. The novel algorithm can adapt itself to the dynamically varying load on a many-core processor and can achieve a good response time and avoid frame drops. The results show significant improvements in performance and detection rate compared to the conventional approach while the simplicity of the conventional algorithm is retained in the new model.
UnivIS-Import:2015-04-16:Pub.2013.tech.IMMD.IMMD4.aresou

A Robust Approach for Variability Extraction from the Linux Build System - Dietrich, Christian; Tartler, Reinhard; Schröder-Preikschat, Wolfgang; Lohmann, Daniel (Proceedings of the 16th International Software Product Line Conference, 2012)
With more than 11,000 optional and alternative features, the Linux kernel is a highly configurable piece of software. Linux is generally perceived as a textbook example for preprocessor-based product derivation, but more than 65 percent of all features are actually handled by the build system. Hence, variability-aware static analysis tools have to take the build system into account. However, extracting variability information from the build system is difficult due to the declarative and turing-complete MAKE language. Existing approaches based on text processing do not cover this challenges and tend to be tailored to a specific Linux version and architecture. This renders them practically unusable as a basis for variability-aware tool support - Linux is a moving target! We describe a robust approach for extracting implementation variability from the Linux build system. Instead of extracting the variability information by a text-based analysis of all build scripts, our approach exploits the build system itself to produce this information. As our results show, our approach is robust and works for all versions and architectures from the (git-)history of Linux. Copyright © 2012 ACM.
UnivIS-Import:2015-04-16:Pub.2012.tech.IMMD.IMMD4.arobus
Keywords: Algorithms; Design; Experimentation; Management; Languages; Configurability; Maintenance; Linux; Kbuild; Static Analysis; Variability; VAMOS

Aspect-Awareness in the Development of Configurable System Software - Lohmann, Daniel (Friedrich-Alexander-Universität Erlangen-Nürnberg, 2009)
UnivIS-Import:2016-07-26:Pub.2009.tech.IMMD.IMMD4.aspect

Aspect-Aware Operating System Development - Lohmann, Daniel; Hofer, Wanja; Schröder-Preikschat, Wolfgang; Spinczyk, Olaf (Proceedings of the 10th International Conference on Aspect-Oriented Software Development (AOSD 2011), 2011)
The domain of operating systems has often been mentioned as an "ideal candidate" for the application of AOP; fundamental policies we find in these systems, such as synchronization or preemption, seem to be inherently cross-cutting in their implementation. Their clear separation into dedicated aspect modules should facilitate better evolvability and - the focus of this paper - configurability. Our experience with applying AOP to the domain of highly configurable embedded operating systems has shown, however, that these advantages can by no means be taken for granted. To reveal maximum configurability of central system policies, aspects and their potential interactions with the system have to be taken into account much earlier, that is, "from the very beginning". We propose the analysis and design process of aspect-aware development, which leads to such an "aspect- friendly" system structure and demonstrate its feasibility on the example of CiAO, an AUTOSAR-OS-compliant operating system that provides configurability of all fundamental system policies by means of AOP.
UnivIS-Import:2015-04-16:Pub.2011.tech.IMMD.IMMD4.aspect
Keywords: CiAO; AOP; Aspect-Oriented Programming; AspectC++; Operating Systems; Embedded Systems; VAMOS

AspectC++: An AOP Extension for C++ - Lohmann, Daniel; Spinczyk, Olaf; et al. (Software Developer's Journal, 2005)
UnivIS-Import:2015-03-09:Pub.2005.tech.IMMD.IMMD4.aspect

AspectC++: An integrated approach for static and dynamic adaptation of system software - Tartler, Reinhard; Lohmann, Daniel; Scheler, Fabian; Spinczyk, Olaf (Knowledge-Based Systems, 2010)
Modern computer systems require an enormous amount of flexibility. This is especially the case in low-level system software, from embedded devices to networking services. From literature and practice, various approaches to modularize and integrate adaptations have been investigated. However, most of this work is implemented with dynamic languages that offer extensive run-time support and enable easy integration of such approaches. System software is written in languages like C or C++ in order to minimize utilization of system resources and maximize efficiency. While for these languages highly optimized and reliable compilers are available, the support for static and dynamic adaptation is rather limited. In order to overcome these limitations, we present an adaptation approach that is based on a sophisticated combination of static and dynamic aspect weaving for aspects written in AspectC++. This facilitates the incremental evolution and deployment of system software that has to be "always on". We demonstrate the feasibility of our approach and its applicability to two pieces of system software, namely the Squid web proxy and the eCos operating system, which is used in the domain of resource-constrained deeply embedded systems. © 2010 Elsevier B.V. All rights reserved.
UnivIS-Import:2015-03-09:Pub.2010.tech.IMMD.IMMD4.aspect
Keywords: Adaptable systems; AOP; AspectC++; C++; Programming languages

AspectC++: aspektowe rozszerzenie C++ - Lohmann, Daniel; Spinczyk, Olaf; et al. (Software Developer's Journal, 2005)
UnivIS-Import:2015-03-09:Pub.2005.tech.IMMD.IMMD4.aspect_6

AspectC++: extension de la Programmation Orientée Aspect pur C++ - Lohmann, Daniel; Spinczyk, Olaf; et al. (Software Developer's Journal, 2005)
UnivIS-Import:2015-03-09:Pub.2005.tech.IMMD.IMMD4.aspect_0

Aspect-Oriented Real-Time Architecture - AORTA - Scheler, Fabian; Lohmann, Daniel; Spinczyk, Olaf; Schröder-Preikschat, Wolfgang (Proceedings Work-In-Progress Session RTSS'06, 2006)
UnivIS-Import:2015-04-16:Pub.2006.tech.IMMD.IMMD4.aspect

Attack Surface Metrics and Automated Compile-Time OS Kernel Tailoring - Kurmus, Anil; Tartler, Reinhard; Dorneanu, Daniela; Heinloth, Bernhard; Rothberg, Valentin; Ruprecht, Andreas; Schröder-Preikschat, Wolfgang; Lohmann, Daniel; Kapitza, Rüdiger (Proceedings of the 20th Network and Distributed System Security Symposium (NDSS '13), 2013)
UnivIS-Import:2015-04-16:Pub.2013.tech.IMMD.IMMD4.attack
Keywords: VAMOS; Configurability; System Software; Software Engineering; Maintenance; Security

Automated Application of Fault Tolerance Mechanisms in a Component-Based System - Stilkerich, Isabella; Stilkerich, Michael; Kapitza, Rüdiger; Lohmann, Daniel; Schröder-Preikschat, Wolfgang (Proceedings of the 9th International Workshop on Java Technologies for Real-Time and Embedded Systems, 2011)
Due to the reduction of structure sizes in modern embedded systems, tolerating soft errors presenting itself as bit flips becomes a mandatory task even for moderate critical applications. Accordingly, software-based fault tolerance mechanisms recently gained in popularity and a multitude of approaches that differ in the number and frequency of tolerated errors as well as their associated overhead have been proposed. As a consequence, an application- and environment-tailored selection of mechanisms is required to balance protection and costs. Accounting the diverse solution space, we propose to make software-based fault tolerance a matter of configuration that should be transparent to the applications. While this would be cumbersome when using an unsafe programming language, we show that in the context of KESO, a JVM for deeply embedded systems, this can be achieved by utilizing the Java type system and static code analysis. As an initial technique we decided to add redundant execution to KESO, which enables us to selectively and transparently replicate an application. This essentially builds a first step to a JVM, which offers reliable execution of components as demanded by the system configuration. © 2011 ACM.
UnivIS-Import:2015-04-16:Pub.2011.tech.IMMD.IMMD4.automa
Keywords: Java; embedded systems; fault tolerance; TMR; KESO; DanceOS

Automatic Feature Selection in Large-Scale System-Software Product Lines - Ruprecht, Andreas; Heinloth, Bernhard; Lohmann, Daniel (Proceedings of the 2014 International Conference on Generative Programming: Concepts and Experiences, 2014)
UnivIS-Import:2015-04-16:Pub.2014.tech.IMMD.IMMD4.automa
Keywords: CADOS; VAMOS; Linux; Tailoring; optimiziaton; experimentation

Automatic OS Kernel TCB Reduction by Leveraging Compile-Time Configurability - Tartler, Reinhard; Kurmus, Anil; Heinloth, Bernhard; Rothberg, Valentin; Ruprecht, Andreas; Dorneanu, Daniela; Kapitza, Rüdiger; Schröder-Preikschat, Wolfgang; Lohmann, Daniel (Proceedings of the 8th Workshop on Hot Topics in System Dependability (HotDep '12), 2012)
The Linux kernel can be a threat to the dependability of systems because of its sheer size. A simple approach to produce smaller kernels is to manually configure the Linux kernel. However, the more than 11000 configuration options available in recent Linux versions render this a demanding task. We report on designing and implementing the first automated generation of a workload-tailored kernel configuration and discuss the security gains such an approach offers in terms of reduction of the Trusted Computing Base (TCB) size. Our results show that the approach prevents the inclusion of 10% of functions known to be vulnerable in the past.<br
UnivIS-Import:2015-04-16:Pub.2012.tech.IMMD.IMMD4.automa_0
Keywords: VAMOS; Configurability; System Software; Software Engineering; Maintenance; Security

Back to the Roots: Implementing the RTOS as a Specialized State Machine - Dietrich, Christian; Hoffmann, Martin; Lohmann, Daniel (11th Annual Workshop on Operating Systems Platforms for Embedded Real-Time Applications, 2015)
UnivIS-Import:2015-07-08:Pub.2015.tech.IMMD.IMMD4.backto

CiAO: An Aspect-Oriented Operating-System Family for Resource-Constrained Embedded Systems - Lohmann, Daniel; Hofer, Wanja; Schröder-Preikschat, Wolfgang; et al. (Proceedings of the 2009 USENIX Annual Technical Conference (USENIX 2009), 2009)
UnivIS-Import:2015-04-16:Pub.2009.tech.IMMD.IMMD4.ciaoan
Keywords: CiAO; AOP; Aspect-Oriented Programming; AspectC++; Operating Systems; Embedded Systems

CiAO/IP: A Highly Configurable Aspect-Oriented IP Stack - Borchert, Christoph; Lohmann, Daniel; Spinczyk, Olaf (MobiSys '12: Proceedings of the 10th international conference on Mobile systems, applications, and services, 2012)
Internet protocols are constantly gaining relevance for the domain of mobile and embedded systems. However, building complex network protocol stacks for small resource-constrained devices is more than just porting a reference implementation. Due to the cost pressure in this area especially the memory footprint has to be minimized. Therefore, embedded TCP/IP implementations tend to be statically configurable with respect to the concrete application scenario. This paper describes our software engineering approach for building CiAO/IP - a tailorable TCP/IP stack for small embedded systems, which pushes the limits of static configurability while retaining source code maintainability. Our evaluation results show that CiAO/IP thereby outperforms both lwIP and uIP in terms of code size (up to 90% less than uIP), throughput (up to 20% higher than lwIP), energy consumption (at least 40% lower than uIP) and, most importantly, tailorability. © 2012 ACM.
UnivIS-Import:2015-04-16:Pub.2012.tech.IMMD.IMMD4.ciaoip
Keywords: aop; aspect-oriented programming; aspectc++; embedded systems; internet protocol; network protocol stacks; operating systems; tcp/ip; CiAO; DanceOS

Concern Hierarchies - Spinczyk, Olaf; Lohmann, Daniel; Schröder-Preikschat, Wolfgang (Proceedings for First Workshop on Aspect-oriented Product Line Engineering (AOPLE-1), 2006)
UnivIS-Import:2015-04-16:Pub.2006.tech.IMMD.IMMD4.concer
Keywords: Concern Hierarchies; AOP; AspectC++; Operating Systems; Product Lines

Concern Impact Analysis in Configurable System Software - The AUTOSAR OS Case - Hofer, Wanja; Lohmann, Daniel; Schröder-Preikschat, Wolfgang (Proceedings of the 7th Workshop on Aspects, Components, and Patterns in Infrastructure Software (ACP4IS 2008), 2008)
System software for cost-sensitive special purpose-systems has to be configurable and tailorable. AOSD should be beneficial for this purpose, as it provides means to untangle the system's concerns in a very fine-grained way. An important prerequisite for a fine-grained software design based on aspects is, however, that all concerns and their interactions present in the system have been comprehensively captured and understood. We propose a method called Concern Impact Analysis for this purpose. Based on a system's specification, CIA provides a guideline to iteratively grasp the concerns present in a system, and their interactions. A speciality of CIA is that it also takes unspecified internal concerns into consideration as early as possible. We have tested CIA with the AUTOSAR OS specification and the design of our CiAO operating system family, where it led to a very fine-grained, aspect-aware kernel design. Copyright © 2008 ACM.
UnivIS-Import:2015-04-16:Pub.2008.tech.IMMD.IMMD4.concer
Keywords: Aspect-Oriented Design; AOP; AOSD; CiAO; Configurability; AUTOSAR; Aspect-Aware Operating System

Configurable Memory Protection by Aspects - Lohmann, Daniel; Hofer, Wanja; Spinczyk, Olaf; Schröder-Preikschat, Wolfgang; et al. (Proceedings of the 4th Workshop on Programming Languages and Operating Systems (PLOS 2007), 2007)
We describe the implementation of memory protection by means of aspect-oriented programming (AOP) in CiAO, an AUTOSAR-like family of embedded operating systems. The use of AOP was originally motivated by the fact that memory protection is a cross-cutting policy, which, furthermore, has to be configurable at build-time in AUTOSAR. We learned, however, that besides switching between full protection and no protection, an AOP-based approach also makes it easy to apply completely different models of protection. For the domain of statically configured embedded systems, where certain failure scenarios can often be excluded by means of code analysis or even probability, this facilitates tailored and light-weight "nav-as-vou-use" protection strateaies Copyright 2007 ACM.
UnivIS-Import:2015-04-16:Pub.2007.tech.IMMD.IMMD4.config
Keywords: Aspect-Oriented Programming (AOP); AspectC++; CiAO; Configurability; Aspect-Aware Operating System; Memory Protection

Configuration coverage in the analysis of large-scale system software - Tartler, Reinhard; Lohmann, Daniel; Dietrich, Christian; Egger, Christoph; Sincero, Julio (Operating Systems Review, 2012)
UnivIS-Import:2015-04-14:Pub.2012.tech.IMMD.IMMD4.config
Keywords: VAMOS; Configurability; System Software; Software Engineering; Maintenance

Consistent Product Line Configuration Across File Type and Product Line Boundaries - Elsner, Christoph; Ulbrich, Peter; Lohmann, Daniel; Schröder-Preikschat, Wolfgang (Proceedings of the 14th International Software Product Line Conference (SPLC 2010), 2010)
Creating a valid software configuration of a product line can require laborious customizations involving multiple configuration file types, such as feature models, domain-specific languages, or preprocessor defines in C header files. Using configurable off-the-shelf components causes additional complexity. Without checking of constraints across file types boundaries already at configuration time, intricate inconsistencies are likely to be introduced-resulting in product defects, which are costly to discover and resolve later on. Up to now, at best ad-hoc solutions have been applied. To tackle this problem in a general way, we have developed an approach and a corresponding plug-in infrastructure. It allows for convenient definition and checking of constraints across configuration file types and product line boundaries. Internally, all configuration files are converted to models, facilitating the use of model-based constraint languages (e.g., OCL). Converter plug-ins for arbitrary configuration file types may be integrated and hide a large amount of complexity usually associated with modeling. We have validated our approach using a quadrotor helicopter product line comprising three sub-product-lines and four different configuration file formats. The results give evidence that our approach is practically applicable, reduces time and effort for product derivation (by avoiding repeated compiling, testing, and reconfiguration cycles), and prevents faulty software deployment. © 2010 Springer-Verlag Berlin Heidelberg.
UnivIS-Import:2015-04-16:Pub.2010.tech.IMMD.IMMD4.consis
Keywords: SPL; Software Product Lines; VAMOS; CiAO

Crosscheck: Hardening replicated multithreaded services - Martens, Arthur; Borchert, Christoph; Geissler, Tobias Oliver; Lohmann, Daniel; Spinczyk, Olaf; Kapitza, Rüdiger (Proceedings of the International Conference on Dependable Systems and Networks, 2014)
State-machine replication has received widespread attention for the provisioning of highly available services in data centers. However, current production systems focus on tolerating crash faults only and prominent service outages caused by state corruptions have indicated that this is a risky strategy. In the future, state corruptions due to transient faults (such as bit flips) become even more likely, caused by ongoing hardware trends regarding the shrinking of structure sizes and reduction of operating voltages. In this paper we present Crosscheck, an approach to tolerate arbitrary state corruption (ASC) in the context of fault-tolerant replication of multithreaded services. Crosscheck is able to detect silent data corruptions ahead of execution, and by crosschecking state changes with co-executing replicas, even ASCs can be detected. Finally, fault tolerance is achieved by a fine-grained recovery using fault-free replicas. Our implementation is transparent to the application by utilizing fine-grained software-hardening mechanisms using aspect-oriented programming. To validate Crosscheck we present a replicated multithreaded key-value store that is resilient to state corruptions.
CRIS-Team Scopus Importer:2022-07-19
Keywords: AspectC++; Determinism; Multithreading; Replication; Software Error Hardening

Cross-Kernel Control-Flow-Graph Analysis for Event-Driven Real-Time Systems - Dietrich, Christian; Hoffmann, Martin; Lohmann, Daniel (Proceedings of the 16th ACM SIGPLAN/SIGBED International Conference on Languages, Compilers, Tools and Theory for Embedded Systems, 2015)
UnivIS-Import:2015-04-17:Pub.2015.tech.IMMD.IMMD4.crossk
Keywords: Static Analysis; Control-Flow Graph; Cross-Kernel Analysis; Real-Time Systems; Optimization; Compiler

Defmacro for C: Lightweight, Ad Hoc Code Generation - Selgrad, Kai; Lier, Alexander; Wittmann, Markus; Lohmann, Daniel; Stamminger, Marc (Proceedings of ELS 2014 7th European Lisp Symposium, 2014)
We describe the design and implementation of CGen, a C code generator with support for Common Lisp-style macroexpansion. Our code generator supports the simple and efficient management of variants, ad hoc code generation to capture reoccurring patterns, composable abstractions as well as the implementation of embedded domain specific languages by using the Common Lisp macro system. We demonstrate the applicability of our approach by numerous examples from small scale convenience macros over embedded languages to real-world applications in high-performance computing.
Keywords: GRK-1773

Design and Architectures for Dependable Embedded Systems - Henkel, Jörg; Bauer, Lars; Becker, Joachim; Bringmann, Oliver; Brinkschulte, Uwe; Chakraborty, Samarjit; Engel, Michael; Ernst, Rolf; Härtig, Hermann; Hedrich, Lars; Herkersdorf, Andreas; Kapitza, Rüdiger; et al. (Proceedings of the 9th International Conference on Hardware/Software Codesign and System Synthesis (CODES+ISSS '11), 2011)
The paper presents an overview of a major research project on dependable embedded systems that has started in Fall 2010 and is running for a projected duration of six years. Aim is a 'dependability co-design' that spans various levels of abstraction in the design process of embedded systems starting from gate level through operating system, applications software to system architecture. In addition, we present a new classification on faults, errors, and failures. Copyright 2011 ACM.
UnivIS-Import:2015-04-16:Pub.2011.tech.IMMD.IMMD4.design_4
Keywords: embedded systems; dependable systems; danceos

Developing embedded software product lines with AspectC++ - Lohmann, Daniel; Spinczyk, Olaf (OOPSLA '06: Companion to the 21st ACM SIGPLAN conference on Object-oriented programming languages, systems, and applications, 2006)
AspectC++ is a general purpose aspect-oriented language extension to C++. It is aimed to bring fully-fledged aspect-oriented programming (AOP) support in areas with strong demands on runtime efficiency and code density. This makes it possible to exploit the power of AOP for the domain of (deeply) embedded systems, where computation speed and available memory resources are strictly limited. AOP concepts are particularly useful for the development of scalable embedded system product lines. This will be demonstrated by a real world example: a small embedded device equipped with meteorological sensors and an 8-bit micro-controller running AspectC++ code. By covering the complete build cycle of configuration, compilation and installation, participants will understand, how easy it is to integrate AspectC++ with an existing tool chain. A presentation of the AspectC++ tools for Eclipse and the pure::variants variant-management system rounds up the demonstration.
UnivIS-Import:2015-04-16:Pub.2006.tech.IMMD.IMMD4.develo
Keywords: AOP; AspectC++; Software Product Lines; embedded

Dimensions of Variability in Embedded Operating Systems - Schröder-Preikschat, Wolfgang; Lohmann, Daniel; Scheler, Fabian; Spinczyk, Olaf (Informatik - Forschung und Entwicklung, 2007)
Design, implementation, and re-engineering of operating systems are still an ambitious undertaking. Despite, or even because, of the long history of theory and practice in this field, adapting existing systems to environments of different conditions and requirements as originally specified or assumed, in terms of functional and/or non-functional respects, is anything but simple. Especially this is true for the embedded systems domain which, on the one hand, calls for highly specialized and application-aware system abstractions and, on the other hand, cares a great deal for easily reusable implementations of these abstractions. The latter aspect becomes more and more important as embedded systems technology is faced with an innovation cycle decreasing in length. Software for embedded systems needs to be designed for variability, and this is in particular true for the operating systems of this domain. The paper discusses dimensions of variability that need to be considered in the development of embedded operating systems and presents approaches that aid construction and maintenance of evolutionary operating systems. © 2007 Springer-Verlag.
UnivIS-Import:2015-03-09:Pub.2007.tech.IMMD.IMMD4.dimens
Keywords: Cross-cutting concerns; Customization; Embedded systems; Non-functional properties; Operating systems; Portability; Specialization

DistRM: Distributed Resource Management for On-Chip Many-Core Systems - Kobbe, Sebastian; Bauer, Lars; Lohmann, Daniel; Schröder-Preikschat, Wolfgang; Henkel, Jörg (Proceedings of the 9th International Conference on Hardware/Software Codesign and System Synthesis (CODES+ISSS '11), 2011)
The trend towards many-core systems comes with various issues, among them their highly dynamic and non-predictable workloads. Hence, new paradigms for managing resources of many-core systems are of paramount importance. The problem of resource management, e.g. mapping applications to processor cores, is NP-hard though, requiring heuristics especially when performed online. In this paper, we therefore present a novel resource-management scheme that supports so-called malleable applications. These applications can adopt their level of parallelism to the assigned resources. By design, our (decentralized) scheme is scalable and it copes with the computational complexity by focusing on local decision-making. Our simulations show that the quality of the mapping decisions of our approach is able to stay near the mapping quality of stateof- the-art (i.e. centralized) online schemes for malleable applications but at a reduced overall communication overhead (only about 12,75% on a 1024 core system with a total workload of 32 multi-threaded applications). In addition, our approach is scalable as opposed to a centralized scheme and therefore it is practically useful for employment in large many-core systems as our extensive studies and experiments show. Copyright 2011 ACM.
UnivIS-Import:2015-04-16:Pub.2011.tech.IMMD.IMMD4.distrm
Keywords: embedded systems; operating systems; resource management; invasic

dOSEK: A Dependable RTOS for Automotive Applications - Hoffmann, Martin; Dietrich, Christian; Lohmann, Daniel (Proceedings of the 19th IEEE Pacific Rim International Symposium on Dependable Computing (PRDC '13), 2013)
Recent automotive systems exhibit an increased susceptibility against transient hardware faults. As a consequence, dependability measures are mandatory to provide appropriate fault detection or masking properties fulfilling the required safety standards. On the other and, production costs are still a crucial factor in this domain, which leads to hardware consolidation and therefore mixed-criticality systems. An existing dependability approach, supporting such systems, combines triple modular redundancy with encoded operations, but still leaves the operating system as single point of failure. We intend to close this gap by extending the encoded operations throughout the kernel execution, and additionally integrate the analyzed system behavior into the code. © 2013 IEEE.
UnivIS-Import:2015-04-16:Pub.2013.tech.IMMD.IMMD4.doseka
Keywords: dependability; EAN; DanceOS; OSEK; dosek; embedded systems; CoRed

Dynamic AspectC++: Generic Advice at Any Time - Tartler, Reinhard; Lohmann, Daniel; Schröder-Preikschat, Wolfgang; et al. (Frontiers in Artificial Intelligence and Applications, 2009)
In theory, the expressive power of an aspect language should be independent of the aspect deployment approach, whether it is static or dynamic weaving. However, in the area of strictly statically typed and compiled languages, such as C or C++, there seems to be a feedback from the weaver implementation to the language level: dynamic aspect languages offer noticeable fewer features than their static counterparts. Especially means for generic aspect implementations are missing, as they are very difficult to implement in dynamic weavers. This hinders reusability of aspects and the application of AOP to scenarios where both, runtime and compile-time adaptation is required. Our solution to overcome these limitations is based on a novel combination of static and dynamic weaving techniques, which facilitates the support of typical static language features, such as generic advice, in dynamic weavers for compiled languages. In our implementation, the same AspectC++ aspect code can now be woven statically or dynamically into the Squid web proxy, providing flexibility and best of bread for many AOP-based adaptation scenarios. © 2009 IOS Press. All rights reserved.
UnivIS-Import:2015-04-16:Pub.2009.tech.IMMD.IMMD4.dynami
Keywords: AOP; Aspect-opriented Programming; AspectC++; Dynamic Aspect Weaving; Languages

Effectiveness of Fault Detection Mechanisms in Static and Dynamic Operating System Designs - Hoffmann, Martin; Borchert, Christoph; Dietrich, Christian; Schirmeier, Horst; Kapitza, Rüdiger; Spinczyk, Olaf; Lohmann, Daniel (Proceedings of the 17th IEEE International Symposium on Object/Component/Service-oriented Real-time Distributed Computing (ISORC '14), 2014)
UnivIS-Import:2015-04-16:Pub.2014.tech.IMMD.IMMD4.effect
Keywords: DanceOS; dosek; osek; dependability; static system

Effectiveness of Software-Based Hardening for Radiation-Induced Soft Errors in Real-Time Operating Systems - Santini, Thiago; Borchert, Christoph; Dietrich, Christian; Schirmeier, Horst; Hoffmann, Martin; Spinczyk, Olaf; Lohmann, Daniel; Rech Wagner, Flávio; Rech, Paolo (Architecture of Computing Systems – ARCS 2015, 2017)
UnivIS-Import:2017-03-24:Pub.2017.tech.IMMD.IMMD4.effect
Keywords: Reliability; Operating System; Embedded System; Dependable System; RTOS; Neutron; eCos; dOSEK pdfcreator=

Eliminating Single Points of Failure in Software-Based Redundancy - Ulbrich, Peter; Hoffmann, Martin; Kapitza, Rüdiger; Lohmann, Daniel; Schröder-Preikschat, Wolfgang; Schmid, Reiner (Proceedings of the 9th European Dependable Computing Conference, 2012)
In the domain of safety-critical embedded and cyber-physical systems, software-based redundancy is generally understood as an effective and cheap approach to improve reliability. Especially redundant execution in terms of triple modular redundancy is a well-known solution. However, triple modular redundancy (TMR) leaves unprotected single points of failure (SPOFs), such as the voter, which have to be carefully considered in all safety considerations. We present Combined Redundancy (CoRed), a holistic approach that hardens safety-critical parts of a system against soft-errors, while effectively eliminating the vulnerability caused by SPOFs. CoRed leverages redundant execution in combination with encoded processing to tackle the unprotected voting and data distribution. Its implementation does not require specific knowledge about the application and can be easily integrated into existing projects. We evaluated CoRed in a realistic setting using a quad rotor helicopter and provide experimental evidence for soft-error resistance and comparable low resource demand. In our experimental comparison plain TMR left more than seven percent of failures undetected, whereas CoRed was able to eliminate all silent data corruptions while inducing an overhead of just seven percen
UnivIS-Import:2015-04-16:Pub.2012.tech.IMMD.IMMD4.elimin
Keywords: Domain-specific architectures; Fault-tolerance; Frameworks; Reliability; Soft errors; Software and System Safety; DanceOS

Escaping the Bonds of the Legacy: Step-Wise Migration to a Type-Safe Language in Safety-Critical Embedded Systems - Stilkerich, Michael; Schedel, Jens; Ulbrich, Peter; Schröder-Preikschat, Wolfgang; Lohmann, Daniel (Proceedings of the 14th IEEE International Symposium on Object/Component/Service-oriented Real-time Distributed Computing (ISORC '11), 2011)
Type-safe high-level languages such as Java have not yet found their way into the domain of deeply embedded systems, even though numerous attempts have been made to make these languages cost attractive. One major challenge that remains is the huge existing code base in many industries. Completely reengineering this code base is not viable for cost and time reasons. We present an approach that allows to isolatedly combine legacy software components and safe software components in an embedded system using the two most common communication idioms found in this domain. Our approach allows the developer to freely choose between hardware- and software-based isolation mechanisms. We demonstrate the feasibility of our approach by porting a non-trivial part of a real-world, hard real-time embedded avionics application. Our results show that the cost of this mixed-mode operation is on the same scale as the pure operation. © 2011 IEEE.
UnivIS-Import:2015-04-16:Pub.2011.tech.IMMD.IMMD4.escapi
Keywords: CiAO; Java; KESO; OSEK/VDX; embedded systems; memory protection; spatial isolation

Experiences with software-based soft-error mitigation using AN codes - Hoffmann, Martin; Ulbrich, Peter; Dietrich, Christian; Schirmeier, Horst; Lohmann, Daniel; Schröder-Preikschat, Wolfgang (Software Quality Journal, 2016)
Arithmetic error coding schemes are a well-known and effective technique for soft-error mitigation. Although the underlying coding theory is generally a complex area of mathematics, its practical implementation is comparatively simple in general. However, compliance with the theory can be lost easily while moving toward an actual implementation, which finally jeopardizes the aspired fault-tolerance characteristics and effectiveness. In this paper, we present our experiences and lessons learned from implementing arithmetic error coding schemes (AN codes) in the context of our Combined Redundancy fault-tolerance approach. We focus on the challenges and pitfalls in the transition from maths to machine code for a binary computer from a systems perspective. Our results show that practical misconceptions (such as the use of prime numbers) and architecture-dependent implementation glitches occur at every stage of this transition. We identify typical pitfalls and describe practical measures to find and resolve them. This allowed us to eliminate all remaining silent data corruptions in the Combined Redundancy framework, which we validated by an extensive fault-injection campaign covering the entire fault space of 1-bit and 2-bit error
UnivIS-Import:2015-04-20:Pub.2014.tech.IMMD.IMMD4.experi
Keywords: Fault injection; Arithmetic code; Dependability

Experiences with Software-based Soft-Error Mitigation using AN-Codes - Hoffmann, Martin; Ulbrich, Peter; Dietrich, Christian; Schirmeier, Horst; Lohmann, Daniel; Schröder-Preikschat, Wolfgang (Software Quality Journal, 2016)
Arithmetic error coding schemes are a well-known and effective technique for soft-error mitigation. Although the underlying coding theory is generally a complex area of mathematics, its practical implementation is comparatively simple in general. However, compliance with the theory can be lost easily while moving toward an actual implementation, which finally jeopardizes the aspired fault-tolerance characteristics and effectiveness. In this paper, we present our experiences and lessons learned from implementing arithmetic error coding schemes (AN codes) in the context of our Combined Redundancy fault-tolerance approach. We focus on the challenges and pitfalls in the transition from maths to machine code for a binary computer from a systems perspective. Our results show that practical misconceptions (such as the use of prime numbers) and architecture-dependent implementation glitches occur at every stage of this transition. We identify typical pitfalls and describe practical measures to find and resolve them. This allowed us to eliminate all remaining silent data corruptions in the Combined Redundancy framework, which we validated by an extensive fault-injection campaign covering the entire fault space of 1-bit and 2-bit errors.
UnivIS-Import:2018-09-06:Pub.2016.tech.IMMD.IMMD4.experi
Keywords: DanceOS; CoRed; Operating Systems; Embedded Systems; Real-Time Systems; Dependability; Safety; Coded Processing; ARES; ESI

Exploiting Static Application Knowledge in a Java Compiler for Embedded Systems: A Case Study - Erhardt, Christoph; Stilkerich, Michael; Lohmann, Daniel; Schröder-Preikschat, Wolfgang (Proceedings of the 9th International Workshop on Java Technologies for Real-Time and Embedded Systems, 2011)
Offering many benefits in terms of productivity and reliability, Java is becoming an attractive choice for the field of embedded computing. However, its programming model that relies on the capabilities of just-in-time compilation limits the opportunities to generate highly optimized code in an ahead-of-time compiler. In the KESO project, a Java VM for statically-configured deeply embedded systems, we have previously used static application knowledge to create a tailored runtime environment. In this paper, we present and discuss how this static knowledge can further be exploited by our compiler in order to perform advanced optimizations that would otherwise not be achievable. We conducted a case study with the CDx real-time benchmark in which we examined the peculiarities and challenges that arise, and evaluated the effectiveness of both standard and system-model-specific compiler optimizations in the context of a static embedded application model. Our results show that incorporating the available a-priori knowledge in the compiler provides significant improvements to both footprint and runtime, and can additionally help the system integrator to identify consistency problems between the code and a higher-level system specification at an early development stage. © 2011 ACM.
UnivIS-Import:2015-04-16:Pub.2011.tech.IMMD.IMMD4.exploi
Keywords: Java; KESO; embedded systems; compiler optimizations

FAIL*: Towards a Versatile Fault-Injection Experiment Framework - Schirmeier, Horst; Hoffmann, Martin; Kapitza, Rüdiger; Lohmann, Daniel; Spinczyk, Olaf (Workshop on Dependability and Fault-Tolerance (VERFE), 2012)
Many years of research on dependable, fault-tolerant software systems yielded many tool implementations for vulnerability analysis and experimental validation of resilience measures. We identify two disjoint classes of fault-injection (FI) experiment tools in the field, and argue that both are plagued by inherent deficiencies, such as insufficient target state access, little or no means to switch to another target system, and non-reusable experiment code. In this article, we present a novel design approach for a FI infrastructure that aims at combining the strengths of both classes. Our Fail * experiment framework provides carefully-chosen abstractions simplifying both the implementation of different simulator/hardware target backends and the reuse of experiment code, while retaining the ability for deep targetstate access for specialized FI experiments. An exemplary report on first experiences with a prototype implementation based on existing x86 and ARM simulators demonstrates the tool's versatility. © 2012 Gesellschaft fuer Informatk.
UnivIS-Import:2015-04-16:Pub.2012.tech.IMMD.IMMD4.failto

Failure by Design: Influence of the RTOS Interface on Memory Fault Resilience - Hoffmann, Martin; Dietrich, Christian; Lohmann, Daniel (Proceedings of the 2nd GI Workshop on Software-Based Methods for Robust Embedded Systems (SOBRES '13), 2013)
UnivIS-Import:2015-04-16:Pub.2013.tech.IMMD.IMMD4.failur

Feature Models in Linux - From Symbols to Semantic - Rothberg, Valentin; Dintzner, Nicolas; Ziegler, Andreas; Lohmann, Daniel (Proceedings of the Tenth International Workshop on Variability Modelling of Software-intensive Systems, 2016)
Linux is a highly configurable operating-system kernel which has been widely studied in the context of software product lines over the past years. Understanding the challenges and perils of evolving and maintaining feature models of the size of Linux is crucial to provide the right tools for development today and to direct future research. Unfortunately, previous studies show contradictory observations when analyzing the evolution of Linux feature models. We explain how peculiarities of the feature models of the Linux kernel lead to those differing observations, and show how the results can be re-aligned. Moreover, our findings also demonstrate that symbolic differencing on feature models used by researchers so far has limited value, depending on the use case. We show how the limitations can be addressed by means of semantic differencing, and ironically invalidate the results we sought to re-align.<br
UnivIS-Import:2017-12-18:Pub.2016.tech.IMMD.IMMD4.featur
Keywords: CADOS; Linux

Fixing Configuration Inconsistencies Across File Type Boundaries - Elsner, Christoph; Lohmann, Daniel; Schröder-Preikschat, Wolfgang (Proceedings of the 37th EUROMICRO Conference on Software Engineering and Advanced Applications, 2011)
Creating a valid software configuration often involves multiple configuration file types, such as feature models, domain-specific languages, or C header files with preprocessor defines. Enforcing constraints across file types boundaries already at configuration is necessary to prevent inconsistencies, which otherwise are costly to discover and resolve later on. We present a pragmatic framework to specify and apply inconsistency-resolving fixes on configuration files of arbitrary types. The framework converts each configuration file to a model, checks it for consistency, applies fixes, and serializes it back again. We argue that conventionally programmed fixes and round-trip mechanisms (i.e., converters and serializers) are indispensable for practical applicability and can provide sufficient reliability when following usual development practices. We have developed round-trip mechanisms for seven different configuration file types and two fixing mechanisms. One fixing mechanism extends previous work by combining automatic detection of correct fix locations with a marker mechanism that reduces the number of locations. A tool-supported process for applying the fixes provides user guidance and integrates additional semantic validity checks on serialized configuration files of complex types (e.g., feature models). Evaluations reveal a speed up in inconsistency fixing and that the performance of the currently integrated round-tripping and fixing mechanisms is competitive. © 2011 IEEE.
UnivIS-Import:2015-04-16:Pub.2011.tech.IMMD.IMMD4.fixing
Keywords: Model Inconsistency Fixing; Software Configuration; Software Product Line

Functional and Non-Functional Properties in a Family of Embedded Operating Systems - Lohmann, Daniel; Schröder-Preikschat, Wolfgang; Spinczyk, Olaf (Proceedings of the 10th IEEE International Workshop on Object-oriented Real-time Dependable Systems, 2005)
The increasing complexity of embedded systems calls for software design and implementation techniques that support specialization without abandonment of reusability. This brings up a conflict as software specialized in supporting a very dedicated case usually cannot be (easily) reused for a different environment. Especially the "standard software" packets such as operating systems, e.g., are concerned with this problem. Particularly critical in this setting are non-functional properties that are ingredient parts of single components or crosscut in the extreme case the entire system software. These properties not only limit component reusability but also impair software maintenance in general. The paper deals with this issue in the scope of operating systems for the embedded-systems domain. It motivates using concepts such as family-based software design, feature modeling and aspect-oriented programming in order to come up with highly customizable and yet reusable system software solutions. © 2005 IEEE.
UnivIS-Import:2015-04-16:Pub.2005.tech.IMMD.IMMD4.functi

Generic Advice: On the Combination of AOP with Generative Programming in AspectC++ - Lohmann, Daniel; Spinczyk, Olaf; et al. (Proceedings of the 3rd International Conference on Generative Programming and Component Engineering (GPCE '04), 2004)
Besides object-orientation, generic types or templates and aspect-oriented programming (AOP) gain increasing popularity as they provide additional dimensions of decomposition. Most modern programming languages like Ada, Eiffel, and C++ already have built-in support for templates. For Java and C# similar extensions will be available in the near future. Even though promising, the combination of aspects with generic and generative programming is still a widely unexplored field. This paper presents our extensions to the AspectC++ language, an aspect-oriented C++ derivate. By these extensions aspects can now affect generic code and exploit the potentials of generic code and template metaprogramming in their implementations. This allows aspects to inject template metaprograms transparently into the component code. A case study demonstrates that this feature enables the development of highly expressive and efficient generic aspect implementations in AspectC++. A discussion whether these concepts are applicable in the context of other aspect-oriented language extensions like AspectJ rounds up our contribution. © Springer-Verlag 2004.
UnivIS-Import:2015-04-16:Pub.2004.tech.IMMD.IMMD4.generi

Globale Kontrollflussanalyse von eingebetteten Echtzeitsystemen - Dietrich, Christian; Hoffmann, Martin; Lohmann, Daniel (Betriebssysteme und Echtzeit, 2015)
UnivIS-Import:2016-02-10:Pub.2015.tech.IMMD.IMMD4.global

Global Optimization of Fixed-Priority Real-Time Systems by RTOS-Aware Control-Flow Analysis - Dietrich, Christian; Hoffmann, Martin; Lohmann, Daniel (ACM Transactions on Embedded Computing Systems, 2017)
Keywords: AUTOSAR; Global control-flow graph; OSEK; static analysis; static system tailoring; whole-system optimization

Gradual Software-Based Memory Protection - Stilkerich, Michael; Lohmann, Daniel; Schröder-Preikschat, Wolfgang (Proceedings of the Workshop on Isolation and Integration for Dependable Systems (IIDS '10), 2010)
UnivIS-Import:2015-04-16:Pub.2010.tech.IMMD.IMMD4.gradua
Keywords: KESO; Configurable Memory Protection; CiAO

Interrupt Synchronization in the CiAO Operating System - Experiences from Implementing Low-Level System Policies by AOP - Lohmann, Daniel; Spinczyk, Olaf; Schröder-Preikschat, Wolfgang; et al. (Proceedings of the 6th AOSD Workshop on Aspects, Components, and Patterns for Infrastructure Software (AOSD-ACP4IS '07), 2007)
Configurability is a major issue in the domain of embedded system software. Existing systems specifically lack good techniques to implement configurability of architectural OS concerns, such as the choice of isolation or synchronization policies to use. As such policies have a very cross-cutting character, aspects should provide good means to implement them in a configurable way. While our results show that this is in fact the case, 1) things could have been easier if additional language features were available, and, 2) additional means to influence the back-end code generation turned out to be very important. This paper presents our experiences in using AspectC++ to design and implement interrupt synchronization as a configurable property in the CiAO operating system. Copyright 2007 ACM.
UnivIS-Import:2015-04-16:Pub.2007.tech.IMMD.IMMD4.interr
Keywords: AOSD; AOP; AspectC++; CiAO; SPL; Software Product Lines; embedded; OS

Lean and Efficient System Software Product Lines: Where Aspects Beat Objects - Lohmann, Daniel; Spinczyk, Olaf; Schröder-Preikschat, Wolfgang (Transactions on Aspect-Oriented Software Development, 2006)
Software development in the domain of embedded and deeply embedded systems is dominated by cost pressure and extremely limited hardware resources. As a result, modern concepts for separation of concerns and software reuse are widely ignored, as developers worry about the thereby induced memory and performance overhead. Especially object-oriented programming (OOP) is still little in demand. For the development of highly configurable fine-grained system software product lines, however, separation of concerns (SoC) is a crucial property. As the overhead of object-orientation is not acceptable in this domain, we propose aspect-oriented programming (AOP) as an alternative. Compared to OOP, AOP makes it possible to reach similar or even better separation of concerns with significantly smaller memory footprints. In a case study for an embedded system product line the memory costs for SoC could be reduced from 148-236% to 2-10% by using AOP instead of OOP. © Springer-Verlag Berlin Heidelberg 2006.
UnivIS-Import:2015-04-20:Pub.2006.tech.IMMD.IMMD4.leanan
Keywords: AOSD; AOP; AspectC++; CiAO; SPL; Software Product Lines; embedded

Leviathan: SPL Support on Filesystem Level - Hofer, Wanja; Elsner, Christoph; Blendinger, Frank; Schröder-Preikschat, Wolfgang; Lohmann, Daniel (Proceedings of the 14th International Software Product Line Conference (SPLC-Poster 2010), 2010)
A lot of configurable software, especially in the domain of embedded and operating systems, is configured with a source preprocessor, mostly to avoid run-time overhead. However, developers then have to face a myriad of preprocessor directives and the corresponding complexity in the source code, even when they might only be working on the implementation of a single feature at a time. Thus, it has long been recognized that tool support is needed to cope with this '#ifdef hell'. Current approaches, which assist the software developer by providing preprocessed views, are all bound to a special integrated development environment. This eliminates them from being used both in industry settings (where domain-specific toolchains are often mandated) and in open-source projects (where diverse sets of editors and tools are being used). © 2010 Springer-Verlag Berlin Heidelberg.
UnivIS-Import:2015-04-16:Pub.2010.tech.IMMD.IMMD4.leviat
Keywords: Leviathan; Software Product Lines; Variability Implementation; Preprocessor-Based Configuration; Toolchain-Independent Variability Support; Filesystem Views; VAMOS

Lightweight, generative variant exploration for high-performance graphics applications - Selgrad, Kai; Lier, Alexander; Köferl, Franz; Stamminger, Marc; Lohmann, Daniel (ACM Bd. 51, Nr. 3, 2015)
Rendering performance is an everlasting goal of computer graphics and significant driver for advances in both, hardware architecture and algorithms. Thereby, it has become possible to apply advanced computer graphics technology even in low-cost embedded appliances, such as car instruments. Yet, to come up with an efficient implementation, developers have to put enormous efforts into hardware/problem-specific tailoring, fine-tuning, and domain exploration, which requires profound expert knowledge. If a good solution has been found, there is a high probability that it does not work as well with other architectures or even the next hardware generation. Generative DSL-based approaches could mitigate these efforts and provide for an efficient exploration of algorithmic variants and hardware-specific tuning ideas. However, in vertically organized industries, such as automotive, suppliers are reluctant to introduce these techniques as they fear loss of control, high introduction costs, and additional constraints imposed by the OEM with respect to software and tool-chain certification. Moreover, suppliers do not want to share their generic solutions with the OEM, but only concrete instances. To this end, we propose a light-weight and incremental approach for meta programming of graphics applications. Our approach relies on an existing formulation of C-like languages that is amenable to meta programming, which we extend to become a lightweight language to combine algorithmic features. Our method provides a concise notation for meta programs and generates easily sharable output in the appropriate C-style target language.

Linux Variability Anomalies: What Causes Them and How Do They Get Fixed? - Nadi, Sarah; Dietrich, Christian; Tartler, Reinhard; Holt, Richard C.; Lohmann, Daniel (Proceedings of the 10th Working Conference on Mining Software Repositories, 2013)
The Linux kernel is one of the largest configurable open source software systems implementing static variability. In Linux, variability is scattered over three different artifacts: source code files, KCONFIG files, and Makefiles. Previous work detected inconsistencies between these artifacts that led to anomalies in the intended variability of Linux. We call these variability anomalies. However, there has been no work done to analyze how these variability anomalies are introduced in the first place, and how they get fixed. In this work, we provide an analysis of the causes and fixes of variability anomalies in Linux. We first perform an exploratory case study that uses an existing set of patches which solve variability anomalies to identify patterns for their causes. The observations we make from this dataset allow us to develop four research questions which we then answer in a confirmatory case study on the scope of the whole Linux kernel. We show that variability anomalies exist for several releases in the kernel before they get fixed, and that contrary to our initial suspicion, typos in feature names do not commonly cause these anomalies. Our results show that variability anomalies are often introduced through incomplete patches that change KCONFIG definitions without properly propagating these changes to the rest of the system. Anomalies are then commonly fixed through changes to the code rather than to KCONFIG files. © 2013 IEEE.
UnivIS-Import:2015-04-16:Pub.2013.tech.IMMD.IMMD4.linuxv
Keywords: VAMOS; Configurability; System Software; Software Engineering; Maintenance

Memory Protection at Option - Stilkerich, Michael; Lohmann, Daniel; Schröder-Preikschat, Wolfgang (Proceedings of the 1st Workshop on Critical Automotive applications: Robustness & Safety, 2010)
There is hardware- and software-based memory protection that can improve the dependability of software systems. The two variants vary in the degree of protection and the amount and sites of overhead. The decision for a particular mechanism therefore highly depends on the application and deployment scenario. We propose a system suited for deeply embedded systems that allows to choose among no protection, software-based protection, hardware-based protection or a combination of the two without the need to change the application. In this paper, we present the current state of this work and support our claim that the best-suited memory protection type depends on the application by a preliminary evaluation. © 2010 ACM.
UnivIS-Import:2015-04-16:Pub.2010.tech.IMMD.IMMD4.memory
Keywords: KESO; Configurable Memory Protection; CiAO

Moving Towards Industrial Software Ecosystems: Are Our Software Architectures Fit for the Future? - Schultis, Klaus-Benedikt; Elsner, Christoph; Lohmann, Daniel (Proceedings of the 4th International Workshop on Product LinE Approaches in Software Engineering (PLEASE 2013), 2013)
The development of large-scale software productlines within large enterprises commonly involves various internal business units. Although within the same enterprise, each business unit has individual motivations and participation interests. For coordinating development, the emerging discipline of software ecosystems intents to explicitly discover and analyze the different players' interests, and manage them, often by means of a suitable software architecture. Already within a single enterprise, this discipline can be of high value. Instead of detailed managerial orders to coordinate internal interactions, an analysis of the players, their interests, and a suitable software architecture may slacken organizational structures and simplify processes. We have started to analyze the ecosystems of several Siemens internal product-lines in order to determine the different players and their interests, and to derive suitable software architectural requirements from this setting. This will enable us to compare these requirements to the actual architecture, for identifying reusable pain points and best practices of the existing system. However, there is no systematic (A) approach to model and analyze the collaboration among the participants from a technical perspective, as well as (B) to derive reusable architectural design-patterns and anti-patterns from such software ecosystems. By illustrating these problems using an existing software productline that moves towards a software ecosystem, we are looking for answers to the two questions above to evaluate whether our product-lines are fit for a future as internal software ecosystems. © 2013 IEEE.
UnivIS-Import:2015-04-16:Pub.2013.tech.IMMD.IMMD4.moving

Multidimensionales Trennen der Belange im Softwareentwurf - Lohmann, Daniel (Friedrich-Alexander-Universität Erlangen-Nürnberg, 2002)
UnivIS-Import:2016-07-26:Pub.2002.tech.IMMD.IMMD4.multid

Multi-Level Product Line Customization - Elsner, Christoph; Schwanninger, Christa; Schröder-Preikschat, Wolfgang; Lohmann, Daniel (New Trends in Software Methodologies, Tools and Techniques (SoMeT 2010), 2010)
Managing and developing a set of software products jointly using a software product line approach has achieved significant productivity and quality gain in the last decade. More and more, product lines now are becoming themselves entities that are sold and bought in the software supply chain. Customers build more specialized product lines on top of them or derive themselves the concrete products. As customers have different requirements, whole product lines now may vary depending on customer needs-they need to be customized. Current approaches going beyond the scope of one product line do not provide appropriate means for customization. They either are tailored to specific implementation techniques, only regard customization on few levels (e.g., only source code level), or imply a lot of manual effort for performing the customization. The PLiC Approach tackles this challenge by providing a generic, reusable reference architecture and methodology for implementing such customizable product lines. In the reference architecture, a product line consists of so-called product line components (PLiCs), which are flexibly recombinable slices of a formerly monolithic product line, thereby maintaining strict separation of concerns. The approach furthermore comprises a tool-supported methodology for recombination of PLiCs based on customer needs and thus minimizes manual intervention when customizing. We implemented the PLiC Approach for a complex model-driven product line, where it facilitates comprehensive customization on various levels in the models, the model transformation chain, and in the source code with reasonable effort. This gives evidence that our approach can be applied in various other contexts where the same or fewer customization levels need to be considered.
UnivIS-Import:2015-04-16:Pub.2010.tech.IMMD.IMMD4.multil
Keywords: Model-driven development; Software product line architecture; Software product line development

Multi Sloth: An Efficient Multi-Core RTOS using Hardware-Based Scheduling - Müller, Rainer; Danner, Daniel; Schröder-Preikschat, Wolfgang; Lohmann, Daniel (Proceedings of the 26th Euromicro Conference on Real-Time Systems (ECRTS '14), 2014)
Multi-core operating systems inherently face the problem of concurrent access to internal kernel state held in shared memory. Previous work on the Sloth real-time kernel proposed to offload the scheduling decisions to the interrupt hardware, thus removing the need for a software scheduler, no state has to be managed in software. While our existing design covers single-core platforms only, we now present Multi Sloth, a multi-core AUTOSAR OS implementation. In this paper, we show that our hardware-centric approach enables us to easily make the transition to multi-core platforms without the need for explicitly synchronizing kernel data. Even in the case of cross-core interactions, Multi Sloth keeps the unique Sloth properties of strict priority obedience and complete prevention of rate-monotonic priority inversions. AUTOSAR OS mandates only unordered spin locks, which do not guarantee predictable timing. We show the advantages of the Multi Sloth design by additionally providing a wait-free and efficient implementation of the priority-aware Multiprocessor Priority Ceiling Protocol (MPCP). On our reference platform, we achieve overheads as low as 1.1s for acquiring a globally shared resource using the MPCP and round-trip times of 1.4s for cross-core task activations.
UnivIS-Import:2015-04-16:Pub.2014.tech.IMMD.IMMD4.aneffi
Keywords: Sloth; Operating Systems; Embedded Systems; Real-Time Systems; Multi-Core; MPCP; AUTOSAR; Infineon TriCore; Infineon AURIX

OctoPOS: A Parallel Operating System for Invasive Computing - Oechslein, Benjamin; Schedel, Jens; Kleinöder, Jürgen; Bauer, Lars; Henkel, Jörg; Lohmann, Daniel; Schröder-Preikschat, Wolfgang (Proceedings of the International Workshop on Systems for Future Multi-Core Architectures (SFMA'11), 2011)
UnivIS-Import:2015-04-16:Pub.2011.tech.IMMD.IMMD4.octopo
Keywords: invasive computing; operating system; multi core; many core

On the Configuration of Non-Functional Properties in Operating System Product Lines - Lohmann, Daniel; Spinczyk, Olaf; Schröder-Preikschat, Wolfgang (Proceedings of the 4th AOSD Workshop on Aspects, Components and Patterns for Infrastructure Software (AOSD-ACP4IS '05), 2005)
UnivIS-Import:2015-04-16:Pub.2005.tech.IMMD.IMMD4.onthec
Keywords: AOP; AspectC++; Design; Operating Systems

On the Design and Development of a Customizable Embedded Operating System - Lohmann, Daniel; Schröder-Preikschat, Wolfgang; Spinczyk, Olaf (In Proceedings of the International Workshop on Dependable Embedded Systems, 2004)
UnivIS-Import:2015-04-16:Pub.2004.tech.IMMD.IMMD4.onthed
Keywords: Operating Systems; AOP; Non-functional Properties

On Typesafe Aspect Implementations in C++ - Lohmann, Daniel; Spinczyk, Olaf (Proceedings of Software Composition 2005, 2005)
Compared to other languages, the C++ language offers a less powerful runtime type system, but a very powerful static type system. In AspectC++, this is addressed by an extended join-point API that provides static type information at compile-time and type-safe access to join-point-specific context information. In this paper we show, how the use of static type information leads to the development highly generic, but type-safe aspects that fit well into the C++ language model. This is demonstrated by an example. © Springer-Verlag Berlin Heidelberg 2005.
UnivIS-Import:2015-04-16:Pub.2005.tech.IMMD.IMMD4.ontype
Keywords: AOP; C++; AspectC++; Generic Advice

Parallel, Hardware-Supported Interrupt Handling in an Event-Triggered Real-Time Operating System - Scheler, Fabian; Hofer, Wanja; Oechslein, Benjamin; Schröder-Preikschat, Wolfgang; Lohmann, Daniel; et al. (Proceedings of the 2009 International Conference on Compilers, Architecture and Synthesis for Embedded Systems (CASES 2009), 2009)
A common problem in event-triggered real-time systems is caused by low-priority tasks that are implemented as interrupt handlers interrupting and disturbing high-priority tasks that are implemented as threads. This problem is termed rate-monotonic priority inversion, and current software-based solutions are restricted in terms of more sophisticated scheduler features as demanded for instance by the AUTOSAR embedded-operating-system specification. We propose a hardware-based approach that makes use of a coprocessor to eliminate the potential priority inversion. By evaluating a prototypical implementation, we show that our approach both overcomes the restrictions of software approaches and introduces only a slight processing overhead in exchange for increased predictability. Copyright 2009 ACM.
UnivIS-Import:2015-04-16:Pub.2009.tech.IMMD.IMMD4.parall
Keywords: CiAO; Real-Time Systems; Priority-Driven; Rate-Monotonic Priority Inversion; TriCore; Interrupt Handling

Proceedings of the 7th Workshop on Aspects, Components, and Patterns for Infrastructure Software (AOSD-ACP4IS '08) - Lohmann, Daniel; et al. (ACM Press, 2008)
UnivIS-Import:2015-07-08:Pub.2008.tech.IMMD.IMMD4.procee

Product Derivation for Solution-Driven Product Line Engineering - Elsner, Christoph; Lohmann, Daniel; Schröder-Preikschat, Wolfgang (Proceedings of the First International Workshop on Feature-Oriented Software Development (FOSD 2009), 2009)
Solution-driven product line engineering is a project business where products are created for each customer individually. Although reuse of results from former projects is widely done, configuration and integration of the results currently is often a manual, time-consuming, and error-prone task and needs considerable knowledge about implementation details. In this paper, we elaborate and approach the challenges when giving automated support for product derivation (i.e., product configuration and generation) in a large-scale solution-driven product line context. Our PLiC approach resembles the fact that, in practice, the domain of a large product line is divided into sub-domains. A PLiC (product line component) packages all results (configuration, generation, and implementation assets) of a sub-domain and offers interfaces for configuration and generation. With our approach we tackle the challenges of using multiple and different types of configuration models and text files, give support for automated product generation, and integrate feature modeling to support application engineering as an extensive development task. Copyright 2009 ACM.
UnivIS-Import:2015-04-16:Pub.2009.tech.IMMD.IMMD4.produc
Keywords: Software Product Line; Feature Modelling

Providing security on demand using invasive computing - Drescher, Gabor; Erhardt, Christoph; Freiling, Felix; Götzfried, Johannes; Lohmann, Daniel; Maene, Pieter; Müller, Tilo; Verbauwhede, Ingrid; Weichslgartner, Andreas; Wildermann, Stefan (it - Information Technology, 2016)

Puma: An Aspect-Oriented Code Analysis and Manipulation Framework for C and C++ - Urban, Matthias; Lohmann, Daniel; Spinczyk, Olaf (Transactions on Aspect-Oriented Software Development (TAOSD), 2011)
Puma is a framework for the development of applications that analyze and optionally transform C or C++ source code. It supports all standard ISO C and C++ language features as well as many language extensions of the GNU Compiler Collection and Microsoft Visual C++. Aspects played an important role during the design and implementation of the framework. It is written in the AspectC++ language. By employing AOSD concepts we gained clean separation of concerns and, thereby, very good configurability and extensibility. All these -ilities are of vital importance for our project, because the available manpower for maintenance tasks is limited. This paper describes the tools, which we used for the development, the principles behind the design of Puma, and its implementation. Even though criticized during the last few years, our experiences show that aspect technology has clear benefits for the development of complex industrial applications. © 2011 Springer-Verlag Berlin Heidelberg.
UnivIS-Import:2015-04-20:Pub.2011.tech.IMMD.IMMD4.pumaan
Keywords: AOSD; Industrial Applications; OOP; AspectC++; Puma; Parser Framework; Compiler Construction; CiAO

PURE Embedded Operating Systems - CiAO - Lohmann, Daniel; Scheler, Fabian; Schröder-Preikschat, Wolfgang; Spinczyk, Olaf (Proceedings of the International Workshop on Operating System Platforms for Embedded Real-Time Applications, 2006)
UnivIS-Import:2015-04-16:Pub.2006.tech.IMMD.IMMD4.pureem

Resource-Aware Harris Corner Detection Based on Adaptive Pruning - Paul, Johny; Stechele, Walter; Kröhnert, Manfred; Asfour, Tamim; Oechslein, Benjamin; Erhardt, Christoph; Schedel, Jens; Lohmann, Daniel; Schröder-Preikschat, Wolfgang (Architecture of Computing Systems ARCS 2014, 2014)
Corner-detection techniques are being widely used in computer vision - for example in object recognition to find suitable candidate points for feature registration and matching. Most computer-vision applications have to operate on real-time video sequences, hence maintaining a consistent throughput and high accuracy are important constrains that ensure high-quality object recognition. A high throughput can be achieved by exploiting the inherent parallelism within the algorithm on massively parallel architectures like many-core processors. However, accelerating such algorithms on many-core CPUs offers several challenges as the achieved speedup depends on the instantaneous load on the processing elements. In this work, we present a new resource-aware Harris corner-detection algorithm for many-core processors. The novel algorithm can adapt itself to the dynamically varying load on a many-core processor to process the frame within a predefined time interval. The results show a 19% improvement in throughput and an 18% improvement in accuracy. © 2014 Springer International Publishing Switzerland.
UnivIS-Import:2015-04-16:Pub.2014.tech.IMMD.IMMD4.resour
Keywords: Harris corner detection; resource-aware programming; invasive computing; adaptive pruning

Resource-awareness on heterogeneous MPSoCs for image processing - Paul, Johny; Stechele, Walter; Oechslein, Benjamin; Erhardt, Christoph; Schedel, Jens; Lohmann, Daniel; Schröder-Preikschat, Wolfgang; Kröhnert, Manfred; Asfour, Tamim; Sousa, Éricles; Hannig, Frank; Lari, Vahid; et al. (Journal of Systems Architecture, 2015)
Multiprocessor system-on-chip (MPSoC) designs offer a lot of computational power assembled in a compact design. The computing power of MPSoCs can be further augmented by adding massively parallel processor arrays (MPPA) and specialized hardware with instruction-set extensions. On-chip MPPAs can be used to accelerate low-level image-processing algorithms with massive inherent parallelism. However, the presence of multiple processing elements (PEs) with different characteristics raises issues related to programming and application mapping, among others. The conventional approach used for programming heterogeneous MPSoCs results in a static mapping of various parts of the application to different PE types, based on the nature of the algorithm and the structure of the PEs. Yet, such a mapping scheme independent of the instantaneous load on the PEs may lead to under-utilization of some type of PEs while overloading others. In this work, we investigate the benefits of using a heterogeneous MPSoC for accelerating various stages within a real-world image-processing algorithm for object-recognition. A case study demonstrates that a resource-aware programming model called Invasive Computing helps to improve the throughput and worst observed latency of the application program, by dynamically mapping applications to different types of PEs available on a heterogeneous MPSo
Keywords: Computer vision; Heterogeneous processor; Image processing; Invasive Computing; MPSoC; Resource awareness

Revealing and Repairing Configuration Inconsistencies in Large-Scale System Software - Tartler, Reinhard; Sincero, Julio; Dietrich, Christian; Schröder-Preikschat, Wolfgang; Lohmann, Daniel (International Journal on Software Tools for Technology Transfer, 2012)
System software typically offers a large amount of compile-time options and variability. A good example is the Linux kernel, which provides more than 10,000 configurable features, growing rapidly. This allows users to tailor it with respect to a broad range of supported hardware architectures and application domains. From the maintenance point of view, compile-time configurability poses big challenges. The configuration model (the selectable features and their constraints as presented to the user) and the configurability that is actually implemented in the code have to be kept in sync, which, if performed manually, is a tedious and error-prone task. In the case of Linux, this has led to numerous defects in the source code, many of which are actual bugs. In order to ensure consistency between the variability expressed in the code and the configuration models, we propose an approach that extracts variability from both into propositional logic. This reveals inconsistencies between variability as expressed by the C Preprocessor (CPP) and an explicit variability model, which manifest themselves in seemingly conditional code that is in fact unconditional. We evaluate our approach with the Linux, for which our tool detects 1,766 configurability defects, which turned out as dead/superfluous source code and bugs. Our findings have led to numerous source-code improvements and bug fixes in Linux: 123 patches (49 merged) fix 364 defects, 147 of which have been confirmed by the corresponding Linux developers and 20 as fixing a previously unknown bug. © 2012 Springer-Verlag.
UnivIS-Import:2015-04-14:Pub.2012.tech.IMMD.IMMD4.reveal
Keywords: Algorithms; Design; Experimentation; Management; Languages; Configurability; Maintenance; Linux; Static Analysis; VAMOS; i4vamos

Revisiting Fault-Injection Experiment-Platform Architectures - Schirmeier, Horst; Hoffmann, Martin; Kapitza, Rüdiger; Lohmann, Daniel; Spinczyk, Olaf (Proceedings of the 17th IEEE Pacific Rim International Symposium on Dependable Computing (PRDC '11), 2011)
Many years of research on dependable, fault-tolerant software systems yielded a myriad of tool implementations for vulnerability analysis and experimental validation of resilience measures. Trace recording and fault injection are among the core functionalities these tools provide for hardware debuggers or system simulators, partially including some means to automate larger experiment campaigns. We argue that current fault-injection tools are too highly specialized for specific hardware devices or simulators, and are developed in poorly modularized implementations impeding evolution and maintenance. In this article, we present a novel design approach for a fault-injection infrastructure that allows experimenting researchers to switch simulator or hardware back ends with little effort, fosters experiment code reuse, and retains a high level of maintainability. © 2011 IEEE.
UnivIS-Import:2015-04-16:Pub.2011.tech.IMMD.IMMD4.revisi_0
Keywords: dependability; fault-injection; DanceOS

Safer Sloth: Efficient, Hardware-Tailored Memory Protection - Danner, Daniel; Müller, Rainer; Schröder-Preikschat, Wolfgang; Hofer, Wanja; Lohmann, Daniel (Proceedings of the 20th Real-Time and Embedded Technology and Applications Symposium (RTAS '14), 2014)
UnivIS-Import:2015-04-16:Pub.2014.tech.IMMD.IMMD4.safers
Keywords: Sloth; Operating Systems; Embedded Systems; Real-Time Systems; Interrupt Handling; Safety; Memory Protection; MPU; OSEK; AUTOSAR; Infineon TriCore

Sleepy Sloth: Threads as Interrupts as Threads - Hofer, Wanja; Lohmann, Daniel; Schröder-Preikschat, Wolfgang (Proceedings of the 32nd IEEE Real-Time Systems Symposium (RTSS 2011), 2011)
Event latency is considered to be one of the most important properties when selecting an event-driven real-time operating system. This is why in previous work on the SLOTH kernel, we suggested treating threads as ISRs-executing all application code in an interrupt context-and thereby reducing event latencies by scheduling and dispatching solely in hardware. However, to achieve these benefits, SLOTH does not support blocking threads or ISRs, but requires all control flows to have run-to-completion semantics. In this paper, we present SLEEPY SLOTH, an extension of SLOTH that provides a new generalized thread abstraction that overcomes this limitation, while still letting the hardware do all scheduling and dispatching. SLEEPY SLOTH abolishes the (artificial) distinction between threads and ISRs: Threads can be dispatched as efficiently as interrupt handlers and interrupt handlers can be scheduled as flexibly as threads. Our SLEEPY SLOTH implementation of the automotive OSEK OS standard provides much more flexibility to application developers while maintaining efficient execution of application control flows. SLEEPY SLOTH runs on commodity off-the-shelf hardware and outperforms a leading commercial OSEK implementation by a factor of 1.3 to 19. © 2011 IEEE.
UnivIS-Import:2015-04-16:Pub.2011.tech.IMMD.IMMD4.sleepy
Keywords: Sloth; Operating Systems; Embedded Systems; Real-Time Systems; Thread Management; Interrupt Handling; OSEK; Infineon TriCore; Priority-Driven Scheduling; Blocking Threads

Sloth: Let the Hardware Do the Work! - Hofer, Wanja; Lohmann, Daniel; Scheler, Fabian; Schröder-Preikschat, Wolfgang (Proceedings of the Work-in-Progress Session of the 22nd ACM Symposium on Operating Systems Principles (SOSP-WiP 2009), 2009)
UnivIS-Import:2015-04-16:Pub.2009.tech.IMMD.IMMD4.slothl
Keywords: Sloth; Threads; Interrupts; OSEK

Sloth on Time: Efficient Hardware-Based Scheduling for Time-Triggered RTOS - Hofer, Wanja; Danner, Daniel; Müller, Rainer; Scheler, Fabian; Schröder-Preikschat, Wolfgang; Lohmann, Daniel (Proceedings of the 33rd IEEE Real-Time Systems Symposium (RTSS 2012), 2012)
Traditional time-triggered operating systems are implemented by multiplexing a single hardware timer-the system timer-in software, having the kernel maintain dispatcher tables at run time. Our Sloth on Time approach proposes to make use of multiple timer cells as available on modern micro controller platforms to encapsulate dispatcher tables in the timer configuration, yielding low scheduling and dispatching latencies at run time. Sloth on Time instruments available timer cells in different roles to implement time-triggered task activation, deadline monitoring, and time synchronization, amongst others. By comparing the Sloth on Time kernel implementation to two commercial kernels, we show that our concept significantly reduces the overhead of time-triggered operating systems. The speed-ups in task dispatching that it achieves range up to a factor of 171x, and its dispatch latencies go as low as 14 clock cycles. Additionally, we demonstrate that Sloth on Time minimizes jitter and increases schedulability for its real-time applications, and that it avoids situations of priority inversion where traditional kernels fail by design. © 2012 IEEE.
UnivIS-Import:2015-04-16:Pub.2012.tech.IMMD.IMMD4.slotho
Keywords: Sloth; Operating Systems; Embedded Systems; Real-Time Systems; Interrupt Handling; Timers; Time-Triggered Scheduling; OSEK; AUTOSAR; Infineon TriCore

Sloth: Threads as Interrupts - Hofer, Wanja; Lohmann, Daniel; Scheler, Fabian; Schröder-Preikschat, Wolfgang (Proceedings of the 30th IEEE Real-Time Systems Symposium (RTSS 2009), 2009)
Traditional operating systems differentiate between threads, which are managed by the kernel scheduler, and interrupt handlers, which are scheduled by the hardware. This approach is not only asymmetrical in its nature, but also introduces problems relevant to real-time systems because low-priority interrupt handlers can interrupt high-priority threads. We propose to internally design all threads as interrupts, thereby simplifying the managed control-flow abstractions and letting the hardware interrupt subsystem do most of the scheduling work. The resulting design of our very light-weight SLOTH system is suitable for the implementation of a wide class of embedded real-time systems, which we describe with the example of the OSEK-OS specification. We show that the design conciseness has a positive impact on the system performance, its memory footprint, and its overall maintainability. © 2009 IEEE.
UnivIS-Import:2015-04-16:Pub.2009.tech.IMMD.IMMD4.slotht
Keywords: Sloth; Operating Systems; Embedded Systems; Real-Time Systems; Thread Management; Interrupt Handling; OSEK; Infineon TriCore; Priority-Driven Scheduling; CiAO; VAMOS

Tailorable System Software - Lohmann, Daniel (2014)
UnivIS-Import:2016-07-26:Pub.2014.tech.IMMD.IMMD4.tailor

The Aspect-Aware Design and Implementation of the CiAO Operating-System Family - Lohmann, Daniel; Spinczyk, Olaf; Hofer, Wanja; Schröder-Preikschat, Wolfgang (Lecture Notes in Computer Science, 2012)
CiAO is the first operating-system family that has been developed with AOP concepts from the very beginning. By its aspect-aware design and implementation, CiAO reaches excellent configurability, separation of concerns, and low footprints in the resulting systems that outperform leading commercial implementations. CiAO implements the automotive operating-system standard OSEK/AUTOSAR OS and provides configurability of all fundamental system properties by means of AOP. We describe the aspect-aware design approach and implementation idioms that led to this efficiency and flexibility. On the example of three larger case studies from CiAO, we demonstrate how AOP can be employed in this respect on different levels of complexity: From highly configurable, yet efficient low-level hardware abstractions over the implementation of central kernel policies up to the decomposition of a complete operating-system specification. Our results show that by a consequent application of the aspect-aware approach, AOP becomes a promising technology to reach configurability, separation of concerns, and runtime/memory efficiency on all levels of operating-system development. © Springer-Verlag Berlin Heidelberg 2012.
UnivIS-Import:2015-03-09:Pub.2012.tech.IMMD.IMMD4.aspect

The Aspect-Oriented Design of the PUMA C/C++ Framework - Lohmann, Daniel; Urban, Matthias; Lohmann, Daniel; Spinczyk, Olaf (AOSD '10: Proceedings of the 9th International Conference on Aspect-Oriented Software Development, 2010)
Puma is a framework for the development of applications that analyze and, optionally, transform C or C++ source code. It supports ISO C and C++ as well as many language extensions of the GNU Compiler Collection and Microsoft Visual C++. Aspects played an important role during the design and implementation of the framework. It is written in the AspectC++ language. By employing AOSD concepts, we gained a clean separation of concerns and, thereby, very good configurability and extensibility. All these - ilities are of vital importance for our project, because the available manpower for maintenance tasks is limited. This paper briefly describes the design principles behind Puma. Copyright 2010 ACM.
UnivIS-Import:2015-04-16:Pub.2010.tech.IMMD.IMMD4.theasp
Keywords: AOSD; Industrial Applications; OOP; AspectC++; Puma; Parser Framework; Compiler Construction; CiAO

The dataref versuchung: Saving Time through Better Internal Repeatability - Dietrich, Christian; Lohmann, Daniel (Operating Systems Review, 2015)
UnivIS-Import:2015-04-14:Pub.2015.tech.IMMD.IMMD4.thedat
Keywords: repeatability; reproducibility; experiment automatization

The Design and Implementation of AspectC++ - Spinczyk, Olaf; Lohmann, Daniel (Knowledge-Based Systems, 2007)
Aspect-Oriented Programming (AOP) is a programming paradigm that supports the modular implementation of crosscutting concerns. Thereby, AOP improves the maintainability, reusability, and configurability of software in general. Although already popular in the Java domain, AOP is still not commonly used in conjunction with C/C++. For a broad adoption of AOP by the software industry, it is crucial to provide solid language and tool support. However, research and tool development for C++ is known to be an extremely hard and tedious task, as the language is overwhelmed with interacting features and hard to analyze. Getting AOP into the C++ domain is not just technical challenge. It is also the question of integrating AOP concepts with the philosophy of the C++ language, which is very different from Java. This paper describes the design and development of the AspectC++ language and weaver, which brings fully-fledged AOP support into the C++ domain. © 2007 Elsevier B.V. All rights reserved.
UnivIS-Import:2015-03-09:Pub.2007.tech.IMMD.IMMD4.thedes
Keywords: AOP; AspectC++; C++; Programming languages

The design of application-tailorable operating system product lines - Lohmann, Daniel; Schröder-Preikschat, Wolfgang; Spinczyk, Olaf (Proceedings of the International Workshop on Construction and Analysis of Safe, Secure and Interoperable Smart Devices, 2006)
System software for deeply embedded devices has to cope with a broad variety of requirements and platforms, but especially with strict resource constraints. To compete against proprietary systems (and thereby to facilitate reuse), an operating system product line for deeply embedded systems has to be highly configurable and tailorable. It is therefore crucial that all selectable and configurable features can be encapsulated into fine-grained, exchangeable and reusable implementation components. However, the encapsulation of non-functional properties is often limited, due to their cross-cutting character. Fundamental system policies, like synchronization or activation points for the scheduler, have typically to be reflected in many points of the operating system component code. The presented approach is based on feature modeling, C++ class composition and overcomes the above mentioned problems by means of aspect-oriented programming (AOP). It facilitates a fine-grained encapsulation and configuration of even non-functional properties in system software. © Springer-Verlag Berlin Heidelberg 2006.
UnivIS-Import:2015-04-16:Pub.2006.tech.IMMD.IMMD4.thedes
Keywords: OS; Product Lines

The Gender Gap in Computer Science — A Bibliometric Analysis - Mattauch, Sandra; Lohmann, Katja; Hannig, Frank; Lohmann, Daniel; Teich, Jürgen (2018)

Toolchain-Independent Variant Management with the Leviathan Filesystem - Hofer, Wanja; Elsner, Christoph; Blendinger, Frank; Schröder-Preikschat, Wolfgang; Lohmann, Daniel (Proceedings of the 2nd Workshop on Feature-Oriented Software Development (FOSD 2010), 2010)
Preprocessor-configured software needs tool support for the developer to be able to cope with the complexity introduced by optional and alternative code blocks in the source. Current approaches, which assist the software developer by providing preprocessed views, are all bound to a special integrated development environment. This eliminates them from being used both in industry settings (where domain-specific toolchains are often mandated) and in open-source projects (where diverse sets of editors and tools are being used and freedom of tool choice is crucial for the project success). We therefore propose to tackle the problem at a lower level by implementing variant views at the filesystem level. By mounting one or more variants using our Leviathan filesystem, we enable the use of standard tools such as syntax validators, code metric analysis tools, or arbitrary editors to view or modify a variant. The major benefit (and challenge) is the support for automatically writing back to the configurable code base when editing one of the mounted variant views. © 2010 ACM.
UnivIS-Import:2015-04-16:Pub.2010.tech.IMMD.IMMD4.toolch
Keywords: Leviathan; Software Product Lines; Variability Implementation; Preprocessor-Based Configuration; Toolchain-Independent Variability Support; Filesystem Views; Käsebrot; VAMOS; CiAO

Towards Scalable Configuration Testing in Variable Software - Rothberg, Valentin; Dietrich, Christian; Ziegler, Andreas; Lohmann, Daniel (Proceedings of the 2016 International Conference on Generative Programming: Concepts and Experiences, 2016)
Testing a software product line such as Linux implies building the source with different configurations. Manual approaches to generate configurations that enable code of interest are doomed to fail due to the high amount of variation points distributed over the feature model, the build system and the source code. Research has proposed various approaches to generate covering configurations, but the algorithms show many drawbacks related to run-time, exhaustiveness and the amount of generated configurations. Hence, analyzing an entire Linux source can yield more than 30 thousand configurations and thereby exceeds the limited budget and resources for build testing. In this paper, we present an approach to fill the gap between a systematic generation of configurations and the necessity to fully build software in order to test it. By merging previously generated configurations, we reduce the number of necessary builds and enable global variability-aware testing. We reduce the problem of merging configurations to finding maximum cliques in a graph. We evaluate the approach on the Linux kernel, compare the results to common practices in industry, and show that our implementation scales even when facing graphs with millions of edge
UnivIS-Import:2017-12-18:Pub.2016.tech.IMMD.IMMD4.toward
Keywords: Configurability; Linux; Sampling; Software product lines; Software testing

Towards Separation of Concerns in Model Transformation Workflows - Elsner, Christoph; Lohmann, Daniel; Schröder-Preikschat, Wolfgang (Proceedings of the 12th Software Product Line Conference (SPLC 2008), Second Volume., 2008)
UnivIS-Import:2015-04-16:Pub.2008.tech.IMMD.IMMD4.toward
Keywords: Aspect Orientation; Model-Driven Software Development; Software Product Lines; Model Transformation Workflows

Understanding Linux Feature Distribution - Dietrich, Christian; Tartler, Reinhard; Schröder-Preikschat, Wolfgang; Lohmann, Daniel (Proceedings of the 2nd AOSD Workshop on Modularity in Systems Software (AOSD-MISS 12), 2012)
Managing variability is hard. This applies both to feature modeling itself as well as the maintenance of the corresponding feature implementations which poses additional challenges. Especially in embedded systems and system software that are developed using the tools CPP, GCC and MAKE, feature realizations happen on different levels of abstractions, concepts and implementation languages. This particularly applies to Linux, which exposes over 11,000 features on over two dozen different architectures. While features are modeled centrally with the KCONFIG tool, feature-code is realized in various source-files and managed by the KBUILD build-system. In this article, we identify and relate levels of variability on which feature-code is implemented. The quantification of variability on the different levels in Linux disproves two common beliefs about the amount of implemented variability. © 2012 ACM.
UnivIS-Import:2015-04-16:Pub.2012.tech.IMMD.IMMD4.unders
Keywords: Algorithms; Design; Experimentation; Management; Languages; Configurability; Maintenance; Linux; Static Analysis; Variability; VAMOS

Using AOP to Develop Architecture-Neutral Operating System Components - Spinczyk, Olaf; Lohmann, Daniel (Proceedings of the 11th ACM SIGOPS European Workshop (SIGOPS-EW '04), 2004)
UnivIS-Import:2015-04-16:Pub.2004.tech.IMMD.IMMD4.usinga
Keywords: AOP; AspectC++; Operating Systems; Architecture