Analysis of Commutativity with State-Chart Graph Representation of Concurrent Programs

04/08/2019
by   Kishore Debnath, et al.
0

We present a new approach to check for commutativity in concurrent programs from their state-chart graphs. A set of operations are commutative if changing the order of their execution on an object does not affect the abstract state of the object and returns the same response. Concurrent operations that commute at object-level can be executed concurrently at transaction-level, which boosts performance while preserving the appearance of atomicity and isolation. Utilizing object-level commutativity in transactional execution enables the reuse of existing non-blocking programming techniques for thread-level synchronization. In our approach, we generate state-chart graphs by tracking data on the atomic instructions invoked on the concurrent object during model checking and represent the atomic instructions as states in a state-transition representation. Considering the non-deterministic nature of concurrent programs, we determine commutativity by exhaustively searching for identical object states captured at a thread-level granularity across all thread interleavings. With this methodology, a user can not only verify commutativity among operations, but also can visually check ways in which methods commute at object-level, which is an edge over current state-of-the-art tools. The object-level commutative information helps in identifying faulty implementations and performance improvement considerations. We use the graph database, Neo4j, to represent object states as nodes that further assists the user to check for concurrency properties using Cypher queries.

READ FULL TEXT

page 2

page 7

page 11

research
03/27/2018

Safe Non-blocking Synchronization in Ada 202x

The mutual-exclusion property of locks stands in the way to scalability ...
research
11/04/2019

Verifying Visibility-Based Weak Consistency

Multithreaded programs generally leverage efficient and thread-safe conc...
research
10/11/2017

A Semantics Comparison Workbench for a Concurrent, Asynchronous, Distributed Programming Language

A number of high-level languages and libraries have been proposed that o...
research
05/03/2019

An Efficient Approach to Achieve Compositionality using Optimized Multi-Version Object Based Transactional Systems

In the modern era of multi-core systems, the main aim is to utilize the ...
research
06/26/2018

Verification of Shared-Reading Synchronisers

Synchronisation classes are an important building block for shared memor...
research
09/22/2017

Subjective Simulation as a Notion of Morphism for Composing Concurrent Resources

Recent approaches to verifying programs in separation logics for concurr...
research
06/12/2017

Serialisable Multi-Level Transaction Control: A Specification and Verification

We define a programming language independent controller TaCtl for multi-...

Please sign up or login with your details

Forgot password? Click here to reset