research-article

Monitoring refinement via symbolic reasoning

Authors:

Constantin Enea,

Jad HamzaAuthors Info & Claims

ACM SIGPLAN Notices, Volume 50, Issue 6

Pages 260 - 269

https://doi.org/10.1145/2813885.2737983

Published: 03 June 2015 Publication History

Abstract

Efficient implementations of concurrent objects such as semaphores, locks, and atomic collections are essential to modern computing. Programming such objects is error prone: in minimizing the synchronization overhead between concurrent object invocations, one risks the conformance to reference implementations — or in formal terms, one risks violating observational refinement. Precisely testing this refinement even within a single execution is intractable, limiting existing approaches to executions with very few object invocations. We develop scalable and effective algorithms for detecting refinement violations. Our algorithms are founded on incremental, symbolic reasoning, and exploit foundational insights into the refinement-checking problem. Our approach is sound, in that we detect only actual violations, and scales far beyond existing violation-detection algorithms. Empirically, we find that our approach is practically complete, in that we detect the violations arising in actual executions.

References

[1]

P. A. Abdulla, F. Haziza, L. Hol´ık, B. Jonsson, and A. Rezine. An integrated specification and verification technique for highly concurrent data structures. In Proc. 19th International Conference on Tools and Algorithms for the Construction and Analysis of Systems (TACAS ’13), volume 7795 of LNCS, pages 324–338. Springer, 2013.

Digital Library

[2]

R. Alur, K. L. McMillan, and D. Peled. Model-checking of correctness conditions for concurrent objects. Inf. Comput., 160(1-2):167–188, 2000.

Digital Library

[3]

D. Amit, N. Rinetzky, T. W. Reps, M. Sagiv, and E. Yahav. Comparison under abstraction for verifying linearizability. In Proc. 19th International Conference on Computer Aided Verification (CAV ’07), volume 4590 of LNCS, pages 477–490. Springer, 2007.

Digital Library

[4]

A. Bouajjani, M. Emmi, C. Enea, and J. Hamza. Verifying concurrent programs against sequential specifications. In Proc. 22nd European Symposium on Programming (ESOP ’13), volume 7792 of LNCS, pages 290–309. Springer, 2013.

Digital Library

[5]

7 Technically, the axioms of this theory without our totality axiom.

[6]

A. Bouajjani, M. Emmi, C. Enea, and J. Hamza. Tractable refinement checking for concurrent objects. In Proc. 42nd Annual ACM SIGPLANSIGACT Symposium on Principles of Programming Languages (POPL ’15), pages 651–662. ACM, 2015.

Digital Library

[7]

S. Burckhardt, C. Dern, M. Musuvathi, and R. Tan. Line-up: a complete and automatic linearizability checker. In Proc. 2010 ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI ’10), pages 330–340. ACM, 2010.

Digital Library

[8]

J. Burnim, G. C. Necula, and K. Sen. Specifying and checking semantic atomicity for multithreaded programs. In Proc. 16th International Conference on Architectural Support for Programming Languages and Operating Systems (ASPLOS ’11), pages 79–90. ACM, 2011.

Digital Library

[9]

C. Dragoi, A. Gupta, and T. A. Henzinger. Automatic linearizability proofs of concurrent objects with cooperating updates. In Proc. 25th International Conference on Computer Aided Verification (CAV ’13), volume 8044 of LNCS, pages 174–190. Springer, 2013.

Digital Library

[10]

I. Filipovic, P. W. O’Hearn, N. Rinetzky, and H. Yang. Abstraction for concurrent objects. Theor. Comput. Sci., 411(51-52):4379–4398, 2010.

Digital Library

[11]

P. B. Gibbons and E. Korach. Testing shared memories. SIAM J. Comput., 26(4):1208–1244, 1997.

Digital Library

[12]

T. A. Henzinger, A. Sezgin, and V. Vafeiadis. Aspect-oriented linearizability proofs. In Proc. 24th International Conference on Concurrency Theory (CONCUR ’13), volume 8052 of LNCS, pages 242–256. Springer, 2013.

Digital Library

[13]

M. Herlihy and J. M. Wing. Linearizability: A correctness condition for concurrent objects. ACM Trans. Program. Lang. Syst., 12(3):463–492, 1990.

Digital Library

[14]

C. M. Kirsch, M. Lippautz, and H. Payer. Fast and scalable, lock-free k-FIFO queues. In Proc. 12th International Conference on Parallel Computing Technologies (PaCT 13), volume 7979 of LNCS, pages 208–223. Springer, 2013.

[15]

