Verification of Concurrent Programs Using Trace Abstraction Refinement

2015 ◽  
pp. 233-248 ◽  
Author(s):  
Franck Cassez ◽  
Frowin Ziegler
Keyword(s):  
Concurrent Programs ◽  
Abstraction Refinement

scholarly journals Counterexample-guided abstraction refinement for symmetric concurrent programs

2012 ◽  
Vol 41 (1) ◽  
pp. 25-44 ◽  
Author(s):  
Alastair F. Donaldson ◽  
Alexander Kaiser ◽  
Daniel Kroening ◽  
Michael Tautschnig ◽  
Thomas Wahl
Keyword(s):  
Concurrent Programs ◽  
Abstraction Refinement

Causal-Consistent Replay Reversible Semantics for Message Passing Concurrent Programs

2021 ◽  
Vol 178 (3) ◽  
pp. 229-266
Author(s):  
Ivan Lanese ◽  
Adrián Palacios ◽  
Germán Vidal
Keyword(s):  
Programming Language ◽  
Message Passing ◽  
Concurrent Programming ◽  
Concurrent Systems ◽  
Concurrent Programs ◽  
Unified Framework ◽  
Innovative Technique ◽  
Dual Notion

Causal-consistent reversible debugging is an innovative technique for debugging concurrent systems. It allows one to go back in the execution focusing on the actions that most likely caused a visible misbehavior. When such an action is selected, the debugger undoes it, including all and only its consequences. This operation is called a causal-consistent rollback. In this way, the user can avoid being distracted by the actions of other, unrelated processes. In this work, we introduce its dual notion: causal-consistent replay. We allow the user to record an execution of a running program and, in contrast to traditional replay debuggers, to reproduce a visible misbehavior inside the debugger including all and only its causes. Furthermore, we present a unified framework that combines both causal-consistent replay and causal-consistent rollback. Although most of the ideas that we present are rather general, we focus on a popular functional and concurrent programming language based on message passing: Erlang.

scholarly journals Mechanized verification of fine-grained concurrent programs

2015 ◽  
Vol 50 (6) ◽  
pp. 77-87 ◽  
Author(s):  
Ilya Sergey ◽  
Aleksandar Nanevski ◽  
Anindya Banerjee
Keyword(s):  
Concurrent Programs ◽  
Fine Grained ◽  
Mechanized Verification

A generic approach to the static analysis of concurrent programs with procedures

2003 ◽  
Vol 38 (1) ◽  
pp. 62-73 ◽  
Author(s):  
Ahmed Bouajjani ◽  
Javier Esparza ◽  
Tayssir Touili
Keyword(s):  
Static Analysis ◽  
Concurrent Programs

scholarly journals Configurable verification of timed automata with discrete variables

2020 ◽  
Author(s):  
Tamás Tóth ◽  
István Majzik
Keyword(s):  
Timed Automata ◽  
Empirical Evaluation ◽  
Real Time Systems ◽  
Discrete Variables ◽  
Reachability Problem ◽  
Abstraction Refinement ◽  
Dependent Behavior ◽  
Wide Range ◽  
Time Systems ◽  
Lazy Abstraction

AbstractAlgorithms and protocols with time dependent behavior are often specified formally using timed automata. For practical real-time systems, besides real-valued clock variables, these specifications typically contain discrete data variables with nontrivial data flow. In this paper, we propose a configurable lazy abstraction framework for the location reachability problem of timed automata that potentially contain discrete variables. Moreover, based on our previous work, we uniformly formalize in our framework several abstraction refinement strategies for both clock and discrete variables that can be freely combined, resulting in many distinct algorithm configurations. Besides the proposed refinement strategies, the configurability of the framework allows the integration of existing efficient lazy abstraction algorithms for clock variables based on $${\textit{LU}}$$ LU -bounds. We demonstrate the applicability of the framework and the proposed refinement strategies by an empirical evaluation on a wide range of timed automata models, including ones that contain discrete variables or diagonal constraints.

Sign in / Sign up

Export Citation Format

Share Document