Filters








5,192 Hits in 4.6 sec

Mechanizing a Correctness Proof for a Lock-Free Concurrent Stack [chapter]

John Derrick, Gerhard Schellhorn, Heike Wehrheim
2008 Lecture Notes in Computer Science  
In this paper we show how to verify that a concurrent lock-free implementation of a stack is correct by mechanizing the proof that it is linearizable, linearizability being a correctness notion for concurrent  ...  These are used in the second part to verify the lock-free stack implementation. We use the specification language Z to describe the algorithms and the KIV theorem prover to mechanize the proof.  ...  John Derrick and Heike Wehrheim were supported by a DAAD/British Council exchange grant for this work.  ... 
doi:10.1007/978-3-540-68863-1_6 fatcat:qwdzlrovofcuje2nd3x5d3wdpm

Formal Verification of Lock-Free Algorithms

Gerhard Schellhorn, Simon Baumler
2009 2009 Ninth International Conference on Application of Concurrency to System Design  
The paper gives a simple example to demonstrate the central correctness criteria of linearizability (a safety property) and lock-freeness (a liveness property) for lock-free algorithms.  ...  Such lock-free algorithms are less vulnerable to the typical problems of concurrent algorithms: deadlocks, livelocks and priority inversion.  ...  Among these, lock-free algorithms are a recently developed class of algorithms for concurrent access to data structures.  ... 
doi:10.1109/acsd.2009.10 dblp:conf/acsd/SchellhornB09 fatcat:2ou44pua5fhe7ovdrqpruere2u

A scalable lock-free stack algorithm

Danny Hendler, Nir Shavit, Lena Yerushalmi
2004 Proceedings of the sixteenth annual ACM symposium on Parallelism in algorithms and architectures - SPAA '04  
It is based on the following simple observation: that a single elimination array used as a backoff scheme for a simple lock-free stack is lock-free, linearizable, and scalable.  ...  We believe its simplicity and scalability make it a viable practical alternative to existing constructions for implementing concurrent stacks.  ...  The elimination backoff stack is based on the following simple observation: that a single elimination array [17] , used as a backoff scheme for a lock-free stack [22] , is both lock-free and linearizable  ... 
doi:10.1145/1007912.1007944 dblp:conf/spaa/HendlerSY04 fatcat:wldpi6vgqjenjm3iakls3idtna

A scalable lock-free stack algorithm

Danny Hendler, Nir Shavit, Lena Yerushalmi
2010 Journal of Parallel and Distributed Computing  
It is based on the following simple observation: that a single elimination array used as a backoff scheme for a simple lock-free stack is lock-free, linearizable, and scalable.  ...  We believe its simplicity and scalability make it a viable practical alternative to existing constructions for implementing concurrent stacks.  ...  The elimination backoff stack is based on the following simple observation: that a single elimination array [17] , used as a backoff scheme for a lock-free stack [22] , is both lock-free and linearizable  ... 
doi:10.1016/j.jpdc.2009.08.011 fatcat:w645sm7epjcfpnx43bjz5druse

Verifying Concurrent Stacks by Divergence-Sensitive Bisimulation [article]

Xiaoxiao Yang, Joost-Pieter Katoen, Huimin Lin, Hao Wu
2018 arXiv   pre-print
We conducted the experiment on concurrent lock-free stacks to validate the efficiency and effectiveness of our methods.  ...  The verification of linearizability -- a key correctness criterion for concurrent objects -- is based on trace refinement whose checking is PSPACE-complete.  ...  of the concurrent stack in [30] violates the lock-free property.  ... 
arXiv:1701.06104v2 fatcat:lvnmxhae4jcabj2obd3kohbqxu

Verifying Concurrent Data Structures by Simulation

Robert Colvin, Simon Doherty, Lindsay Groves
2005 Electronical Notes in Theoretical Computer Science  
We explain how we used this approach in mechanically verifying a simple lock-free stack implementation using forward simulation, and briefly discuss our experience in verifying three other lock-free algorithms  ...  We describe an approach to verifying concurrent data structures based on simulation between two Input/Output Automata (IOAs), modelling the specification and the implementation.  ...  of a simple lock-free stack algorithm.  ... 
doi:10.1016/j.entcs.2005.04.026 fatcat:tizfqq3j5vbfplkvt4cqria2ey

Modular Termination Verification for Non-blocking Concurrency [chapter]

Pedro da Rocha Pinto, Thomas Dinsdale-Young, Philippa Gardner, Julian Sutherland
2016 Lecture Notes in Computer Science  
This allows us to verify total correctness for nonblocking algorithms, e.g. a counter and a stack. Our specifications can express lock-and wait-freedom.  ...  We present Total-TaDA, a program logic for verifying the total correctness of concurrent programs: that such programs both terminate and produce the correct result.  ...  (FNU) and the "Automated Verification for Concurrent Programs" Individual Postdoc Grant from The Danish Council for Independent Research for Technology and Production Sciences (FTP).  ... 
doi:10.1007/978-3-662-49498-1_8 fatcat:k7v3ffarsfb2dayts4gr5i6h6m

Supporting lock-free composition of concurrent data objects

