Dr.-Ing.

Kuhn, Thomas

Filters

8
10 1
Reset filters

Settings
Now showing 1 - 10 of 11
  • Publication
    FERA: A Framework for Critical Assessment of Execution Monitoring Based Approaches for Finding Concurrency Bugs
    ( 2020)
    Jahic, Jasmin
    ;
    Bauer, Thomas
    ;
    Kuhn, Thomas
    ;
    Wehn, Norbert
    ;
    Antonino, Pablo Oliveira
    The software community has recognized the importance of concurrent multithreaded software and the criticality of concurrency bugs. However, it has still not fully acknowledged the complexity of the process for finding these bugs. When based on execution monitoring, the process includes tracing of the software execution, specification of concurrency bug models, modeling of synchronization mechanism patterns, and several other process steps and components. Existing approaches, however, focus only on the parts of the process for finding concurrency bugs (PFCB) and fail to notice their inter-dependencies, which affect the analysis outcome. Without a proper understanding of these inter-dependencies, the advances in this research area remain partially incremental and limited to specific use cases. In order to better understand this problem, we provide a model of a generic process for finding concurrency bugs (PFCB) and a framework for the critical assessment of execution-monitoring-based approaches for finding concurrency bugs (FERA). Our framework captures the inter-dependencies between the individual PFCB steps and establishes the relation between these inter-dependencies and the final outcome of the monitoring. The FERA framework is suitable for assessing the suitability of approaches for finding concurrency bugs, for specific software systems (e.g., with specific synchronization properties). With this paper, we demonstrate that finding concurrency bugs is not an isolated action consisting of applying an algorithm to an execution trace, but rather a continuous engineering process.
  • Publication
    Towards virtual validation of distributed functions
    ( 2019)
    Baumann, Peter
    ;
    Samlaus, Roland
    ;
    Mikelsons, Lars
    ;
    Kuhn, Thomas
    ;
    Jahic, Jasmin
    Continuous development of software functions using software-in-the-loop (SiL) simulations up to their virtual validation or virtual release are key enablers for new technologies of autonomous and connected mobility. Due to the complexity of autonomous and predictive driving functions, the unit-under-test is often not encapsulated in one Electronic Control Unit (ECU), but distributed over multiple ECUs. Thus, a cross-domain vehicle simulation framework capable of simulating numerous connected virtual ECUs (vECUs) together with the corresponding physical models (e.g. vehicle dynamics) is required. In this contribution, this is realized by extending an existing MiL co-simulation environment consisting of a middleware-based coupling of proprietary tools with a toolchain for the generation of vECUs as Functional Mock-up Units (FMU) and a modular virtual bus implementation. This framework is tested by showing a smooth transition from model-in-the-loop to SiL simulation of a function distributed over two vECUs communicating via a virtual Controller Area Network bus.
  • Publication
    Towards Runtime Monitoring for Malicious Behaviors Detection in Smart Ecosystems
    ( 2019)
    Cioroaica, Emilia
    ;
    Giandomenico, Felicita Di
    ;
    Kuhn, Thomas
    ;
    Lonetti, Francesca
    ;
    Marchetti, Eda
    ;
    Jahic, Jasmin
    ;
    Schnicke, Frank
    Smart Ecosystem reflects in the control decisions of entities of different nature, especially of its software components. Particularly, the malicious behavior requires a more accurate attention. This paper discusses the challenges related to the evaluation of software smart agents and proposes a first solution leveraging the monitoring facilities for a) assuring conformity between the software agent and its digital twin in a real-time evaluation and b) validating decisions of the digital twins during runtime in a predictive simulation.
  • Publication
    Detection of conflicts and inconsistencies between architecture solutions
    ( 2019)
    Kallweit, Benno
    ;
    Antonino, Pablo Oliveira
    ;
    Jahic, Jasmin
    ;
    Kuhn, Thomas
    ;
    Liggesmeyer, Peter
    This paper presents a semi-automated approach for detecting conflicts and inconsistencies between architecture solutions. Inconsistencies occur when two or more architecture solutions rely on each other but cannot be satisfied, and conflicts when there are contradictions within one single decision specification, such as contradictory variable range and value. The proposed approach comprises a set of checks followed by transformations of architecture solutions specified according to a domain-specific-language, also created in the context of this work, into state machines. The semi-automated approach is implemented as a plugin for the MagicDraw modeling tool, and was evaluated in a project from the automotive domain.
  • Publication
    Rapid Identification of Shared Memory in Multithreaded Embedded Systems with Static Scheduling
    ( 2019)
    Jahic, Jasmin
    ;
    Kumar, Varun
    ;
    Jung, Matthias
    ;
    Wirrer, Gerhard
    ;
    Wehn, Norbert
    ;
    Kuhn, Thomas
    Due to the non-deterministic order of interactions between concurrent threads, testing of concurrent software is a challenge. In order to cope with this challenge, researchers have proposed analysis approaches in which the dynamic-based algorithms (e.g., Happens-before, Lockset) are an irreplaceable part. One of the biggest challenges of such algorithms, and a pre-condition to the analysis, is identification of memory locations that are shared between threads. This task is a significant contributor to the overhead of the analysis algorithms. In embedded systems that use static scheduling, scheduling is the implicit synchronization mechanism. In this paper, we suggest taking an advantage of static scheduling scheme to speed up the process of finding variables shared between threads, and with it, the identification of concurrency bugs. We demonstrate this concept by introducing modification to the Lockset algorithm and its internal structure. We show that considering static scheduling reduces the execution analysis time of the Lockset algorithm.
  • Publication
    BOSMI: A framework for non-intrusive monitoring and testing of embedded multithreaded software on the logical level
    ( 2018)
    Jahic, Jasmin
    ;
    Kuhn, Thomas
    ;
    Jung, Matthias
    ;
    Wehn, Norbert
    Traditional software testing methods are inefficient in cases where data inputs alone do not determine the outcome of a program's execution. In order to verify such software, testing is often complemented by analysis of the execution trace. For monitoring the execution trace, most approaches today insert additional instructions at the binary level, making the monitoring intrusive. Binary instrumentation operate on a low level, making it difficult to properly modify a program's states and to quantify its code coverage. In this paper, we present a framework for testing complex embedded multithreaded software on the logical level. Testing software on this level avoids dependency on concrete compilers and relates the execution to the source code, thus enabling coverage. Our non-intrusive execution monitoring and control is implemented using the LLVM interpreter compiler infrastructure. Instead of forcing thread interleaving, we suggest simulating interleaving effects through non-intrusive changes of shared variables. This makes it possible to test a single thread without executing the full software stack, which is especially useful in situations where the full software stack is not available (e.g., pre-integration testing). We complement existing approaches with new features such as dynamic configuration of monitoring and execution rollback to the checkpoints. Our approach introduces acceptable overhead without any complex setup.
  • Publication
    A Framework for Non-intrusive Trace-driven Simulation of Manycore Architectures with Dynamic Tracing Configuration
    ( 2018)
    Jahic, Jasmin
    ;
    Jung, Matthias
    ;
    Kuhn, Thomas
    ;
    Kestel, Claus
    ;
    Wehn, Norbert
    Traditional software testing methods are inefficient for multithreaded software. In order to verify such software, testing is often complemented by analysis of the execution trace. To monitor the execution trace, most approaches today use binary instrumentation or rigid frameworks based on system simulators. Most existing approaches are intrusive, as they tend to change the monitored software. Furthermore, their monitoring configuration is static, resulting in huge, often non-relevant, traces. In this paper, we present a light, non-intrusive execution monitoring and control approach, implemented using the gem5 system simulator. We complement existing approaches with dynamic configuration of the monitoring, making it possible to dynamically change the monitoring focus to the parts of the software that are of interest. This configuration results in reduced execution trace size. Our approach does not change the software under test, but rather the virtual platform that executes the software.
  • Publication
    Supervised testing of concurrent software in embedded systems
    ( 2017)
    Jahic, Jasmin
    ;
    Kuhn, Thomas
    ;
    Jung, Matthias
    ;
    Wehn, Norbert
    The migration of sequential embedded software to multicore processors is a challenging task. Parallelization of software introduces concurrency bugs (e.g. data races), which only conditionally appear during testing because they strongly depend on the timing of the execution. Therefore, traditional testing approaches cannot efficiently test concurrent software. More appropriate are analysis approaches that prove the absence of software faults. Current approaches often produce false positives as they fail to consider all relevant synchronization sources. In this paper, we complement current analysis techniques by considering a scheduling scheme as a synchronization mechanism. We narrow the analysis by analyzing only relevant variants in execution timing that might produce concurrency bugs. Therefore, we eliminate a family of false positives caused by ignoring the scheduling synchronization. Engineers can optimize this scheduling scheme to satisfy different requirements. Our approach uses virtual prototyping to enable design space exploration of systems with complex scheduling schemes by investigating the influence of the scheduling scheme on the synchronization of concurrent software.
  • Publication
    Accelerated simulated fault injection testing
    ( 2017)
    Cioroaica, Emilia
    ;
    Jahic, Jasmin
    ;
    Kuhn, Thomas
    ;
    Peper, Christian
    ;
    Uecker, Denis
    ;
    Dropmann, Christoph
    ;
    Munk, Peter
    ;
    Rakshith, Amarnath
    ;
    Thaden, Eike
    Fault injection testing approaches assess the reliability of execution environments for critical software. They support the early testing of safety concepts that mitigate the impact of hardware failures on software behavior. The growing use of platform software for embedded systems raises the need to verify safety concepts that execute on top of operating systems and middleware platforms. Current fault injection techniques consider the resulting software stack as one black box and attempt to test the reaction of all components in the context of faults. This leads to very high software complexity and consequently requires a very high number of fault injection experiments. Testing the software components, such as control functions, operating systems, and middleware, individually would lead to a significant reduction of the number of experiments required. In this paper, we illustrate our novel approach for fault injection testing, which considers the components of a software stack, enables re-use of previously collected evidences, allows focusing testing on highly critical parts of the control software, and significantly lowers the number of experiments required.
  • Publication
    Analysis of functional software dependencies through supervised execution
    ( 2014)
    Jahic, Jasmin
    ;
    Kuhn, Thomas
    Knowing functional interferences between system components is imperative when developing safety critical systems. In this paper, we describe an approach for reliably detecting functional dependencies of software components to other system entities through supervised execution of software using the simulation techniques. Supervised execution enables monitoring of the internal state of system components and therefore permits the rapid detection of component behavior changes across simulation contexts. Credibility of results is achieved through collected test coverage metrics.