Using partial orders for the efficient verification of deadlock freedom and safety properties

Godefroid, Patrice; Wolper, Pierre

doi:10.1007/3-540-55179-4_32

Cited by 85 publications

(20 citation statements)

References 26 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…4]. Sleep sets [19] form an orthogonal approach, but in isolation only reduce the number of transitions. Dwyer et al [8] propose dynamic techniques for object-oriented programs.…”

Section: Related Workmentioning

confidence: 99%

Stubborn Transaction Reduction

Laarman

2018

Lecture Notes in Computer Science

View full text Add to dashboard Cite

The exponential explosion of parallel interleavings remains a fundamental challenge to model checking of concurrent programs. Both partial-order reduction (POR) and transaction reduction (TR) decrease the number of interleavings in a concurrent system. Unlike POR, transactions also reduce the number of intermediate states. Modern POR techniques, on the other hand, offer more dynamic ways of identifying commutative behavior, a crucial task for obtaining good reductions. We show that transaction reduction can use the same dynamic commutativity as found in stubborn set POR. We also compare reductions obtained by POR and TR, demonstrating with several examples that these techniques complement each other. With an implementation of the dynamic transactions in the model checker LTSmin, we compare its effectiveness with the original static TR and two POR approaches. Several inputs, including realistic case studies, demonstrate that the new dynamic TR can surpass POR in practice. α1

show abstract

“…4]. Sleep sets [19] form an orthogonal approach, but in isolation only reduce the number of transitions. Dwyer et al [8] propose dynamic techniques for object-oriented programs.…”

Section: Related Workmentioning

confidence: 99%

Stubborn Transaction Reduction

Laarman

2018

Lecture Notes in Computer Science

View full text Add to dashboard Cite

show abstract

“…As we already mentioned, automated verification of concurrent systems encounters major problems due to state explosion. One particularly efficient technique able to addresses this problem is known as partial order reduction (POR) [20,37,44]. It consists of restricting the exploration of the state space by avoiding the execution of similar, or equivalent runs.…”

Section: Related Workmentioning

confidence: 99%

Automated Synthesis of Distributed Controllers

Muscholl

2015

Automata, Languages, and Programming

View full text Add to dashboard Cite

Abstract. Synthesis is a particularly challenging problem for concurrent programs. At the same time it is a very promising approach, since concurrent programs are difficult to get right, or to analyze with traditional verification techniques. This paper gives an introduction to distributed synthesis in the setting of Mazurkiewicz traces, and its applications to decentralized runtime monitoring. ContextModern computing systems are increasingly distributed and heterogeneous. Software needs to be able to exploit these advances, providing means for applications to be more performant. Traditional concurrent programming paradigms, as in Java, are based on threads, shared-memory, and locking mechanisms that guard access to common data. More recent paradigms like the reactive programming model of Erlang [4] and Scala [35,36] replace shared memory by asynchronous message passing, where sending a message is non-blocking.In all these concurrent frameworks, writing reliable software is a serious challenge. Programmers tend to think about code mostly in a sequential way, and it is hard to grasp all possible schedulings of events in a concurrent execution. For similar reasons, verification and analysis of concurrent programs is a difficult task. Testing, which is still the main method for error detection in software, has low coverage for concurrent programs. The reason is that bugs in such programs are difficult to reproduce: they may happen under very specific thread schedules and the likelihood of taking such corner-case schedules is very low. Automated verification, such as model-checking and other traditional exploration techniques, can handle very limited instances of concurrent programs, mostly because of the very large number of possible states and of possible interleavings of executions.Formal analysis of programs requires as a pre-requisite a clean mathematical model for programs. Verification of sequential programs starts usually with an abstraction step -reducing the value domains of variables to finite domains, viewing conditional branching as non-determinism, etc. Another major simplification consists in disallowing recursion. This leads to a very robust computational model, namely finite-state automata and regular languages. Regular languages of words (and trees) are particularly well understood notions. The deep connections between logic and automata revealed by the foundational work of Büchi, Rabin, and others, are the main ingredients in automata-based verification.

show abstract

“…This problem is known as state space explosion and ensures that the Kripke structure will either no longer be completely written into the working memory or that the search for desired states can take a very long time. Many scientific works aim to mitigate this problem and cover, for example, the use of symbolic model checking [10], partial order reduction [11], CEGAR (Counterexampleguided abstraction refinement) [12] and some other methods which all have the common goal of keeping the state space as small as possible.…”

Section: Model Checkingmentioning

confidence: 99%

A Study on Configuration and Integration of Sub-Systems to System-of-Systems with Rule Verification

Warnecke¹

2015

ENG

View full text Add to dashboard Cite

Increasing complexity of today's software systems is one of the major challenges software engineers have to face. This is aggravated by the fact that formerly isolated systems have to be interconnected to more complex systems, called System-of-Systems (SoS). Those systems are in charge to provide more functionality to the user than all of their independent sub-systems could do. Reducing the complexity of such systems is one goal of the software engineering paradigm called component-based software engineering (CBSE). CBSE enables the developers to treat individual sub-systems as components which interact via interfaces with a simulated environment. Thus those components can be developed and implemented independently from other components. After the implementation a system integrator is able to interconnect the components to a SoS. Despite this much-used approach it is possible to show that constraints, which are valid in an isolated sub-system, are broken after this system is integrated into a SoS. To emphasize this issue we developed a technique based on interconnected timed automata for modelling sub-systems and System-of-Systems in the model checking tool UPPAAL. The presented modelling technique allows it to verify the correctness of single sub-systems as well as the resulting SoS. Additionally we developed a tool which abstracts the complicated timed automata to an easy to read component based language with the goal to help system integrators building and verifying complex SoS.

show abstract

Using partial orders for the efficient verification of deadlock freedom and safety properties

Cited by 85 publications

References 26 publications

Stubborn Transaction Reduction

Stubborn Transaction Reduction

Automated Synthesis of Distributed Controllers

A Study on Configuration and Integration of Sub-Systems to System-of-Systems with Rule Verification

Contact Info

Product

Resources

About