Abstract Threads

@inproceedings{Lahiri2010AbstractT,
  title={Abstract Threads},
  author={Shuvendu K. Lahiri and Alexander Malkis and Shaz Qadeer},
  booktitle={VMCAI},
  year={2010}
}
Verification of large multithreaded programs is challenging. Automatic approaches cannot overcome the state explosion in the number of threads; semi-automatic methods require expensive human time for finding global inductive invariants. Ideally, automatic methods should not deal with the composition of the original threads and a human should not supply a global invariant. We provide such an approach. In our approach, a human supplies a specification of each thread in the program. Here he has… 
Modular Verification of Concurrent Programs via Sequential Model Checking
TLDR
This work reduces the verification of a concurrent program to a series of verification tasks of sequential programs, and works particularly well on hierarchically structured programs where the threads are structured hierarchically.
Thread modularity at many levels: a pearl in compositional verification
TLDR
A hierarchy of proof systems where each level k corresponds to a generalized notion of thread modularity (level 1 corresponds to the original notion) is described, which precisely captures programs that can be proved using uniform Ashcroft invariants with k universal quantifiers.
Reachability in Binary Multithreaded Programs Is Polynomial
  • A. Malkis, S. Borgwardt
  • Computer Science
    2017 IEEE 37th International Conference on Distributed Computing Systems (ICDCS)
  • 2017
TLDR
For the subclass of so-called binary multithreaded programs, new bounds are proved: all these quantities are majorized by a polynomial and, in certain cases, by a linear, logarithmic, or even constant function.
On the Strength of Owicki-Gries for Resources
TLDR
It is proved the absence of a general exact closure-based fixpoint characterization of the accuracy of the Owicki-Gries method, both in the collecting semantics and in certain trace semantics.
Reachability in Multithreaded Programs Is Polynomial in the Number of Threads
  • A. Malkis
  • Computer Science
    2019 20th International Conference on Parallel and Distributed Computing, Applications and Technologies (PDCAT)
  • 2019
TLDR
Borders shed more light on how the widely expressed claim, that one of the major obstacles to analyzing concurrent programs is the exponential state explosion in the number of threads, should (and should not) be understood.
Reachability in Parallel Programs Is Polynomial in the Number of Threads
  • A. Malkis
  • Computer Science
    Journal of Parallel and Distributed Computing
  • 2021

References

SHOWING 1-10 OF 37 REFERENCES
Verifying safety properties of concurrent Java programs using 3-valued logic
We provide a parametric framework for verifying safety properties of concurrent Java programs. The framework combines thread-scheduling information with information about the shape of the heap. This
Modular verification of multithreaded programs
Precise Thread-Modular Verification
TLDR
A new abstraction algorithm for threadmodular verification that offers both high degree precision and polynomial complexity is proposed, based on a new abstraction domain that combines Cartesian abstraction with exception sets, which allow one to handle particular thread interactions precisely.
Thread-Modular Model Checking
We present thread-modular model checking, a novel technique for verifying correctness properties of loosely-coupled multithreaded software systems. Thread-modular model checking verifies each thread
Race checking by context inference
TLDR
This work uses richer context models to infer suitable context models automatically by a combination of counterexample-guided abstraction refinement, bisimulation minimization, circular assume-guarantee reasoning, and parametric reasoning about an unbounded number of threads.
Types as models: model checking message-passing programs
TLDR
The system includes two novel components to achieve this end: a behavioral type-and-effect system for the π-calculus, which extracts sound models as types, and an assume-guarantee proof rule for carrying out compositional model checking on the types.
Bounded Model Checking of Concurrent Programs
TLDR
This work proposes a SAT-based bounded verification technique, called TCBMC, for threaded C programs, based on CBMC, and obtains an efficient modeling that can be sent to a SAT solver for property checking.
Principles of model checking
TLDR
Principles of Model Checking offers a comprehensive introduction to model checking that is not only a text suitable for classroom use but also a valuable reference for researchers and practitioners in the field.
Thread-modular shape analysis
TLDR
This work presents the first shape analysis for multithreaded programs that avoids the explicit enumeration of execution-interleavings and shows that resource invariants of a certain class can be characterized as least fixed points and computed via repeated applications of shape analysis only on each individual thread.
ACSAR: Software Model Checking with Transfinite Refinement
TLDR
The idea behind ACSAR is to abstract not just states but also the state changes induced by structured program statements, including for- and while-statements, which allows one to shortcut such a “transfinite” sequence of refinement steps.
...
...