Nothing Special   »   [go: up one dir, main page]

skip to main content
research-article

Predicate RCU: an RCU for scalable concurrent updates

Published: 24 January 2015 Publication History

Abstract

Read-copy update (RCU) is a shared memory synchronization mechanism with scalable synchronization-free reads that nevertheless execute correctly with concurrent updates. To guarantee the consistency of such reads, an RCU update transitioning the data structure between certain states must wait for the completion of all existing reads. Unfortunately, these waiting periods quickly become a bottleneck, and thus RCU remains unused in data structures that require scalable, fine-grained, update operations. To solve this problem, we present Predicate RCU (PRCU), an RCU variant in which an update waits only for the reads whose consistency it affects, which are specified by a user-supplied predicate. We explore the trade-offs in implementing PRCU, describing implementations that reduce wait times by 10--100x with varying overhead on reads on modern x86 multiprocessor machines. We demonstrate the applicability of PRCU by applying it to two RCU-based concurrent algorithms---the Citrus binary search tree and a resizable hash table---and show experimentally that PRCU significantly improves the performance of both algorithms.

References

[1]
Intel 64 and IA-32 Architectures Software Developers Manual, Volume 3: System Programming Guide, June 2013.
[2]
M. Arbel and H. Attiya. Concurrent Updates with RCU: Search Tree As an Example. In PODC, 2014.
[3]
N. G. Bronson, J. Casper, H. Chafi, and K. Olukotun. A Practical Concurrent Binary Search Tree. In PPoPP, 2010.
[4]
A. T. Clements, M. F. Kaashoek, and N. Zeldovich. Scalable Address Spaces Using RCU Balanced Trees. In ASPLOS, 2012.
[5]
P. J. Courtois, F. Heymans, and D. L. Parnas. Concurrent Control with “Readers” and “Writers”. CACM, 14(10), Oct. 1971.
[6]
M. Desnoyers, P. E. McKenney, A. S. Stern, M. R. Dagenais, and J. Walpole. User-Level Implementations of Read-Copy Update. IEEE TPDS, 23(2), 2012.
[7]
D. Dice, O. Shalev, and N. Shavit. Transactional locking II. In DISC, 2006.
[8]
K. P. Eswaran, J. N. Gray, R. A. Lorie, and I. L. Traiger. The Notions of Consistency and Predicate Locks in a Database System. CACM, 19 (11), Nov. 1976.
[9]
K. Fraser. Practical lock-freedom. PhD thesis, University of Cambridge, Computer Laboratory, February 2004.
[10]
A. Gotsman, N. Rinetzky, and H. Yang. Verifying concurrent memory reclamation algorithms with grace. In ESOP, 2013.
[11]
D. Guniguntala, P. E. McKenney, J. Triplett, and J. Walpole. The read-copy-update mechanism for supporting real-time applications on shared-memory multiprocessor systems with Linux. IBM Systems Journal, 47(2):221–236, May 2008.
[12]
S. Heller, M. Herlihy, V. Luchangco, M. Moir, W. N. Scherer, and N. Shavit. A lazy concurrent list-based set algorithm. In OPODIS, 2006.
[13]
M. Herlihy. Wait-free synchronization. ACM TOPLAS, 13(1):124– 149, Jan. 1991.
[14]
M. Herlihy and J. E. B. Moss. Transactional memory: architectural support for lock-free data structures. In ISCA, 1993.
[15]
M. Herlihy and N. Shavit. The Art of Multiprocessor Programming. Morgan Kaufmann Publishers Inc., 2008.
[16]
P. W. Howard and J. Walpole. Relativistic red-black trees. Concurrency and Computation: Practice and Experience, 2013.
[17]
S. V. Howley and J. Jones. A Non-blocking Internal Binary Search Tree. In SPAA, 2012.
[18]
Y. Liu, V. Luchangco, and M. Spear. Mindicators: A Scalable Approach to Quiescence. In ICDCS, 2013.
[19]
P. E. McKenney. Sleepable RCU. http://lwn.net/Articles/ 202847/, October 2006. Linux World News.
[20]
P. E. McKenney. Hierarchical RCU. http://lwn.net/Articles/ 305782/, November 2008. Linux World News.
[21]
P. E. McKenney and J. D. Slingwine. Read-copy update: Using execution history to solve concurrency problems. In Parallel and Distributed Computing and Systems, 1998.
[22]
P. E. McKenney, H. J. Boehm, and L. Crowl. C++ Data-Dependency Ordering: Atomics and Memory Model. Technical Report N2664, ISO/IEC JTC1 SC22 WG21, 2008.
[23]
T. Nakaike and M. M. Michael. Lock Elision for Read-only Critical Sections in Java. In PLDI, 2010.
[24]
A. Natarajan and N. Mittal. Fast Concurrent Lock-free Binary Search Trees. In PPoPP, 2014.
[25]
S. Owens, S. Sarkar, and P. Sewell. A Better x86 Memory Model: X86-TSO. In TPHOLs, 2009.
[26]
W. Ruan, Y. Liu, and M. Spear. Boosting Timestamp-based Transactional Memory by Exploiting Hardware Cycle Counters. ACM TACO, 10(4), Dec. 2013.
[27]
J. Triplett, P. E. McKenney, and J. Walpole. Resizable, scalable, concurrent hash tables via relativistic programming. In USENIX ATC, 2011.

