Verena Klös

Adaptive Knowledge Bases in Self-Adaptive System Design

Self-adaptive systems allow for flexible solutions in changing environments. Usually, a fixed set of predefined rules is used to define the adaptation possibilities of a system. The main problem of such systems is to cope with environment behaviours that were not anticipated at design-time. In this case, no adaptation rule might be applicable or adaptations might not have the expected effect. In this paper, we propose an extended architecture of IBMs MAPE-K loop to cope with this problem. We impose a structure on the knowledge base consisting of an abstract system and environment model, a global goal model, and a set of (current) adaptation rules. Furthermore, we introduce an evaluation component that deletes failed adaptation rules, as well as a learning component that uses run-time models to autonomously generate new rules if the current ones are not applicable. With our approach, not only functional components can dynamically be adapted but also the adaptation logic itself.

Modular Design and Verification of Distributed Adaptive Real-Time Systems Based on Refinements and Abstractions

A promising way to cope with complexity in verifying large systems is to perform modular verification where components are verified separately. However, in the context of adaptive systems, it is difficult to apply this principle because adaptation behaviour and functional behaviour are often intertwined. In this paper, we present and apply a design pattern for distributed adaptive real-time systems using the process calculus Timed CSP. Our pattern explicitly differentiates between functional data and adaptive control data and thereby allows for a strict separation of adaptation and functional components. We enable the modular verification of functional and adaptation behaviour, respectively, based on the notion of process refinement in Timed CSP. The verification of refinements is automated using industrial-strength proof tools. As the notion of refinement can also be used to justify abstractions, we furthermore enable abstractionbased verification, where a detailed system is abstracted to facilitate more efficient verification efforts. This is especially important in the industrial development of adaptive systems using languages like SystemC where a designer not necessarily applies fine-grained refinements, but implements larger parts of the functional and adaptation logic possibly at the same time. Therefore, we discuss how common refinements and abstractions from the context of Timed CSP can be used as a formal basis for refinements and abstractions in SystemC.

Runtime Management and Quantitative Evaluation of Changing System Goals

A key challenge in cyber-physical systems is their highly dynamic nature including changing system goals. Therefore, these systems have to autonomously manage their system goals and continuously evaluate their achievement at run-time. However, with the increasing complexity of system goals including, e.g., priorities, dependencies, and conflicts among goals, abinary or qualitative judgement of achievement of goals is not sufficient any more. Instead, it is necessary to quantify the degree to which the goals are fulfilled in order to balance the cost-benefit ratio at run-time. In this paper, we present a hierarchical and modular goal model that allows for capturing complex relations between subgoals, e.g., dependencies and conflicts. We provide an algorithm that efficiently evaluates gradual achievement of goalsat run-time. Due to the modular structure of our model and our evaluation, goals can easily be added, removed, and changed at run-time. With our approach, we a) ease the design of goal-aware autonomous systems by providing an explicit structure that emphasises relations between subgoals, b) provide an automatic quantification of the satisfaction of complex system goals that can be used to, e.g., evaluate autonomous decisions at runtime, andc) enable runtime management of changing system goals.

Formal Models for Analysing Dynamic Adaptation Behaviour in Real-Time Systems

Self-adaptive systems are able to autonomously adapt themselves to react to dynamic changes in their environment. They, thereby, provide suitable mechanisms to deal with uncertain environment settings, as is required in modern reactive systems, such as cyber-physical systems. However, design and analysis of adaptation logic is complex and error-prone. Thus, early design-time analysis of the adaptation logic is necessary, especially in safety-critical applications. In this paper, we cope with the problem of comprehensively analysing time-dependent self-adaptive systems. We consider rule-based adaptation as a generic mechanism to describe adaptation logic. We automatically extract formal timed models of the functional components from a SystemC system-level implementation. This ensures that analysis results on the models correspond to the actual running system. To analyse the adaptation behaviours, we embed the extracted functional models in a formal, generic, and abstract MAPE-K loop modelled with timed automata. We classify important adaptation properties and show how they can be generally verified on the resulting models together with an abstract model of the environment, which we assume to be given. To evaluate our approach, we analyse the widely used web-based information system Znn.com.

