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 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

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

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

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

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

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=

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

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

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

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

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

Team Up: Cooperative Memory Management in Embedded Systems - Stilkerich, Isabella; Taffner, Philip; Erhardt, Christoph; Dietrich, Christian; Wawersich, Christian; Stilkerich, Michael (Proceedings of the 2014 Conference on Compilers, Architectures and Synthesis for Embedded Systems - CASES'14, 2014)
The use of a managed, type-safe languages such as Java in realtime and embedded systems can offer productivity and, in particular, safety and dependability benefits over the dominating unsafe languages at reasonable costs. A JVM that has dynamic memory-management needs to provide an implicit memory-management strategy, that is, for example, a garbage collector (GC) or stack allocation provided by the escape analysis of the JVM's compiler: Explicit management of dynamically allocated memory (i.e., by use of functions such as C's malloc() and free()) is vulnerable to programming errors such as neglected or false memory release operations causing memory leaks or dangling pointers. Such operations have the potential to break the soundness of the type system and are therefore usually not available for strongly typed languages. Type-safe languages in combination with static analyses - which respect hardware as well as system-specific information - can efficiently be employed to provide a runtime system including memory management (MM) that is specifically suited to an embedded application on a particular hardware device. In the context of this paper, we present novel memory-management strategy we implemented in our KESO JVM. It is a latency-aware garbage-collection algorithm called LAGC. Also, we introduce the static analyses that can assist LAGC. The application developers have to ensure that there is enough time for the GCs to run. Hardware characteristics such as soft-error proneness of the hardware or the memory layout can also be taken into consideration as demanded by the system configuration. This is achieved by integrating the GCs in the design process of the whole system just as any other user application, which is the reason why this approach is called cooperative memory management. The suggested strategies require reasonably low overhead. Copyright 2014 ACM.
UnivIS-Import:2015-04-16:Pub.2014.tech.IMMD.IMMD4.teamup
Keywords: KESO; AORTA; invasic; Java; RTSJ; Embedded Systems; Real-Time Systems; Reliability

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

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

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