Integrating model verification and self-adaptation

Acknowledgments During my dissertation research, many people have oered their generous help. Without their help, I could never finish this dissertation. I am sincerely grateful to all of them. My advisor, Prof. James C. Browne, has been the most important person to my dissertation research. He has oered,me all the guidance and help that I

2002

CIB-W078 Conference in Cairo, 2010

This paper presents an overview of concepts for model checking. This have resulted in a description of four different concepts based on the intention for checking. The four concepts are: a) Validating systems, b) Guiding systems, c) Adaptive systems and d) Content based checking. By use of an ontological approach we propose a four level taxonomy of model checking 1) Intention, 2) Result, 3) Rule set and 4) Type of products. Model checking should be regarded as a knowledge system for support of the design process.

2006

Model checking has proven to be an effective technology for verification and debugging in hardware and more recently in software domains. With the proliferation of multicore architectures and a greater emphasis on distributed computing, model checking is an increasingly important software quality assurance technique that can complement existing testing and inspection methods.

IEEE Transactions on Software Engineering, 1998

In this paper, we present our experiences in using symbolic model checking to analyze a specification of a software system for aircraft collision avoidance. Symbolic model checking has been highly successful when applied to hardware systems. We are interested in whether model checking can be effectively applied to large software specifications. To investigate this, we translated a portion of the state-based system requirements specification of Traffic Alert and Collision Avoidance System II (TCAS II) into input to a symbolic model checker (SMV). We successfully used the symbolic model checker to analyze a number of properties of the system. We report on our experiences, describing our approach to translating the specification to the SMV language, explaining our methods for achieving acceptable performance, and giving a summary of the properties analyzed. Based on our experiences, we discuss the possibility of using model checking to aid specification development by iteratively applying the technique early in the development cycle. We consider the paper to be a data point for optimism about the potential for more widespread application of model checking to software systems.

Logic Journal of IGPL, 2006

We consider the case where inconsistencies are present between a system and its corresponding model, used for automatic verification. Such inconsistencies can be the result of modeling errors or recent modifications of the system. Despite such discrepancies we can still attempt to perform automatic verification. In fact, as we show, we can sometimes exploit the verification results to assist in automatically learning the required updates to the model. In a related previous work, we have suggested the idea of black box checking, where verification starts without any model, and the model is obtained while repeated verification attempts are performed. Under the current assumptions, an existing inaccurate (but not completely obsolete) model is used to expedite the updates. We use techniques from black box testing and machine learning. We present an implementation of the proposed methodology called AMC (for Adaptive Model Checking). We discuss some experimental results, comparing various tactics of updating a model while trying to perform model checking.

2005

Model checking has proven to be an effective technology for verification and debugging in hardware and more recently in software domains. We believe that recent trends in both the requirements for software systems and the processes by which systems are developed suggest that domain-specific model checking engines may be more effective than general purpose model checking tools. To overcome limitations of existing tools which tend to be monolithic and non-extensible, we have developed an extensible and customizable model checking framework called Bogor. In this tool paper, we summarize (a) Bogor’s direct support for modeling object-oriented designs and implementations, (b) its facilities for extending and customizing its modeling language and algorithms to create domain-specific model checking engines, and (c) pedagogical materials that we have developed to describe the construction of model checking tools built on top of the Bogor infrastructure.

2010

Model checking techniques have been applied widely for verifying hardware designs and protocols since they can check if the system operates as desired or not without actually running the system. Recently, the usage of model checking for software verification has also been increasingly considered. One notable advantage of the model checking approach is the ability of producing counter-example when detecting undesired problem. However, model checking also suffered some prominent disadvantages which are (i) state explosion problem with non-trivial input space and (ii) over-specific model-based representation of verification results. In this paper, we propose a framework known as MAFSE (Model-bAsed Framework for Software vErification) which is still able to make full use of model checking capability for verifying software programs yet overcoming those typical drawbacks by applying appropriate methods. Our framework has been tested with some lab-scaled data and is promising to be applied for industrial software engineering.

Automated Software Engineering, 2008

Model checkers were originally developed to support the formal verification of high-level design models of distributed system designs. Over the years, they have become unmatched in precision and performance in this domain. Research in model checking has meanwhile moved towards methods that allow us to reason also about implementation level artifacts (e.g., software code) directly, instead of hand-crafted representations of those artifacts. This does not mean that there is no longer a place for the use of high-level models, but it does mean that such models are used in a different way today. In the approach that we describe here, high-level models are used to represent the environment for which the code is to be verified, but not the application itself. The code of the application is now executed as is by the model checker, while using powerful forms of abstraction on-the-fly to build the abstract state space that guides the verification process. This model-driven code checking method allows us to verify implementation level code efficiently for high-level safety and liveness properties. In this paper, we give an overview of the methodology that supports this new paradigm of code verification.

Electronic Notes in Theoretical Computer Science, 2005

We propose a new development scheme for quality-aware applications, quality-driven development (QDD), based on the Model-Driven Architecture (MDA) of OMG. We argue that software development in areas, such as real-time systems, should not only rely on code verification, but also on design verification, and show that a slightly extended MDA process offers the opportunity to integrate system development together with design verification.