Yuhong Zhao

Model-based Runtime Verification Framework for Self-optimizing Systems

This paper describes a novel on-line model checking approach offered as service of a real-time operating system (RTOS). The verification system is intended especially for self-optimizing component-based real-time systems where self-optimization is performed by dynamically exchanging components. The verification is performed at the level of (RT-UML) models. The properties to be checked are expressed by RT-OCL terms where the underlying temporal logic is restricted to either time-annotated ACTL or LTL formulae. The on-line model checking runs interleaved with the execution of the component to be checked in a pipelined manner. The technique applied is based on on-the-fly model checking. More specifically for ACTL formulae this means on-the-fly solution of the NHORNSAT problem while in the case of LTL the emptiness checking method is applied.

Online Model Checking for Dependable Real-Time Systems

This paper presents a lightweight verification technique, which is applicable to dependable real-time systems, provided that the (abstract) model and the (concrete) implementation of the system under test are given in advance. In addition to the usual quality assurance techniques at design time (e.g., formal verification) and at implementation time (e.g., testing), we provide a special form of model checking at run time. That is, we check the correctness of an actual system execution by means of exploring a partial model space covering the current execution trace. In doing so, concrete state information is observed from time to time while the system to be checked is running. This runtime information is used to guide model checking to reduce the model space to be explored. In this sense, we call this method online model checking. Since we do not directly check the execution trace itself, our online checking at model level is capable of checking a running system some steps ahead of the actual state of execution. In this paper, we describe online model checking as well as the underlying system architecture in general, explain the basic algorithm and its extension to improve performance, and provide experimental results.

On-Line Model Checking as Operating System Service

A complementary verification method for real-time application with dynamic task structure has been developed. Here the real-time application is developed by means of Model-Driven Engineering. The basic verification technique is given by model checking. However, the model checking is executed at run-time whenever some reconfiguration of the task set takes place. Instead of exploring the entire state space of the model to be checked, only a partial state space at model level covering the execution trace of the checked task is explored. This on-line model checking can be seen as an extension to the traditional schedulability acceptance test which is needed anyway in systems with dynamic task set. Therefore this runtime verification is implemented as a service of the underlying operating system. In this paper we describe this method in general, explain some design and implementation decisions and provide experimental results.

Accelerating Online Model Checking

Online model checking is a lightweight verification technique to ensure at runtime the safety of the current execution trace of the system application under test. Doing model checking online suffers from the limited execution time allocated to each checking cycle. In this paper, we focus on accelerating online model checking so that as large the model space as possible can be explored in time. For this purpose, we introduce offline backward exploration so as to reduce the workload of online forward exploration. As a result, online model checking becomes online reach ability checking. SAT solver is used as verification engine for online model checking. We improve the performance of the SAT solver zChaff by optimizing and customizing zChaff with respect to the online model checking specific features. Moreover, we take advantage of the parallel feature and the multi-port memory available on FPGA chips. We present a new underlying architecture using 2 SAT solvers as verification engine for online model checking. We implement a quick prototype of the new underlying architecture for online model checking. Several experiments are done to test the performance of our online model checking.

Model-based Runtime Verification Framework

Model-based runtime verification is an extension to the state-of-the-art runtime verification, aimed at checking at runtime the system implementation against the system model (consistency checking) and the system model against the system specification (safety checking). Notice that our runtime verification works at the model level, thus, we do not need to strictly synchronize this runtime verification with the system execution. In fact, we mainly use the runtime information (current states) obtained from the system execution to reduce the state space (of the system model) to be explored. It means that this model-based runtime verification might run before or after the system execution, i.e., switch alternately between a preventive pre-checking mode and a maintaining post-checking mode. In order to make it run ahead of the system execution for as long time as possible, we present two possible strategies so that this runtime verification can selectively reduce the state space (of the system model) to be explored by making the system model enriched with probabilities and additional information derived and learned at the system testing phase.

Designing Self-Adaptive Embedded Real-Time Software -- Towards System Engineering of Self-Adaptation

Upcoming interlinked embedded systems will be confronted with unexpectedly changing environments, which makes online adaptation without manual interference necessary. There is a need for appropriate system architectures and novel design approaches. In this paper, we discuss general concepts of self-adaptive real-time systems. Furthermore, specific system engineering techniques solving two important aspects of such a paradigm are presented. We discuss how the necessity for adaptation can be identified using Online Model Checking and how self-adapting safety guards can be designed by means of Artificial Immune Systems. Finally, we present an approach to integrating these techniques into an underlying platform architecture based on mixed-criticality virtualization.

Efficient integration of online model checking into a small-footprint real-time operating system

In this paper we discuss how an efficient online model checker and a small-footprint RTOS can be integrated. Alternative approaches are discussed, leading to the decision for a federated approach. An implemented prototype is described and some analytical as well as experimental evaluations are presented.

Comprehensive verification framework for dependability of self-optimizing systems

By integrating formal specification and formal verification into the design phase of a system development process, the correctness of the system can be ensured to a great extent. However, it is not sufficient for a self-optimizing system that needs to exchange its components safely and consistently over time. Therefore, this paper presents a comprehensive verification framework to guarantee the dependability of such a self-optimizing system at the design phase (off-line verification) as well as at the runtime phase (on-line verification). The proposed verification framework adopts AsmL as intermediate representation for the system specification and on-the-fly model checking technique for alleviating the state space explosion problem. The off and the on -line verifications are performed at (RT-UML) model level. The properties to be checked are expressed by RT-OCL where the underlying temporal logic is restricted to time-annotated ACTL/LTL formulae. In particular, the on-line verification is achieved by running the on-the-fly model checking interleaved with the execution of the checked system in a pipelined manner.

Efficient Integration of Online Model Checking into a Small-Footprint Real-Time Operating System

In this paper we discuss how an efficient online model checker and a small-footprint RTOS can be integrated. Alternative approaches are discussed, leading to the decision for a federated approach. An implemented prototype is described and some analytical as well as experimental evaluations are presented.

Organic real-time programming — Vision and approaches towards self-evolving and adaptive real-time software

For upcoming Cyber Physical Systems with a high need of adaptation to changing environments an appropriate programming approach is needed. In this paper we argue that such systems have to be highly adaptive and self-evolving. The general vision and approach is pointed out. Furthermore specific approaches solving important aspects of such a programming paradigm are presented. The aspects discussed include the identification of adaptation needs using online Model Checking, real-time-aware adaptation mechanisms, and self-adapting safety guards by means of Artificial Immune Systems.