research-article

Monitoring refinement via symbolic reasoning

Authors:

Constantin Enea,

Jad HamzaAuthors Info & Claims

PLDI '15: Proceedings of the 36th ACM SIGPLAN Conference on Programming Language Design and Implementation

Pages 260 - 269

https://doi.org/10.1145/2737924.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

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
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

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 ...
Monitoring refinement via symbolic reasoning
PLDI '15

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 ...
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 Conferences

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

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

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].

Sponsors

SIGPLAN: ACM Special Interest Group on Programming Languages

Publisher

Association for Computing Machinery

New York, NY, United States

Publication History

Published: 03 June 2015

Permissions

Request permissions for this article.

Request Permissions

Check for updates

Author Tags

Qualifiers

Research-article

Funding Sources

Conference

PLDI '15

Sponsor:

SIGPLAN

PLDI '15: ACM SIGPLAN Conference on Programming Language Design and Implementation

June 13 - 17, 2015

OR, Portland, USA

Acceptance Rates

Overall Acceptance Rate 406 of 2,067 submissions, 20%

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 15 Feb 2025

Other Metrics

View Author Metrics

Citations

Cited By

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
Zennou RBiswas RBouajjani AEnea CErradi M(2019)Checking Causal Consistency of Distributed DatabasesNetworked Systems10.1007/978-3-030-31277-0_3(35-51)Online publication date: 14-Sep-2019
https://doi.org/10.1007/978-3-030-31277-0_3
Emmi MEnea C(2019)Violat: Generating Tests of Observational Refinement for Concurrent ObjectsComputer Aided Verification10.1007/978-3-030-25543-5_30(534-546)Online publication date: 12-Jul-2019
https://doi.org/10.1007/978-3-030-25543-5_30
Biswas REmmi MEnea C(2019)On the Complexity of Checking Consistency for Replicated Data TypesComputer Aided Verification10.1007/978-3-030-25543-5_19(324-343)Online publication date: 12-Jul-2019
https://doi.org/10.1007/978-3-030-25543-5_19
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 Table of Conten