Y. Liu, W. Chen, Y. A. Liu, and J. Sun. Model checking linearizability via refinement. In Proc. Second World Congress on Formal Methods (FM ’09), volume 5850 of LNCS, pages 321–337. Springer, 2009.

Digital Library

[16]

M. M. Michael. ABA prevention using single-word instructions. Technical Report RC 23089, IBM Thomas J. Watson Research Center, January 2004.

[17]

M. M. Michael and M. L. Scott. Simple, fast, and practical nonblocking and blocking concurrent queue algorithms. In Proc. Fifteenth Annual ACM Symposium on Principles of Distributed Computing (PODC ’96), pages 267–275. ACM, 1996.

Digital Library

[18]

P. W. O’Hearn, N. Rinetzky, M. T. Vechev, E. Yahav, and G. Yorsh. Verifying linearizability with hindsight. In Proc. 29th Annual ACM Symposium on Principles of Distributed Computing (PODC ’10), pages 85–94. ACM, 2010.

Digital Library

[19]

O. Shacham, N. G. Bronson, A. Aiken, M. Sagiv, M. T. Vechev, and E. Yahav. Testing atomicity of composed concurrent operations. In Proc. 26th Annual ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA ’11), pages 51–64. ACM, 2011.

Digital Library

[20]

R. Treiber. Systems programming: Coping with parallelism. Technical Report RJ5118, IBM Almaden Res. Ctr., 1986.

[21]

V. Vafeiadis. Automatically proving linearizability. In Proc. 22nd International Conference on Computer Aided Verification (CAV ’10), volume 6174 of LNCS, pages 450–464. Springer, 2010.

Digital Library

[22]

J. M. Wing and C. Gong. Testing and verifying concurrent objects. J. Parallel Distrib. Comput., 17(1-2):164–182, 1993.

Digital Library

[23]

L. Zhang, A. Chattopadhyay, and C. Wang. Round-up: Runtime checking quasi linearizability of concurrent data structures. In 28th IEEE/ACM International Conference on Automated Software Engineering (ASE ’13), pages 4–14. IEEE, 2013.

[24]

S. J. Zhang. Scalable automatic linearizability checking. In Proc. 33rd International Conference on Software Engineering (ICSE ’11), pages 1185–1187. ACM, 2011.

Digital Library

Cited By

Cook VPeterson CPainter ZDechev D(2022)Quantifiability: a concurrent correctness condition modeled in vector spaceComputing10.1007/s00607-022-01092-3105:5(955-978)Online publication date: 7-Jun-2022
https://doi.org/10.1007/s00607-022-01092-3
Peterson CCook VDechev D(2021)Concurrent Correctness in Vector SpaceVerification, Model Checking, and Abstract Interpretation10.1007/978-3-030-67067-2_8(151-173)Online publication date: 12-Jan-2021
https://doi.org/10.1007/978-3-030-67067-2_8
Zhang ZWu PZhang Y(2017)Localization of Linearizability Faults on the Coarse-Grained LevelInternational Journal of Software Engineering and Knowledge Engineering10.1142/S021819401740007127:09n10(1483-1505)Online publication date: Nov-2017
https://doi.org/10.1142/S0218194017400071
Show More Cited By

Index Terms

Monitoring refinement via symbolic reasoning
1. Theory of computation
  1. Logic
  2. Semantics and reasoning
    1. Program reasoning

Recommendations

Monitoring refinement via symbolic reasoning
PLDI '15: Proceedings of the 36th ACM SIGPLAN Conference on Programming Language Design and Implementation

Efficient implementations of concurrent objects such as semaphores, locks, and atomic collections are essential to modern computing. Programming such objects is error prone: in minimizing the synchronization overhead between concurrent object ...
Tractable Refinement Checking for Concurrent Objects
POPL '15: Proceedings of the 42nd Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages

Efficient implementations of concurrent objects such as semaphores, locks, and atomic collections are essential to modern computing. Yet programming such objects is error prone: in minimizing the synchronization overhead between concurrent object ...
Verifying Linearizability via Optimized Refinement Checking

Linearizability is an important correctness criterion for implementations of concurrent objects. Automatic checking of linearizability is challenging because it requires checking that: 1) All executions of concurrent operations are serializable, and 2) ...

Comments

Information & Contributors

Information

Published In

cover image ACM SIGPLAN Notices

ACM SIGPLAN Notices Volume 50, Issue 6

PLDI '15

June 2015

630 pages

ISSN:0362-1340

EISSN:1558-1160

DOI:10.1145/2813885

