Stefan Henkler

Modeling and verifying dynamic communication structures based on graph transformations

Current and especially future software systems increasingly exhibit so-called self-* properties (e.g., self-healing or self-optimization). In essence, this means that software in such systems needs to be reconfigurable at run-time to remedy a detected failure or to adjust to a changing environment. Reconfiguration includes adding or deleting (software) components as well as adding or deleting component interaction. As a consequence, the state space of self-* systems becomes so complex, that current verification approaches like model checking or theorem proving usually do not scale. Our approach addresses this problem by firstly defining a system architecture with clearly defined components and their interfaces (ports including the definition of signatures of all events and methods which the port may receive and the component may execute) and so-called coordination patterns. These coordination patterns specify communication protocols based on the definition of the ports only for those component interactions which are defined in the (static) architecture specification by a corresponding connection. Secondly, the reconfiguration of architectures is precisely defined by giving a formal definition of all change operations, e.g., adding or deleting components and component connections. By exploiting this formal definition, it becomes provable that an architecture includes only component connections which correspond to the defined coordination patterns. Then, the verification of safety and liveness properties has to be carried out only for each individual coordination pattern rather than for the system as a whole.

A survey of approaches for the visual model-driven development of next generation software-intensive systems

Software-intensive systems of the future are expected to be highly distributed and to exhibit adaptive and anticipatory behavior when operating in highly dynamic environments and interfacing with the physical world. Therefore, visual modeling techniques to address these software-intensive systems require a mix of models from a multitude of disciplines such as software engineering, control engineering, and business process engineering. As in this concert of techniques software provides the most flexible element, the integration of these different views can be expected to happen in the software. The software thus includes complex information processing capabilities as well as hard real-time coordination between distributed technical systems and computers. In this article, we identify a number of general requirements for the visual model-driven specification of next generation software-intensive systems. As business process engineering and software engineering are well integrated areas and in order to keep this survey focused, we restrict our attention here to approaches for the visual model-driven development of adaptable software-intensive systems where the integration of software engineering with control engineering concepts and safety issues are important. In this survey, we identify requirements and use them to classify and characterize a number of approaches that can be employed for the development of the considered class of software-intensive systems.

Towards a Rigorous Modeling Formalism for Systems of Systems

The scope of this paper is collaborative, distributed safety critical systems which build up a larger scale system of systems (SoS). Systems participating in an SoS follow both global as well as individual goals, which may be contradicting. Both the global and local goals of the overall SoS may change over time. Hence, self-adaptive ness, i.e., reconfiguration of the SoS as a reaction on changes within its context is a major characteristic of this systems. The aim of this paper is to describe first steps towards a modeling formalism for SoS in a safety critical context. The challenge is to address on the one hand the required flexibility to adapt the system during run-time and on the other hand to guarantee that the system reacts still in a safe manner. To address these challenges, we propose an approach which guarantees that the system still reacts in a safe manner while adaption to uncertainty including context changes. This adaption has to be assumed as unsafe during design time. The key for having success is to define the interaction between the systems as well as its goals as basic elements of the design. Based on our former work, we propose a well-defined modeling approach for the interaction based on components as basic structural elements, the contract paradigm for the design of the interaction, and graph transformations, which addresses the adaptivity of system of systems. The component model is additionally explicitly enriched by goals, which supports so called evaluation functions to determine the level of target achievement.

Modeling collaborations with dynamic structural adaptation in mechatronic UML

The next generation of advanced mechatronic systems is expected to behave more intelligently than todays systems. These systems are expected to enhance their functionality and improve their performance by building communities of autonomous agents which exploit local and global networking. Such mechatronic systems will therefore include complex coordination protocols which require execution in real-time and reconfiguration of the locally employed control algorithms at runtime to adjust their behavior to the changing system goals leading to self-adaptation. In this paper we will present an extension of the MECHATRONIC UML approach which will enable us to model collaborations between components which include structural adaptation and multi-ports. Besides the modeling of complex collaborations and the rules to join and leave these collaborations via ports and multi-ports, we propose to employ hierarchical state machines with a dynamic number of submachines to model the behavior of the multi-ports. For the collaborations this involves the related protocols, while for the components we have to refine this behavior to ensure a proper synchronization with other parts of the component behavior.

Fujaba4eclipse real-time tool suite

The Fujaba Real-Time Tool Suite supports modeling and verification of software in mechatronic or embedded systems. It also addresses the specification of advanced systems which reconfigure part of their structure and behavior at runtime. The Fujaba Real-Time Tool Suite requires a rigorous development process concerning the use of the different (partially refined) UML diagrams. All diagrams have a formally and well-defined semantics which allow to check models for given safety properties. Further, the tool suite provides a tight integration with software tools used by control engineers like CaMEL-View and Matlab to enable the simulation of production code of a complete system.

Architecture-driven platform independent deterministic replay for distributed hard real-time systems

Distributed hard real-time systems have become a major component of many advanced technical products. Means to ensure their proper quality are thus of paramount importance. To ensure high quality software, besides preventive means also cost-effective techniques for defect removal are important. The later activity in practice includes testing in order to detect failures, subsequent diagnosis in order to pin down the observed failure to a defect, and finally the proper removal of the defect. In this chain of activities, finding the cause of a failure is often a rather difficult and long-winded undertaking. In the domain of embedded real-time systems the problem is even harder than in a standard environment because of the real-time behavior and hardware heterogeneity (development vs. target platform). Both renders the deterministic replay of faulty behavior a hard problem which today can only be addressed when a substantial amount of additional monitoring hardware is added to the system. The paper proposes to minimize the required additional hardware using an architecture-driven approach which exploits the high-level information available at the architectural level in order to achieve platform independent deterministic replay for distributed hard real-time systems at relative low cost.

Introduction to the SPES Modeling Framework

The aim of model-based development is to use models as main development artifacts in all phases of the development process.

Legacy component integration by the Fujaba real-time tool suite

We present a Tool Suite which supports the (re-)construction of a behavioral model of a legacy component based on a learning approach by exploiting knowledge of known models of the existing component environment. This in turn enables to check whether the legacy component can be integrated correctly into its environment.

Synthesis of timed behavior from scenarios in the Fujaba Real-Time Tool Suite

Based on a well-defined component architecture the tool supports the synthesis of so-called real-time statecharts from timed sequence diagrams. The two step synthesis process addresses the existing scalability problems by a proper decomposition and allows the user to define particular restrictions on the resulting statecharts.

Tool Support for Developing Advanced Mechatronic Systems: Integrating the Fujaba Real-Time Tool Suite with CAMeL-View

The next generation of advanced mechatronic systems is expected to use its software to exploit local and global networking capabilities to enhance their functionality and to adapt their local behavior when beneficial. Such systems will therefore include complex hard real-time coordination at the network level. This coordination is further reflected locally by complex reconfiguration in form of mode management and control algorithms. We present in this paper the integration of two tools which allow the integrated specification of real-time coordination and traditional control engineering specifically targeting the required complex reconfiguration of the local behavior.