Cited By

View all
  • (2020)RCU Usage In the Linux KernelACM SIGOPS Operating Systems Review10.1145/3421473.342148154:1(47-63)Online publication date: 31-Aug-2020
  • (2015)Pattern-based synthesis of synchronization for the C++ memory model2015 Formal Methods in Computer-Aided Design (FMCAD)10.1109/FMCAD.2015.7542261(120-127)Online publication date: Sep-2015
  • (2023)Opportunities and Limitations of Hardware Timestamps in Concurrent Data Structures2023 IEEE International Parallel and Distributed Processing Symposium (IPDPS)10.1109/IPDPS54959.2023.00068(624-634)Online publication date: May-2023
  • Show More Cited By

Recommendations

Comments

Please enable JavaScript to view thecomments powered by Disqus.

Information & Contributors

Information

Published In

cover image ACM SIGPLAN Notices
ACM SIGPLAN Notices  Volume 50, Issue 8
PPoPP '15
August 2015
290 pages
ISSN:0362-1340
EISSN:1558-1160
DOI:10.1145/2858788
  • Editor:
  • Andy Gill
Issue’s Table of Contents
  • cover image ACM Conferences
    PPoPP 2015: Proceedings of the 20th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming
    January 2015
    290 pages
    ISBN:9781450332057
    DOI:10.1145/2688500
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: 24 January 2015
Published in SIGPLAN Volume 50, Issue 8

Check for updates

Author Tags

  1. Concurrent data structures
  2. RCU
  3. Synchronization

Qualifiers

  • Research-article

Funding Sources

Contributors

Other Metrics

Bibliometrics & Citations

Bibliometrics

Article Metrics

  • Downloads (Last 12 months)22
  • Downloads (Last 6 weeks)4
Reflects downloads up to 21 Nov 2024

Other Metrics

Citations

Cited By

View all
  • (2020)RCU Usage In the Linux KernelACM SIGOPS Operating Systems Review10.1145/3421473.342148154:1(47-63)Online publication date: 31-Aug-2020
  • (2015)Pattern-based synthesis of synchronization for the C++ memory model2015 Formal Methods in Computer-Aided Design (FMCAD)10.1109/FMCAD.2015.7542261(120-127)Online publication date: Sep-2015
  • (2023)Opportunities and Limitations of Hardware Timestamps in Concurrent Data Structures2023 IEEE International Parallel and Distributed Processing Symposium (IPDPS)10.1109/IPDPS54959.2023.00068(624-634)Online publication date: May-2023
  • (2023)Lock-based or Lock-less: Which Is Fresh?IEEE INFOCOM 2023 - IEEE Conference on Computer Communications10.1109/INFOCOM53939.2023.10229077(1-10)Online publication date: 17-May-2023
  • (2023)Compiler‐driven approach for automating nonblocking synchronization in concurrent data abstractionsConcurrency and Computation: Practice and Experience10.1002/cpe.793536:5Online publication date: 24-Oct-2023
  • (2019)MV-RLUProceedings of the Twenty-Fourth International Conference on Architectural Support for Programming Languages and Operating Systems10.1145/3297858.3304040(779-792)Online publication date: 4-Apr-2019
  • (2019)The Real-Time Linux KernelACM Computing Surveys10.1145/329771452:1(1-36)Online publication date: 21-Feb-2019
  • (2019)Improving efficacy of concurrent internal binary search trees using local recoveryProceedings of the 20th International Conference on Distributed Computing and Networking10.1145/3288599.3288615(61-70)Online publication date: 4-Jan-2019
  • (2019)Automating non-blocking synchronization in concurrent data abstractionsProceedings of the 34th IEEE/ACM International Conference on Automated Software Engineering10.1109/ASE.2019.00074(735-747)Online publication date: 10-Nov-2019
  • (2018)Practical concurrent traversals in search treesACM SIGPLAN Notices10.1145/3200691.317850353:1(207-218)Online publication date: 10-Feb-2018
  • Show More Cited By

View Options

Login options

View options

PDF

View or Download as a PDF file.

PDF

eReader

View online with eReader.

eReader

Media

Figures

Other

Tables

Share

Share

Share this Publication link

Share on social media