Editor:
Andy Gill
University of Kansas, Lawrence, KS

Issue’s Table of Contents

PLDI '15: Proceedings of the 36th ACM SIGPLAN Conference on Programming Language Design and Implementation
June 2015
630 pages
ISBN:9781450334686
DOI:10.1145/2737924
General Chair:
David Grove
IBM Research, USA
,
Program Chair:
Steve Blackburn
Australian National University, Australia

Copyright © 2015 ACM.

Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. Copyrights for components of this work owned by others than the author(s) must be honored. Abstracting with credit is permitted. To copy otherwise, or republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee. Request permissions from [email protected].

Publisher

Association for Computing Machinery

New York, NY, United States

Publication History

Published: 03 June 2015

Published in SIGPLAN Volume 50, Issue 6

Check for updates

Author Tags

Qualifiers

Research-article

Funding Sources

Contributors

Other Metrics

View Article Metrics

Bibliometrics & Citations

Bibliometrics

Article Metrics

19
Total Citations
View Citations
288
Total Downloads

Downloads (Last 12 months)23
Downloads (Last 6 weeks)6

Reflects downloads up to 17 Feb 2025

Other Metrics

View Author Metrics

Citations

Cited By

Cook VPeterson CPainter ZDechev D(2022)Quantifiability: a concurrent correctness condition modeled in vector spaceComputing10.1007/s00607-022-01092-3105:5(955-978)Online publication date: 7-Jun-2022
https://doi.org/10.1007/s00607-022-01092-3
Peterson CCook VDechev D(2021)Concurrent Correctness in Vector SpaceVerification, Model Checking, and Abstract Interpretation10.1007/978-3-030-67067-2_8(151-173)Online publication date: 12-Jan-2021
https://doi.org/10.1007/978-3-030-67067-2_8
Zhang ZWu PZhang Y(2017)Localization of Linearizability Faults on the Coarse-Grained LevelInternational Journal of Software Engineering and Knowledge Engineering10.1142/S021819401740007127:09n10(1483-1505)Online publication date: Nov-2017
https://doi.org/10.1142/S0218194017400071
Nagar KSahoo AChowdhury RJagannathan S(2024)Automated Robustness Verification of Concurrent Data Structure Libraries against Relaxed Memory ModelsProceedings of the ACM on Programming Languages10.1145/36898028:OOPSLA2(2578-2605)Online publication date: 8-Oct-2024
https://dl.acm.org/doi/10.1145/3689802
Jia QLv YWu PZhan BHao JYe HWang C(2023)VeriLin: A Linearizability Checker for Large-Scale Concurrent ObjectsTheoretical Aspects of Software Engineering10.1007/978-3-031-35257-7_12(202-220)Online publication date: 27-Jun-2023
https://doi.org/10.1007/978-3-031-35257-7_12
Zennou RBiswas RBouajjani AEnea CErradi M(2021)Checking causal consistency of distributed databasesComputing10.1007/s00607-021-00911-3104:10(2181-2201)Online publication date: 9-Feb-2021
https://doi.org/10.1007/s00607-021-00911-3
Çirisci BEnea CFarzan AMutluergil S(2020)Root Causing Linearizability ViolationsComputer Aided Verification10.1007/978-3-030-53288-8_17(350-375)Online publication date: 14-Jul-2020
https://doi.org/10.1007/978-3-030-53288-8_17
Nagar KMukherjee PJagannathan S(2020)Semantics, Specification, and Bounded Verification of Concurrent Libraries in Replicated SystemsComputer Aided Verification10.1007/978-3-030-53288-8_13(251-274)Online publication date: 14-Jul-2020
https://doi.org/10.1007/978-3-030-53288-8_13
Ozkan BMajumdar RNiksic FHollingsworth JKeidar I(2019)Checking linearizability using hitting familiesProceedings of the 24th Symposium on Principles and Practice of Parallel Programming10.1145/3293883.3295726(366-377)Online publication date: 16-Feb-2019
https://dl.acm.org/doi/10.1145/3293883.3295726
Meyer RWolff S(2019)Decoupling lock-free data structures from memory reclamation for static analysisProceedings of the ACM on Programming Languages10.1145/32903713:POPL(1-31)Online publication date: 2-Jan-2019
https://dl.acm.org/doi/10.1145/3290371
Show More Cited By

View Options

Login options

Check if you have access through your login credentials or your institution to get full access on this article.

Full Access

Get this Publication

View options

PDF

View or Download as a PDF file.

eReader

View online with eReader.

Figures

Tables

Media

View Issue’s Table of Contents