Designing and Verifying Communication Protocols Using Model Driven Architecture and Spin Model Checker
09 Dec 2008-Journal of Software Engineering and Applications (Scientific Research Publishing)-Vol. 01, Iss: 1, pp 13-19
TL;DR: A 2-Phase strategy based on the UML state machine and sequence diagram is introduced to satisfy the properties of communication protocols and is compared with the developed UML models.
Abstract: The need of communication protocols in today’s environment increases as much as the network explores. Many new kinds of protocols, e.g. for information sharing, security, etc., are being developed day-to-day which often leads to rapid, premature developments. Many protocols have not scaled to satisfy important properties like deadlock and livelock freedom, since MDA focuses on the rapid development rather than on the quality of the developed models. In order to fix the above, we introduce a 2-Phase strategy based on the UML state machine and sequence diagram. The state machine is converted into PROMELA code as a protocol model and its properties are derived from the sequence diagram as Linear Temporal Logic (LTL) through automation. The PROMELA code is interpreted through the SPIN model checker, which helps to simulate the behavior of protocol. Later the automated LTL properties are supplemented to the SPIN for the verification of protocol properties. The results are compared with the developed UML model and SPIN simulated model. Our test results impress the designer to verify the expected results with the system design and to identify the errors which are unnoticed during the design phase.
Citations
More filters
01 Nov 1998
TL;DR: 본 논문에서는 Dr Gerald J. Holzmann이 제시하였던 커널 스케줄링 방식을 프로세스 ACSR-VP 보인다.
Abstract: 본 논문에서는 Dr Gerald J. Holzmann이 제시하였던 커널 스케줄링 방식을 프로세스 알제브라 ACSR-VP를 이용해서 있음을 보인다. 본 오류는 SPIN을 통하여 역시 확인하였다. 이것을 다시 모델링하여 오류를 수정하였고 ACSR-VP와 SPIN으로 오류가 수정되었음을 확인하였다.
163 citations
TL;DR: A formal verification framework based on mapping a composition of SysML activity diagrams to the input language of the probabilistic symbolic model checker called ''PRISM'' is proposed that supports the most important artifacts.
Abstract: SysML activity diagrams are OMG/INCOSE standard diagrams used for modeling and specifying probabilistic systems. They support systems composition by call behavior and send/receive artifacts. For verification, the existing approaches dedicated to these diagrams are limited to a restricted set of artifacts. In this paper, we propose a formal verification framework for these diagrams that supports the most important artifacts. It is based on mapping a composition of SysML activity diagrams to the input language of the probabilistic symbolic model checker called ''PRISM''. To prove the soundness of our mapping approach, we capture the underlying semantics of both the SysML activity diagrams and their generated PRISM code. We found that the probabilistic equivalence relation between both semantics preserve the satisfaction of the system requirements. Finally, we demonstrate the effectiveness of our approach by presenting real case studies.
38 citations
TL;DR: A novel verification framework based on PRISM probabilistic model checker that takes the SysML activity diagram as input and produces their equivalent timed probabilism automata that is/are expressed in PRISM language is proposed.
Abstract: Formal verification framework for probabilistic systems is proposed.SysML activity diagrams is used for system modeling.Automatic transformation of activity diagram into PRISM language.The soundness of the proposed framework is proved. Time-constrained and probabilistic verification approaches gain a great importance in system behavior validation including avionic, transport risk assessment, automotive systems and industrial process controllers. They enable the evaluation of system behavior according to the design requirements and ensure their correctness before any implementation. Due to the difficulty of analyzing, modeling and verifying these large scale systems, we introduce a novel verification framework based on PRISM probabilistic model checker that takes the SysML activity diagram as input and produce their equivalent timed probabilistic automata that is/are expressed in PRISM language. To check the functional correctness of the system under test, the properties are expressed in PCTL temporal logic. To prove the soundness of our mapping approach, we capture the underlying semantics of both the SysML activity diagrams and their generated PRISM code. We found that the timed probabilistic equivalence relation between both semantics preserve the satisfaction of the system requirements. We present digital camera as case study to illustrate the applicability of the proposed approach and to demonstrate its efficiency by analyzing a performability properties.
14 citations
Cites background from "Designing and Verifying Communicati..."
...Kaliappan, Koenig, and Kaliappan (2008) propose a verification approach for system workflow especially in communication protocol....
[...]
TL;DR: A synthesis method is proposed that automatically synthesizes the protocol specification of distributed protocol entities from the service specification, given that both types of specifications are modeled in UML protocol state machines.
Abstract: The object-oriented paradigm is widely applied in designing and implementing communication systems. Unified Modeling Language (UML) is a standard language used to model the design of object-oriented systems. A protocol state machine is a UML adopted diagram that is widely used in designing communication protocols. It has two key attractive advantages over traditional finite state machines: modeling concurrency and modeling nested hierarchical states. In a distributed communication system, each entity of the system has its own protocol that defines when and how the entity exchanges messages with other communicating entities in the system. The order of the exchanged messages must conform to the overall service specifications of the system. In object-oriented systems, both the service and the protocol specifications are modeled in UML protocol state machines. Protocol specification synthesis methods have to be applied to automatically derive the protocol specification from the service specification. Otherwise, a time-consuming process of design, analysis, and error detection and correction has to be applied iteratively until the design of the protocol becomes error-free and consistent with the service specification. Several synthesis methods are proposed in the literature for models other than UML protocol state machines, and therefore, because of the unique features of the protocol state machines, these methods are inapplicable to services modeled in UML protocol state machines. In this paper, we propose a synthesis method that automatically synthesizes the protocol specification of distributed protocol entities from the service specification, given that both types of specifications are modeled in UML protocol state machines. Our method is based on the latest UML version (UML2.3), and it is proven to synthesize protocol specifications that are syntactically and semantically correct. As an example application, the synthesis method is used to derive the protocol specification of the H.323 standard used in Internet calls.
12 citations
Cites methods from "Designing and Verifying Communicati..."
...Design validation and analysis techniques have been proposed by several researchers (e.g., [1, 31, 42-45])....
[...]
10 Sep 2015
TL;DR: A probabilistic and timed verification framework of State Machine diagrams extended with time and probability features of PRISM language is proposed and efficiency is demonstrated by analyzing performability properties on a Automatic Teller Machine case study.
Abstract: Timed-constrained and probabilistic verification approaches gain a great importance in system behavior validation. They enable the evaluation of system behavior according to the design requirements and ensure their correctness before any implementation. In this paper, we propose a probabilistic and timed verification framework of State Machine diagrams extended with time and probability features. The approach consists on mapping the extended State Machine diagram to its equivalent probabilistic timed automata that is expressed in PRISM language. To check the functional correctness of the system under test, the properties are expressed in PCTL temporal logic. We demonstrate the approach efficiency by analyzing performability properties on a Automatic Teller Machine (ATM) case study.
10 citations
Cites background from "Designing and Verifying Communicati..."
...[13] propose a verification approach for system work-flow especially in communication protocol....
[...]
References
More filters
[...]
01 Sep 1996
TL;DR: Model checking tools, created by both academic and industrial teams, have resulted in an entirely novel approach to verification and test case generation that often enables engineers in the electronics industry to design complex systems with considerable assurance regarding the correctness of their initial designs.
Abstract: Turing Lecture from the winners of the 2007 ACM A.M. Turing Award. In 1981, Edmund M. Clarke and E. Allen Emerson, working in the USA, and Joseph Sifakis working independently in France, authored seminal papers that founded what has become the highly successful field of model checking. This verification technology provides an algorithmic means of determining whether an abstract model---representing, for example, a hardware or software design---satisfies a formal specification expressed as a temporal logic (TL) formula. Moreover, if the property does not hold, the method identifies a counterexample execution that shows the source of the problem. The progression of model checking to the point where it can be successfully used for complex systems has required the development of sophisticated means of coping with what is known as the state explosion problem. Great strides have been made on this problem over the past 28 years by what is now a very large international research community. As a result many major hardware and software companies are beginning to use model checking in practice. Examples of its use include the verification of VLSI circuits, communication protocols, software device drivers, real-time embedded systems, and security algorithms. The work of Clarke, Emerson, and Sifakis continues to be central to the success of this research area. Their work over the years has led to the creation of new logics for specification, new verification algorithms, and surprising theoretical results. Model checking tools, created by both academic and industrial teams, have resulted in an entirely novel approach to verification and test case generation. This approach, for example, often enables engineers in the electronics industry to design complex systems with considerable assurance regarding the correctness of their initial designs. Model checking promises to have an even greater impact on the hardware and software industries in the future. ---Moshe Y. Vardi, Editor-in-Chief
7,392 citations
01 May 1997
TL;DR: An overview of the design and structure of the verifier, its theoretical foundation, and an overview of significant practical applications are given.
Abstract: SPIN is an efficient verification system for models of distributed software systems. It has been used to detect design errors in applications ranging from high-level descriptions of distributed algorithms to detailed code for controlling telephone exchanges. The paper gives an overview of the design and structure of the verifier, reviews its theoretical foundation, and gives an overview of significant practical applications.
4,159 citations
"Designing and Verifying Communicati..." refers methods in this paper
...The model properties are translated into a temporal logic and imported together with the PROMELA code into the model checker SPIN (Simple Protocol INterpreter) [4] for verification....
[...]
Book•
21 Apr 2003
TL;DR: Insight is given in what MDA means and what you can achieve, both today and in the future, thereby raising the level of maturity of the IT industry.
Abstract: From the Book:
For many years, the three of us have been developing software using object oriented techniques. We started with object oriented programming languages, like C++, Smalltalk, and Eiffel. Soon we felt the need to describe our software at a higher level of abstraction. Even before the first object oriented analysis and design methods, like Coad/Yourdon and OMT, were published, we used our own invented bubbles and arrows diagrams. This naturally led to questions like "What does this arrow mean?" and "What is the difference between this circle and that rectangle?". We therefore rapidly decided to use the newly emerging methods to design and describe our software. During the years we found that we were spending more time on designing our models, than on writing code. The models helped us to cope with larger and more complex systems. Having a good model of the software available, made the process of writing code easier and in many cases even straightforward.
In 1997 some of us got involved in defining the first standard for object oriented modeling called UML. This was a major milestone that stimulated the use of modeling in the software industry. When the OMG launched its initiative on Model Driven Architecture we felt that this was logically the next step to take. People try to get more and more value from their high level models, and the MDA approach supports these efforts.
At that moment we realized that all these years we had naturally walked the path towards model driven development. Every bit of wisdom we acquired during our struggle with the systems we had to build, fitted in with this new idea of how to build software. It caused a feeling similar to an AHA-erlebnis: "Yes, this is it," the same feeling we had years before when we first encountered the object-oriented way of thinking, and again when we first read the GOF book on design patterns. We feel that MDA could very well be the next major step forward in the way software is being developed. MDA brings the focus of software development to a higher level of abstraction, thereby raising the level of maturity of the IT industry.
We are aware of the fact that the grand vision of MDA, which Richard Soley, the president of the OMG, presents so eloquently, is not yet a reality. However some parts of MDA can already be used today, while others are under development. With this book we want to give you insight in what MDA means and what you can achieve, both today and in the future.
Anneke Kleppe, Jos Warmer, and Wim Bast
Soest, the Netherlands
January 2003
2,031 citations
"Designing and Verifying Communicati..." refers methods in this paper
...The final step takes PSM as an input to produce the implementation for a particular platform using a transformation tool....
[...]
01 Nov 1998
TL;DR: 본 논문에서는 Dr Gerald J. Holzmann이 제시하였던 커널 스케줄링 방식을 프로세스 ACSR-VP 보인다.
Abstract: 본 논문에서는 Dr Gerald J. Holzmann이 제시하였던 커널 스케줄링 방식을 프로세스 알제브라 ACSR-VP를 이용해서 있음을 보인다. 본 오류는 SPIN을 통하여 역시 확인하였다. 이것을 다시 모델링하여 오류를 수정하였고 ACSR-VP와 SPIN으로 오류가 수정되었음을 확인하였다.
163 citations
26 Aug 2002
TL;DR: This work presents a toolset which can validate both static and dynamic aspects of a model; and this toolset is based on the semantic model using Abstract State Machines, which means it is correct with respect to the semanticmodel.
Abstract: The Unified Modeling Language has become widely accepted as a standard in software development. Several tools have been produced to support UML model validation. However most of them support either static or dynamic model checking; and no tools support to check both static and dynamic aspects of a UML model. But a UML model should include the static and dynamic aspects of a software system. Furthermore, these UML tools translate a UML model into a validation language such as PROMELA. But they have some shortcomings: there is no proof of correctness (with respect to the UML semantics) for these tools. In order to overcome these shortcomings, we present a toolset which can validate both static and dynamic aspects of a model; and this toolset is based on the semantic model using Abstract State Machines. Since the toolset is derived from the semantic model, the toolset is correct with respect to the semantic model.
53 citations
"Designing and Verifying Communicati..." refers background in this paper
...The Platform Independent Model is a model with a high level of abstraction that is independent of any implementation technology [11]....
[...]