Debugging of Concurrent Systems Using Counterexample Analysis

Model checking is an established technique for automatically verifying that a model satisfies a given temporal property. When the model violates the property, the model checker returns a counterexample , which is a sequence of actions leading to a state where the property is not satisfied. Understanding this counterexample for debugging the specification is a complicated task for several reasons: (i) the counterexample can contain hundreds of actions, (ii) the debugging task is mostly achieved manually, and (iii) the counterexample does not give any clue on the state of the system (e.g., parallelism or data expressions) when the error occurs. This paper presents a new approach that improves the usability of model checking by simplifying the comprehension of counterexamples. Our solution aims at keeping only actions in counterexamples that are relevant for debugging purposes. To do so, we first extract in the model all the counterexamples. Second, we define an analysis algorithm that identifies actions that make the behaviour skip from incorrect to correct behaviours, making these actions relevant from a debugging perspective. Our approach is fully automated by a tool that we implemented and applied on real-world case studies from various application areas for evaluation purposes.

[1]  Ernesto Pimentel,et al.  Contracts for security adaptation , 2011, J. Log. Algebraic Methods Program..

[2]  Mohammed Bekkouche,et al.  LocFaults: a new flow-driven and constraint-based error localization approach , 2015, SAC.

[3]  Radu Mateescu,et al.  CADP 2011: a toolbox for the construction and analysis of distributed processes , 2012, International Journal on Software Tools for Technology Transfer.

[4]  Lina Ye,et al.  Debugging Process Algebra Specifications , 2015, VMCAI.

[5]  Alfred V. Aho,et al.  Compilers: Principles, Techniques, and Tools , 1986, Addison-Wesley series in computer science / World student series edition.

[6]  Fabienne Boyer,et al.  Verification of a self-configuration protocol for distributed applications in the cloud , 2012, SAC '12.

[7]  G. G. Stokes "J." , 1890, The New Yale Book of Quotations.

[8]  David Park,et al.  Concurrency and Automata on Infinite Sequences , 1981, Theoretical Computer Science.

[9]  Christel Baier,et al.  Principles of model checking , 2008 .

[10]  Chao Wang,et al.  Abstraction and mining of traces to explain concurrency bugs , 2016, FM 2016.

[11]  Florian Leitner-Fischer,et al.  Symbolic Causality Checking Using Bounded Model Checking , 2015, SPIN.

[12]  Radu Mateescu,et al.  A Model Checking Language for Concurrent Value-Passing Systems , 2008, FM.

[13]  Xifeng Yan,et al.  CloSpan: Mining Closed Sequential Patterns in Large Datasets , 2003, SDM.

[14]  Stefan Leue,et al.  Mining Sequential Patterns to Explain Concurrent Counterexamples , 2013, SPIN.

[15]  Alexandra Silva,et al.  Generalizing determinization from automata to coalgebras , 2013, Log. Methods Comput. Sci..

[16]  Yves Le Traon,et al.  Effective fault localization via mutation analysis: a selective mutation approach , 2014, SAC.

[17]  Radu Mateescu,et al.  Partial Model Checking using Networks of Labelled Transition Systems and Boole an Equation Systems , 2013, Log. Methods Comput. Sci..

[18]  Javier Cámara,et al.  Semi-Automatic Specification of Behavioural Service Adaptation Contracts , 2010, Electron. Notes Theor. Comput. Sci..

[19]  Stephan Merz,et al.  Model Checking , 2000 .

[20]  Frédéric Lang,et al.  SVL: A Scripting Language for Compositional Verification , 2001, FORTE.

[21]  Gwen Salaün,et al.  Describing and reasoning on Web services using process algebra , 2004, Proceedings. IEEE International Conference on Web Services, 2004..

[22]  Tevfik Bultan,et al.  Realizability of Choreographies Using Process Algebra Encodings , 2012, IEEE Transactions on Services Computing.

[23]  Gwen Salaün,et al.  Adaptation of Service Protocols Using Process Algebra and On-the-Fly Reduction Techniques , 2008, IEEE Transactions on Software Engineering.

[24]  Xiang Fu,et al.  Conversation protocols: a formalism for specification and verification of reactive electronic services , 2003, Theor. Comput. Sci..

[25]  Robin Milner,et al.  Communication and concurrency , 1989, PHI Series in computer science.