Daniel Cederman, Philippas Tsigas
2010 Proceedings of the 15th ACM SIGPLAN symposium on Principles and practice of parallel programming - PPoPP '10  
We present a lock-free methodology for composing highly concurrent linearizable objects together by unifying their linearization points.  ...  This makes it possible to relatively easily introduce atomic lock-free move operations to a wide range of concurrent objects.  ...  As a proof of concept we show how to apply our method on two commonly used concurrent data objects, the lockfree queue by Michael and Scott [23] and the lock-free stack by Treiber [30] .  ... 
doi:10.1145/1693453.1693503 dblp:conf/ppopp/CedermanT10 fatcat:4ftrjxvohzbclfdt4vdko4aakq

Supporting lock-free composition of concurrent data objects

Daniel Cederman, Philippas Tsigas
2010 Proceedings of the 7th ACM international conference on Computing frontiers - CF '10  
We present a lock-free methodology for composing highly concurrent linearizable objects together by unifying their linearization points.  ...  This makes it possible to relatively easily introduce atomic lock-free move operations to a wide range of concurrent objects.  ...  As a proof of concept we show how to apply our method on two commonly used concurrent data objects, the lockfree queue by Michael and Scott [23] and the lock-free stack by Treiber [30] .  ... 
doi:10.1145/1787275.1787286 dblp:conf/cf/CedermanT10 fatcat:lp6rxku22bbjzcobelg3j4bpcu

Quantitative Reasoning for Proving Lock-Freedom

Jan Hoffmann, Michael Marmar, Zhong Shao
2013 2013 28th Annual ACM/IEEE Symposium on Logic in Computer Science  
Using a single formalism for verifying memory safety and lock-freedom allows a combined correctness proof that verifies both properties simultaneously.  ...  This article presents one possible formalization of this quantitative proof technique by developing a variant of concurrent separation logic (CSL) for total correctness.  ...  s lock-free stack with elimination backoff, and Michael's lock-free hazard-pointer stack ( §VII).  ... 
doi:10.1109/lics.2013.18 dblp:conf/lics/HoffmannMS13 fatcat:mm4jplyaavb3hccvi7nu3qydxe

Supporting lock-free composition of concurrent data objects

Daniel Cederman, Philippas Tsigas
2010 SIGPLAN notices  
We present a lock-free methodology for composing highly concurrent linearizable objects together by unifying their linearization points.  ...  This makes it possible to relatively easily introduce atomic lock-free move operations to a wide range of concurrent objects.  ...  As a proof of concept we show how to apply our method on two commonly used concurrent data objects, the lockfree queue by Michael and Scott [23] and the lock-free stack by Treiber [30] .  ... 
doi:10.1145/1837853.1693503 fatcat:3g54wc3s65fytkuib5shc3anlq

Supporting Lock-Free Composition of Concurrent Data Objects [article]

Daniel Cederman, Philippas Tsigas
2009 arXiv   pre-print
We present a lock-free methodology for composing highly concurrent linearizable objects together by unifying their linearization points.  ...  This makes it possible to relatively easily introduce atomic lock-free move operations to a wide range of concurrent objects.  ...  As a proof of concept we show how to apply our method on two commonly used concurrent data objects, the lock-free queue by Michael and Scott [18] and the lock-free stack by Treiber [22] .  ... 
arXiv:0910.0366v1 fatcat:momal4zaibditde55rll4r3hqe

Lock-Free Parallel Garbage Collection [chapter]

H. Gao, J. F. Groote, W. H. Hesselink
2005 Lecture Notes in Computer Science  
This paper presents a lock-free parallel algorithm for garbage collection in a realistic model using synchronization primitives offered by machine architectures.  ...  We first design and prove an algorithm with a coarse grain of atomicity and subsequently apply the reduction theorem developed in [11] to implement the higher-level atomic steps by means of the low-level  ...  The algorithm is correct if it behaves properly for all interleavings. Here we only give a sketch of the correctness of the algorithm. For the complete mechanical proof, we refer to [14] .  ... 
doi:10.1007/11576235_31 fatcat:ptizfikfkfhrbkajlzx5aj4qcq

Proving linearizability with temporal logic

Simon Bäumler, Gerhard Schellhorn, Bogdan Tofan, Wolfgang Reif
2009 Formal Aspects of Computing  
Linearizability is a correctness criterion for concurrent systems. In this report, we describe how temporal logic can be used to prove linearizability of a concurrent lock-free stack implementation.  ...  To reduce the proof to single components only a compositional reasoning technique is used.  ...  Lock-free algorithms are a class of algorithms for concurrent access to data structures. Unlike the classic mutex based algorithms lock-free algorithms require no locking.  ... 
doi:10.1007/s00165-009-0130-y fatcat:6sko4xbiu5afhbyqzib455fhva

Verifying Invariants of Lock-Free Data Structures with Rely-Guarantee and Refinement Types

Colin S. Gordon, Michael D. Ernst, Dan Grossman, Matthew J. Parkinson
2017 ACM Transactions on Programming Languages and Systems  
Second, we demonstrate the approach's broad applicability through a series of case studies, using two implementations: an axiomatic COQ domain-specific language and a library for Liquid Haskell.  ...  Third, these two implementations allow us to compare and contrast verifications by interactive proof (COQ) and a weaker form that can be expressed using automatically-discharged dependent refinement types  ...  -The first mechanized proof of invariants for a lock-free linearizable union-find [Anderson and Woll 1991] .  ... 
doi:10.1145/3064850 fatcat:bs2qkwegfjci7da3xq7eq5ixc4
« Previous Showing results 1 — 15 out of 5,192 results