Comprehensible and dependable self-learning self-adaptive systems

Abstract Self-adaptivity enables flexible solutions in dynamically changing environments. However, due to the increasing complexity, uncertainty, and topology changes in cyber-physical systems (CPS), static adaptation mechanisms are insufficient as they do not always achieve appropriate effects. Furthermore, CPS are used in safety-critical domains, which requires them and their autonomous adaptations to be dependable. To overcome these problems, we extend the MAPE-K feedback loop architecture by imposing a structure and requirements on the knowledge base and by introducing a meta-adaptation layer. This enables us to continuously evaluate the accuracy of previous adaptations, learn new adaptation rules based on executable run-time models, and verify the correctness of the adaptation logic in the current system context. We demonstrate the effectiveness of our approach using a temperature control system. With our framework, we enable the design of comprehensible and dependable dynamically evolving adaptation logics.

Runtime management and quantitative evaluation of changing system goals in complex autonomous systems

Abstract A key challenge in cyber-physical systems (CPS) design is their highly dynamic nature including runtime changes of system goals. Additional safety regulations or changed priorities may apply, e.g. (temporarily) focusing on safety goals after some incident occurred. Goal-aware CPS continuously evaluate goal achievement and autonomously perform adaptations for re-achievement at runtime. For complex system goals capturing dependencies, priorities, and conflicts, efficient goal evaluation techniques are required. To enable a fine-grained balancing of the cost-benefit ratio of autonomous decisions at runtime, a qualitative evaluation of goals is not sufficient. We provide an algorithm that efficiently calculates the quantitative “distance” between a system state and the system goals. We organise various goal types, their parent-children-relationships, context-dependent importances, and dependency relations in a hierarchical goal model. Due to its modular structure, goals can easily be added, removed, and changed at runtime. We illustrate our approach with an exemplary autonomous air drone delivery system and discuss it based on illustrative example scenarios. We argue that our approach enables a) the design of complex context-dependent quantitative goal models for autonomous goal-aware systems, b) the measurement of the impact of autonomous decisions at runtime, and c) the efficient runtime management of changing system goals.

A multi-robot search using LEGO mindstorms: an embedded software design project

Embedded software is concurrent, real-time dependent, typically networked, must meet strict resource and high quality requirements, and often runs on cheap hardware. Altogether, this makes the education of embedded software designers a difficult challenge. In this paper, we present an embedded software design project, where students have to develop a multi-robot search using Lego mindstorms. The main idea is to confront the students with all the spites that are typically present in embedded systems, while at the same time giving them an algorithmically non-trivial problem to solve. To this end, we let the students use a bio-inspired search algorithm (particle-swarm optimization) to detect survivors (led by cries for help) in an unknown disaster zone using a number of Lego Mindstorm robots. We have executed this project simultaneously at the University of Potsdam and TU Berlin and discuss results and evaluations. We think that this project is very well suited for the education of embedded software engineers.

Automatic Analysis and Abstraction for Model Checking HW/SW Co-Designs modeled in SystemC

Embedded systems usually consist of deeply integrated hardware and software components. As a consequence, modular verification is not easily possible. One important step towards modular verification of integrated HW/SW systems is to automatically compute abstractions of components that influence the overall system behavior but are not relevant for a given property. In this paper, we present an automatic abstraction technique for HW/SW co-designs modeled in SystemC. The key idea is to use a variant of classical abstract interpretation that is tailored for the specific semantics of SystemC. Our main contributions are the following: First, we present an analysis that determines data-dependencies between variables and equivalent data values with respect to conditional branches while taking the timing behavior and scheduling policies of SystemC into consideration. Second, we use the results for slicing and variable abstraction to significantly reduce the semantic state space of a given SystemC design and again produce a valid abstract design. Our abstraction technique makes it possible to automatically verify properties for comparatively large designs with the UPPAAL model checker, which cannot be handled without our approach. We demonstrate this with two case studies from the SystemC reference implementation.