RRR-SMR: Reduce, Reuse, Recycle: Better Methods for Practical Lock-Free Data Structures
Traditionally, most concurrent algorithms rely on safe memory reclamation (SMR) schemes for manual memory management. SMR schemes such as epoch-based reclamation (EBR) and hazard pointers (HP) are typically viewed as the only solution for memory recycling. When using SMR, a new object needs to be al...
Uloženo v:
| Vydáno v: | Proceedings of ACM on programming languages Ročník 9; číslo PLDI; s. 2156 - 2179 |
|---|---|
| Hlavní autoři: | , |
| Médium: | Journal Article |
| Jazyk: | angličtina |
| Vydáno: |
New York, NY, USA
ACM
10.06.2025
|
| Témata: | |
| ISSN: | 2475-1421, 2475-1421 |
| On-line přístup: | Získat plný text |
| Tagy: |
Přidat tag
Žádné tagy, Buďte první, kdo vytvoří štítek k tomuto záznamu!
|
| Abstract | Traditionally, most concurrent algorithms rely on safe memory reclamation (SMR) schemes for manual memory management. SMR schemes such as epoch-based reclamation (EBR) and hazard pointers (HP) are typically viewed as the only solution for memory recycling. When using SMR, a new object needs to be allocated whenever something new is added to a data structure. However, in more complex scenarios, the same object may need to be moved between different data structures (e.g., moving a node from one list to another, and then back to the original list) in a copy-free manner, i.e., without deallocating and allocating the node again. It is typically impossible for two reasons: (1) the ABA problem would still arise even when using SMR since the same pointer can reappear (without going through the full SMR cycle) if the same node eventually ends up back in the original data structure; (2) while in simple queues and stacks, nodes can immediately be recycled, it is unclear how to adapt data structures which use non-trivial traversal and two-phase deletion strategies, e.g., linked lists, skip lists, hash tables, trees, etc., where it is seemingly impossible to always immediately move (logically) deleted objects since they might still be accessed by other threads. We propose a general method of creating RRR (Reduce, Reuse, Recycle) data structures to allow safe memory recycling when using SMR which addresses the above-mentioned problems. Our method is applicable to linked lists, skip lists, hash tables, Natarajan-Mittal tree, and other data structures. We also discuss and propose a specialized approach -- a more efficient version of Michael-and-Scott's (recycling) queue. Our evaluation on x86-64 shows promising results when using our methods for different data structures and SMR schemes. |
|---|---|
| AbstractList | Traditionally, most concurrent algorithms rely on safe memory reclamation (SMR) schemes for manual memory management. SMR schemes such as epoch-based reclamation (EBR) and hazard pointers (HP) are typically viewed as the only solution for memory recycling. When using SMR, a new object needs to be allocated whenever something new is added to a data structure. However, in more complex scenarios, the same object may need to be moved between different data structures (e.g., moving a node from one list to another, and then back to the original list) in a copy-free manner, i.e., without deallocating and allocating the node again. It is typically impossible for two reasons: (1) the ABA problem would still arise even when using SMR since the same pointer can reappear (without going through the full SMR cycle) if the same node eventually ends up back in the original data structure; (2) while in simple queues and stacks, nodes can immediately be recycled, it is unclear how to adapt data structures which use non-trivial traversal and two-phase deletion strategies, e.g., linked lists, skip lists, hash tables, trees, etc., where it is seemingly impossible to always immediately move (logically) deleted objects since they might still be accessed by other threads. We propose a general method of creating RRR (Reduce, Reuse, Recycle) data structures to allow safe memory recycling when using SMR which addresses the above-mentioned problems. Our method is applicable to linked lists, skip lists, hash tables, Natarajan-Mittal tree, and other data structures. We also discuss and propose a specialized approach -- a more efficient version of Michael-and-Scott's (recycling) queue. Our evaluation on x86-64 shows promising results when using our methods for different data structures and SMR schemes. Traditionally, most concurrent algorithms rely on safe memory reclamation (SMR) schemes for manual memory management. SMR schemes such as epoch-based reclamation (EBR) and hazard pointers (HP) are typically viewed as the only solution for memory recycling. When using SMR, a new object needs to be allocated whenever something new is added to a data structure. However, in more complex scenarios, the same object may need to be moved between different data structures (e.g., moving a node from one list to another, and then back to the original list) in a copy-free manner, i.e., without deallocating and allocating the node again. It is typically impossible for two reasons: (1) the ABA problem would still arise even when using SMR since the same pointer can reappear (without going through the full SMR cycle) if the same node eventually ends up back in the original data structure; (2) while in simple queues and stacks, nodes can immediately be recycled, it is unclear how to adapt data structures which use non-trivial traversal and two-phase deletion strategies, e.g., linked lists, skip lists, hash tables, trees, etc., where it is seemingly impossible to always immediately move (logically) deleted objects since they might still be accessed by other threads. We propose a general method of creating RRR (Reduce, Reuse, Recycle) data structures to allow safe memory recycling when using SMR which addresses the above-mentioned problems. Our method is applicable to linked lists, skip lists, hash tables, Natarajan-Mittal tree, and other data structures. We also discuss and propose a specialized approach -- a more efficient version of Michael-and-Scott's (recycling) queue. Our evaluation on x86-64 shows promising results when using our methods for different data structures and SMR schemes. |
| ArticleNumber | 234 |
| Author | Arovi, Md Amit Hasan Nikolaev, Ruslan |
| Author_xml | – sequence: 1 givenname: Md Amit Hasan orcidid: 0009-0009-4341-1954 surname: Arovi fullname: Arovi, Md Amit Hasan email: arovi@psu.edu organization: Pennsylvania State University, University Park, USA – sequence: 2 givenname: Ruslan orcidid: 0000-0002-1699-0593 surname: Nikolaev fullname: Nikolaev, Ruslan email: rnikola@psu.edu organization: Pennsylvania State University, University Park, USA |
| BookMark | eNpNkEFPAjEUhBuDiYjEu6fevLja7tvaLTcFUROIZtF43Dzb14gCa9rugX8vChpP3yTzZQ5zyDqrZkWMHUtxLmWhLkDnBkDvsW5eaJXJIpedf_mA9WN8F0JIA0UJpsteqqrKZtNqwCtyraWzDdv4A7u2Cxrwa0qJAp9Semtc5L4J_DGgTXOLCz5p7Ec2DkR8hAn5LIXWpjZQPGL7HheR-jv22PP45ml4l00ebu-HV5MMpbrUmQdjCwXeOG-0NORkCa4EKiwgSIUISiiPprR5KXIt7CspCUaWTjrUGqHHTre7NjQxBvL1Z5gvMaxrKervS-rdJRvzZGuiXf5Jv-UX5dhapA |
| Cites_doi | 10.1145/248052.248106 10.5281/zenodo.15258497 10.1145/3087556.3087588 10.1145/2767386.2767436 10.1145/3385412.3385978 10.1145/2555243.2555256 10.1145/564870.564881 10.1145/3332466.3374540 10.1145/3381052.3381316 10.1145/3519939.3523730 10.1145/3276513 10.1145/3437801.3441625 10.1145/3178487.3178488 10.1145/3453483.3454060 10.1145/3503221.3508433 10.1145/3656383 10.1145/3658851 10.1109/TPDS.2004.8 10.5555/645958.676105 10.1145/3453483.3454090 10.1145/3558481.3591102 10.1145/3409964.3461817 10.1145/3437801.3441596 10.1016/j.jpdc.2007.04.010 |
| ContentType | Journal Article |
| Copyright | Owner/Author |
| Copyright_xml | – notice: Owner/Author |
| DBID | AAYXX CITATION |
| DOI | 10.1145/3729337 |
| DatabaseName | CrossRef |
| DatabaseTitle | CrossRef |
| DatabaseTitleList | CrossRef |
| DeliveryMethod | fulltext_linktorsrc |
| Discipline | Computer Science |
| EISSN | 2475-1421 |
| EndPage | 2179 |
| ExternalDocumentID | 10_1145_3729337 3729337 |
| GroupedDBID | AAKMM AAYFX ACM AEFXT AEJOY AIKLT AKRVB ALMA_UNASSIGNED_HOLDINGS GUFHI LHSKQ M~E OK1 ROL AAYXX CITATION |
| ID | FETCH-LOGICAL-a1567-f39c453f9df9719ed183d83e4c3a315aa3505fa98c280270cbe513918d1da77a3 |
| ISSN | 2475-1421 |
| IngestDate | Sat Nov 29 07:43:35 EST 2025 Mon Aug 18 16:40:35 EDT 2025 |
| IsDoiOpenAccess | true |
| IsOpenAccess | true |
| IsPeerReviewed | true |
| IsScholarly | true |
| Issue | PLDI |
| Keywords | ABA epoch-based reclamation non-blocking hazard pointers |
| Language | English |
| License | This work is licensed under Creative Commons Attribution International 4.0. |
| LinkModel | OpenURL |
| MergedId | FETCHMERGED-LOGICAL-a1567-f39c453f9df9719ed183d83e4c3a315aa3505fa98c280270cbe513918d1da77a3 |
| ORCID | 0000-0002-1699-0593 0009-0009-4341-1954 |
| OpenAccessLink | https://dl.acm.org/doi/10.1145/3729337 |
| PageCount | 24 |
| ParticipantIDs | crossref_primary_10_1145_3729337 acm_primary_3729337 |
| PublicationCentury | 2000 |
| PublicationDate | 20250610 2025-06-10 |
| PublicationDateYYYYMMDD | 2025-06-10 |
| PublicationDate_xml | – month: 06 year: 2025 text: 20250610 day: 10 |
| PublicationDecade | 2020 |
| PublicationPlace | New York, NY, USA |
| PublicationPlace_xml | – name: New York, NY, USA |
| PublicationTitle | Proceedings of ACM on programming languages |
| PublicationTitleAbbrev | ACM PACMPL |
| PublicationYear | 2025 |
| Publisher | ACM |
| Publisher_xml | – name: ACM |
| References | Naama Ben-David, Guy E. Blelloch, and Yuanhao Wei. 2022. Lock-free locks revisited. In Proceedings of the 27th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming (PPoPP ’22). Association for Computing Machinery, New York, NY, USA. 278–293. isbn:9781450392044 https://doi.org/10.1145/3503221.3508433 10.1145/3503221.3508433 Ajay Singh, Trevor Brown, and Ali Mashtizadeh. 2021. NBR: neutralization based reclamation. In Proceedings of the 26th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming (PPoPP ’21). Association for Computing Machinery, New York, NY, USA. 175–190. isbn:9781450382946 https://doi.org/10.1145/3437801.3441625 10.1145/3437801.3441625 Nachshon Cohen. 2018. Every data structure deserves lock-free memory reclamation. Proc. ACM Program. Lang., 2, OOPSLA (2018), Article 143, oct, 24 pages. https://doi.org/10.1145/3276513 10.1145/3276513 Jaehwang Jung, Jeonghyeon Kim, Matthew J. Parkinson, and Jeehoon Kang. 2024. Concurrent Immediate Reference Counting. Proc. ACM Program. Lang., 8, PLDI (2024), Article 153, June, 24 pages. https://doi.org/10.1145/3656383 10.1145/3656383 Maurice Herlihy and Nir Shavit. 2012. The Art of Multiprocessor Programming, Revised Reprint (1st ed.). Morgan Kaufmann Publishers Inc., San Francisco, CA, USA. isbn:9780123973375 Trevor Alexander Brown. 2015. Reclaiming Memory for Lock-Free Data Structures: There has to be a Better Way. In Proceedings of the 2015 ACM Symposium on Principles of Distributed Computing (PODC ’15). Association for Computing Machinery, New York, NY, USA. 261–270. isbn:9781450336178 https://doi.org/10.1145/2767386.2767436 10.1145/2767386.2767436 Keir Fraser. 2004. Practical lock-freedom. Univ. of Cambridge, Computer Laboratory. http://www.cl.cam.ac.uk/techreports/UCAM-CL-TR-579.pdf MIPS. 2016. MIPS32/MIPS64 Rev. 6.06. http://www.mips.com/products/architectures Andreia Correia, Pedro Ramalhete, and Pascal Felber. 2021. OrcGC: Automatic Lock-Free Memory Reclamation. In Proceedings of the 26th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming (PPoPP ’21). ACM, 205–218. isbn:9781450382946 https://doi.org/10.1145/3437801.3441596 10.1145/3437801.3441596 Maged M. Michael. 2002. High performance dynamic lock-free hash tables and list-based sets. In Proceedings of the Fourteenth Annual ACM Symposium on Parallel Algorithms and Architectures (SPAA ’02). Association for Computing Machinery, New York, NY, USA. 73–82. isbn:1581135297 https://doi.org/10.1145/564870.564881 10.1145/564870.564881 Maged M. Michael. 2004. Hazard pointers: safe memory reclamation for lock-free objects. IEEE Transactions on Parallel and Distributed Systems, 15, 6 (2004), June, 491–504. issn:1045-9219 https://doi.org/10.1109/TPDS.2004.8 10.1109/TPDS.2004.8 Gali Sheffi, Maurice Herlihy, and Erez Petrank. 2021. VBR: Version Based Reclamation. In Proceedings of the 33rd ACM Symposium on Parallelism in Algorithms and Architectures (SPAA ’21). Association for Computing Machinery, New York, NY, USA. 443–445. isbn:9781450380706 https://doi.org/10.1145/3409964.3461817 10.1145/3409964.3461817 Microsoft. 2024. Mimalloc allocator. https://github.com/microsoft/mimalloc Ruslan Nikolaev and Binoy Ravindran. 2024. A Family of Fast and Memory Efficient Lock- and Wait-Free Reclamation. Proc. ACM Program. Lang., 8, PLDI (2024), Article 235, June, 25 pages. https://doi.org/10.1145/3658851 10.1145/3658851 IBM. 2005. PowerPC Architecture Book, Version 2.02. Book I: PowerPC User Instruction Set Architecture. http://www.ibm.com/developerworks Intel. 2024. Intel 64 and IA-32 Architectures Developer’s Manual. http://www.intel.com Ruslan Nikolaev, Mincheol Sung, and Binoy Ravindran. 2020. LibrettOS: a dynamically adaptable multiserver-library OS. In Proceedings of the 16th ACM SIGPLAN/SIGOPS International Conference on Virtual Execution Environments (VEE ’20). Association for Computing Machinery, New York, NY, USA. 114–128. isbn:9781450375542 https://doi.org/10.1145/3381052.3381316 10.1145/3381052.3381316 Thomas E. Hart, Paul E. McKenney, Angela Demke Brown, and Jonathan Walpole. 2007. Performance of memory reclamation for lockless synchronization. J. Parallel and Distrib. Comput., 67, 12 (2007), 1270 – 1285. issn:0743-7315 https://doi.org/10.1016/j.jpdc.2007.04.010 10.1016/j.jpdc.2007.04.010 Ruslan Nikolaev and Binoy Ravindran. 2020. Universal wait-free memory reclamation. In Proceedings of the 25th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming (PPoPP ’20). Association for Computing Machinery, New York, NY, USA. 130–143. isbn:9781450368186 https://doi.org/10.1145/3332466.3374540 10.1145/3332466.3374540 Daniel Anderson, Guy E. Blelloch, and Yuanhao Wei. 2021. Concurrent deferred reference counting with constant-time overhead. In Proceedings of the 42nd ACM SIGPLAN International Conference on Programming Language Design and Implementation (PLDI 2021). Association for Computing Machinery, New York, NY, USA. 526–541. isbn:9781450383912 https://doi.org/10.1145/3453483.3454060 10.1145/3453483.3454060 Md Amit Hasan Arovi and Ruslan Nikolaev. 2025. Fixing non-blocking data structures for better compatibility with memory reclamation schemes. arxiv:2504.06254. arxiv:2504.06254 Pedro Ramalhete and Andreia Correia. 2017. Brief Announcement: Hazard Eras - Non-Blocking Memory Reclamation. In Proceedings of the 29th ACM Symposium on Parallelism in Algorithms and Architectures (SPAA ’17). Association for Computing Machinery, New York, NY, USA. 367–369. isbn:9781450345934 https://doi.org/10.1145/3087556.3087588 10.1145/3087556.3087588 Haosen Wen, Joseph Izraelevitz, Wentao Cai, H. Alan Beadle, and Michael L. Scott. 2018. Interval-based memory reclamation. In Proceedings of the 23rd ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming (PPoPP ’18). Association for Computing Machinery, New York, NY, USA. 1–13. isbn:9781450349826 https://doi.org/10.1145/3178487.3178488 10.1145/3178487.3178488 Microsoft. 2021. Windows App Development: Interlocked Singly Linked Lists. https://learn.microsoft.com/en-us/windows/win32/sync/interlocked-singly-linked-lists Jaehwang Jung, Janggun Lee, Jeonghyeon Kim, and Jeehoon Kang. 2023. Applying Hazard Pointers to More Concurrent Data Structures. In Proceedings of the 35th ACM Symposium on Parallelism in Algorithms and Architectures (SPAA ’23). Association for Computing Machinery, New York, NY, USA. 213–226. isbn:9781450395458 https://doi.org/10.1145/3558481.3591102 10.1145/3558481.3591102 ARM. 2024. ARM Architecture Reference Manual. http://developer.arm.com Ruslan Nikolaev and Binoy Ravindran. 2021. Snapshot-free, transparent, and robust memory reclamation for lock-free data structures. In Proceedings of the 42nd ACM SIGPLAN International Conference on Programming Language Design and Implementation (PLDI 2021). Association for Computing Machinery, New York, NY, USA. 987–1002. isbn:9781450383912 https://doi.org/10.1145/3453483.3454090 10.1145/3453483.3454090 R. K. Treiber. 1986. Systems Programming: Coping with Parallelism.. IBM Almaden Research Center. Daniel Anderson, Guy E. Blelloch, and Yuanhao Wei. 2022. Turning manual concurrent memory reclamation into automatic reference counting. In Proceedings of the 43rd ACM SIGPLAN International Conference on Programming Language Design and Implementation (PLDI 2022). Association for Computing Machinery, New York, NY, USA. 61–75. isbn:9781450392655 https://doi.org/10.1145/3519939.3523730 10.1145/3519939.3523730 Aravind Natarajan and Neeraj Mittal. 2014. Fast concurrent lock-free binary search trees. In Proceedings of the 19th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming (PPoPP ’14). Association for Computing Machinery, New York, NY, USA. 317–328. isbn:9781450326568 https://doi.org/10.1145/2555243.2555256 10.1145/2555243.2555256 Jeehoon Kang and Jaehwang Jung. 2020. A marriage of pointer- and epoch-based reclamation. In Proceedings of the 41st ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI 2020). Association for Computing Machinery, New York, NY, USA. 314–328. isbn:9781450376136 https://doi.org/10.1145/3385412.3385978 10.1145/3385412.3385978 Maged M. Michael and Michael L. Scott. 1996. Simple, fast, and practical non-blocking and blocking concurrent queue algorithms. In Proceedings of the Fifteenth Annual ACM Symposium on Principles of Distributed Computing (PODC ’96). Association for Computing Machinery, New York, NY, USA. 267–275. isbn:0897918002 https://doi.org/10.1145/248052.248106 10.1145/248052.248106 RISC-V International. 2024. Ratified Specification. https://riscv.org/specifications/ratified Md Amit Hasan Arovi and Ruslan Nikolaev. 2025. Artifact for PLDI’25. https://doi.org/10.5281/zenodo.15258497 10.5281/zenodo.15258497 Timothy L. Harris. 2001. A Pragmatic Implementation of Non-blocking Linked-Lists. In Proceedings of the 15th International Conference on Distributed Computing (DISC ’01). Springer-Verlag, Berlin, Heidelberg. 300–314. isbn:3540426051 e_1_2_2_4_1 e_1_2_2_25_1 e_1_2_2_5_1 e_1_2_2_24_1 e_1_2_2_6_1 e_1_2_2_23_1 e_1_2_2_7_1 Herlihy Maurice (e_1_2_2_13_1) e_1_2_2_22_1 e_1_2_2_21_1 e_1_2_2_1_1 e_1_2_2_20_1 e_1_2_2_2_1 e_1_2_2_3_1 e_1_2_2_9_1 e_1_2_2_29_1 e_1_2_2_8_1 e_1_2_2_28_1 e_1_2_2_27_1 e_1_2_2_26_1 IBM. (e_1_2_2_14_1) 2005; 2 e_1_2_2_12_1 e_1_2_2_11_1 e_1_2_2_10_1 e_1_2_2_30_1 e_1_2_2_31_1 e_1_2_2_19_1 e_1_2_2_32_1 e_1_2_2_18_1 e_1_2_2_33_1 Treiber R. K. (e_1_2_2_34_1) 1986 e_1_2_2_17_1 e_1_2_2_16_1 e_1_2_2_35_1 e_1_2_2_15_1 |
| References_xml | – reference: Microsoft. 2021. Windows App Development: Interlocked Singly Linked Lists. https://learn.microsoft.com/en-us/windows/win32/sync/interlocked-singly-linked-lists – reference: Md Amit Hasan Arovi and Ruslan Nikolaev. 2025. Fixing non-blocking data structures for better compatibility with memory reclamation schemes. arxiv:2504.06254. arxiv:2504.06254 – reference: Timothy L. Harris. 2001. A Pragmatic Implementation of Non-blocking Linked-Lists. In Proceedings of the 15th International Conference on Distributed Computing (DISC ’01). Springer-Verlag, Berlin, Heidelberg. 300–314. isbn:3540426051 – reference: IBM. 2005. PowerPC Architecture Book, Version 2.02. Book I: PowerPC User Instruction Set Architecture. http://www.ibm.com/developerworks/ – reference: Microsoft. 2024. Mimalloc allocator. https://github.com/microsoft/mimalloc – reference: Ruslan Nikolaev and Binoy Ravindran. 2021. Snapshot-free, transparent, and robust memory reclamation for lock-free data structures. In Proceedings of the 42nd ACM SIGPLAN International Conference on Programming Language Design and Implementation (PLDI 2021). Association for Computing Machinery, New York, NY, USA. 987–1002. isbn:9781450383912 https://doi.org/10.1145/3453483.3454090 10.1145/3453483.3454090 – reference: Ajay Singh, Trevor Brown, and Ali Mashtizadeh. 2021. NBR: neutralization based reclamation. In Proceedings of the 26th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming (PPoPP ’21). Association for Computing Machinery, New York, NY, USA. 175–190. isbn:9781450382946 https://doi.org/10.1145/3437801.3441625 10.1145/3437801.3441625 – reference: Trevor Alexander Brown. 2015. Reclaiming Memory for Lock-Free Data Structures: There has to be a Better Way. In Proceedings of the 2015 ACM Symposium on Principles of Distributed Computing (PODC ’15). Association for Computing Machinery, New York, NY, USA. 261–270. isbn:9781450336178 https://doi.org/10.1145/2767386.2767436 10.1145/2767386.2767436 – reference: ARM. 2024. ARM Architecture Reference Manual. http://developer.arm.com/ – reference: Jeehoon Kang and Jaehwang Jung. 2020. A marriage of pointer- and epoch-based reclamation. In Proceedings of the 41st ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI 2020). Association for Computing Machinery, New York, NY, USA. 314–328. isbn:9781450376136 https://doi.org/10.1145/3385412.3385978 10.1145/3385412.3385978 – reference: Md Amit Hasan Arovi and Ruslan Nikolaev. 2025. Artifact for PLDI’25. https://doi.org/10.5281/zenodo.15258497 10.5281/zenodo.15258497 – reference: Ruslan Nikolaev and Binoy Ravindran. 2024. A Family of Fast and Memory Efficient Lock- and Wait-Free Reclamation. Proc. ACM Program. Lang., 8, PLDI (2024), Article 235, June, 25 pages. https://doi.org/10.1145/3658851 10.1145/3658851 – reference: Andreia Correia, Pedro Ramalhete, and Pascal Felber. 2021. OrcGC: Automatic Lock-Free Memory Reclamation. In Proceedings of the 26th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming (PPoPP ’21). ACM, 205–218. isbn:9781450382946 https://doi.org/10.1145/3437801.3441596 10.1145/3437801.3441596 – reference: Ruslan Nikolaev, Mincheol Sung, and Binoy Ravindran. 2020. LibrettOS: a dynamically adaptable multiserver-library OS. In Proceedings of the 16th ACM SIGPLAN/SIGOPS International Conference on Virtual Execution Environments (VEE ’20). Association for Computing Machinery, New York, NY, USA. 114–128. isbn:9781450375542 https://doi.org/10.1145/3381052.3381316 10.1145/3381052.3381316 – reference: Maurice Herlihy and Nir Shavit. 2012. The Art of Multiprocessor Programming, Revised Reprint (1st ed.). Morgan Kaufmann Publishers Inc., San Francisco, CA, USA. isbn:9780123973375 – reference: Intel. 2024. Intel 64 and IA-32 Architectures Developer’s Manual. http://www.intel.com/ – reference: Naama Ben-David, Guy E. Blelloch, and Yuanhao Wei. 2022. Lock-free locks revisited. In Proceedings of the 27th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming (PPoPP ’22). Association for Computing Machinery, New York, NY, USA. 278–293. isbn:9781450392044 https://doi.org/10.1145/3503221.3508433 10.1145/3503221.3508433 – reference: R. K. Treiber. 1986. Systems Programming: Coping with Parallelism.. IBM Almaden Research Center. – reference: RISC-V International. 2024. Ratified Specification. https://riscv.org/specifications/ratified/ – reference: Maged M. Michael. 2002. High performance dynamic lock-free hash tables and list-based sets. In Proceedings of the Fourteenth Annual ACM Symposium on Parallel Algorithms and Architectures (SPAA ’02). Association for Computing Machinery, New York, NY, USA. 73–82. isbn:1581135297 https://doi.org/10.1145/564870.564881 10.1145/564870.564881 – reference: Haosen Wen, Joseph Izraelevitz, Wentao Cai, H. Alan Beadle, and Michael L. Scott. 2018. Interval-based memory reclamation. In Proceedings of the 23rd ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming (PPoPP ’18). Association for Computing Machinery, New York, NY, USA. 1–13. isbn:9781450349826 https://doi.org/10.1145/3178487.3178488 10.1145/3178487.3178488 – reference: Jaehwang Jung, Janggun Lee, Jeonghyeon Kim, and Jeehoon Kang. 2023. Applying Hazard Pointers to More Concurrent Data Structures. In Proceedings of the 35th ACM Symposium on Parallelism in Algorithms and Architectures (SPAA ’23). Association for Computing Machinery, New York, NY, USA. 213–226. isbn:9781450395458 https://doi.org/10.1145/3558481.3591102 10.1145/3558481.3591102 – reference: MIPS. 2016. MIPS32/MIPS64 Rev. 6.06. http://www.mips.com/products/architectures/ – reference: Pedro Ramalhete and Andreia Correia. 2017. Brief Announcement: Hazard Eras - Non-Blocking Memory Reclamation. In Proceedings of the 29th ACM Symposium on Parallelism in Algorithms and Architectures (SPAA ’17). Association for Computing Machinery, New York, NY, USA. 367–369. isbn:9781450345934 https://doi.org/10.1145/3087556.3087588 10.1145/3087556.3087588 – reference: Jaehwang Jung, Jeonghyeon Kim, Matthew J. Parkinson, and Jeehoon Kang. 2024. Concurrent Immediate Reference Counting. Proc. ACM Program. Lang., 8, PLDI (2024), Article 153, June, 24 pages. https://doi.org/10.1145/3656383 10.1145/3656383 – reference: Daniel Anderson, Guy E. Blelloch, and Yuanhao Wei. 2021. Concurrent deferred reference counting with constant-time overhead. In Proceedings of the 42nd ACM SIGPLAN International Conference on Programming Language Design and Implementation (PLDI 2021). Association for Computing Machinery, New York, NY, USA. 526–541. isbn:9781450383912 https://doi.org/10.1145/3453483.3454060 10.1145/3453483.3454060 – reference: Maged M. Michael. 2004. Hazard pointers: safe memory reclamation for lock-free objects. IEEE Transactions on Parallel and Distributed Systems, 15, 6 (2004), June, 491–504. issn:1045-9219 https://doi.org/10.1109/TPDS.2004.8 10.1109/TPDS.2004.8 – reference: Maged M. Michael and Michael L. Scott. 1996. Simple, fast, and practical non-blocking and blocking concurrent queue algorithms. In Proceedings of the Fifteenth Annual ACM Symposium on Principles of Distributed Computing (PODC ’96). Association for Computing Machinery, New York, NY, USA. 267–275. isbn:0897918002 https://doi.org/10.1145/248052.248106 10.1145/248052.248106 – reference: Ruslan Nikolaev and Binoy Ravindran. 2020. Universal wait-free memory reclamation. In Proceedings of the 25th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming (PPoPP ’20). Association for Computing Machinery, New York, NY, USA. 130–143. isbn:9781450368186 https://doi.org/10.1145/3332466.3374540 10.1145/3332466.3374540 – reference: Gali Sheffi, Maurice Herlihy, and Erez Petrank. 2021. VBR: Version Based Reclamation. In Proceedings of the 33rd ACM Symposium on Parallelism in Algorithms and Architectures (SPAA ’21). Association for Computing Machinery, New York, NY, USA. 443–445. isbn:9781450380706 https://doi.org/10.1145/3409964.3461817 10.1145/3409964.3461817 – reference: Daniel Anderson, Guy E. Blelloch, and Yuanhao Wei. 2022. Turning manual concurrent memory reclamation into automatic reference counting. In Proceedings of the 43rd ACM SIGPLAN International Conference on Programming Language Design and Implementation (PLDI 2022). Association for Computing Machinery, New York, NY, USA. 61–75. isbn:9781450392655 https://doi.org/10.1145/3519939.3523730 10.1145/3519939.3523730 – reference: Thomas E. Hart, Paul E. McKenney, Angela Demke Brown, and Jonathan Walpole. 2007. Performance of memory reclamation for lockless synchronization. J. Parallel and Distrib. Comput., 67, 12 (2007), 1270 – 1285. issn:0743-7315 https://doi.org/10.1016/j.jpdc.2007.04.010 10.1016/j.jpdc.2007.04.010 – reference: Nachshon Cohen. 2018. Every data structure deserves lock-free memory reclamation. Proc. ACM Program. Lang., 2, OOPSLA (2018), Article 143, oct, 24 pages. https://doi.org/10.1145/3276513 10.1145/3276513 – reference: Aravind Natarajan and Neeraj Mittal. 2014. Fast concurrent lock-free binary search trees. In Proceedings of the 19th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming (PPoPP ’14). Association for Computing Machinery, New York, NY, USA. 317–328. isbn:9781450326568 https://doi.org/10.1145/2555243.2555256 10.1145/2555243.2555256 – reference: Keir Fraser. 2004. Practical lock-freedom. Univ. of Cambridge, Computer Laboratory. http://www.cl.cam.ac.uk/techreports/UCAM-CL-TR-579.pdf – ident: e_1_2_2_21_1 doi: 10.1145/248052.248106 – ident: e_1_2_2_4_1 doi: 10.5281/zenodo.15258497 – ident: e_1_2_2_30_1 doi: 10.1145/3087556.3087588 – ident: e_1_2_2_7_1 doi: 10.1145/2767386.2767436 – ident: e_1_2_2_18_1 doi: 10.1145/3385412.3385978 – ident: e_1_2_2_25_1 doi: 10.1145/2555243.2555256 – ident: e_1_2_2_19_1 doi: 10.1145/564870.564881 – ident: e_1_2_2_26_1 doi: 10.1145/3332466.3374540 – ident: e_1_2_2_23_1 – ident: e_1_2_2_31_1 – ident: e_1_2_2_29_1 doi: 10.1145/3381052.3381316 – ident: e_1_2_2_2_1 doi: 10.1145/3519939.3523730 – ident: e_1_2_2_8_1 doi: 10.1145/3276513 – ident: e_1_2_2_15_1 – ident: e_1_2_2_33_1 doi: 10.1145/3437801.3441625 – ident: e_1_2_2_35_1 doi: 10.1145/3178487.3178488 – volume-title: Systems Programming: Coping with Parallelism. year: 1986 ident: e_1_2_2_34_1 – ident: e_1_2_2_1_1 doi: 10.1145/3453483.3454060 – ident: e_1_2_2_6_1 doi: 10.1145/3503221.3508433 – ident: e_1_2_2_16_1 doi: 10.1145/3656383 – ident: e_1_2_2_28_1 doi: 10.1145/3658851 – ident: e_1_2_2_20_1 doi: 10.1109/TPDS.2004.8 – ident: e_1_2_2_11_1 doi: 10.5555/645958.676105 – ident: e_1_2_2_27_1 doi: 10.1145/3453483.3454090 – ident: e_1_2_2_3_1 – volume: 2 start-page: 02 year: 2005 ident: e_1_2_2_14_1 article-title: PowerPC Architecture Book publication-title: Version – ident: e_1_2_2_22_1 – ident: e_1_2_2_5_1 – ident: e_1_2_2_24_1 – ident: e_1_2_2_17_1 doi: 10.1145/3558481.3591102 – ident: e_1_2_2_32_1 doi: 10.1145/3409964.3461817 – ident: e_1_2_2_9_1 doi: 10.1145/3437801.3441596 – volume-title: Revised Reprint ident: e_1_2_2_13_1 – ident: e_1_2_2_10_1 – ident: e_1_2_2_12_1 doi: 10.1016/j.jpdc.2007.04.010 |
| SSID | ssj0001934839 |
| Score | 2.2937565 |
| Snippet | Traditionally, most concurrent algorithms rely on safe memory reclamation (SMR) schemes for manual memory management. SMR schemes such as epoch-based... |
| SourceID | crossref acm |
| SourceType | Index Database Publisher |
| StartPage | 2156 |
| SubjectTerms | Concurrent algorithms Theory of computation |
| SubjectTermsDisplay | Theory of computation -- Concurrent algorithms |
| Title | RRR-SMR: Reduce, Reuse, Recycle: Better Methods for Practical Lock-Free Data Structures |
| URI | https://dl.acm.org/doi/10.1145/3729337 |
| Volume | 9 |
| hasFullText | 1 |
| inHoldings | 1 |
| isFullTextHit | |
| isPrint | |
| journalDatabaseRights | – providerCode: PRVHPJ databaseName: ROAD: Directory of Open Access Scholarly Resources customDbUrl: eissn: 2475-1421 dateEnd: 99991231 omitProxy: false ssIdentifier: ssj0001934839 issn: 2475-1421 databaseCode: M~E dateStart: 20170101 isFulltext: true titleUrlDefault: https://road.issn.org providerName: ISSN International Centre |
| link | http://cvtisr.summon.serialssolutions.com/2.0.0/link/0/eLvHCXMwtZ1LT9wwEIAtXgcubaGtSl_ygdtikcQ2jrltaRFIZLUKVHBDTuxIK7QBkV1EL_x2xo9kQ8UBDlyyUZxYG3-T8Xg8HiO0nRgNRj4TBKxPSlgcaVJwowl8lCahnPKodKRPxGiUXlzIcYjTbdx2AqKu0_t7efOmqOEawLZLZ1-Bu6sULsA5QIcjYIfji8DneU5Os9xHuum5d5LnZt6Ek_IfPGBLf7mVPIPM7SHt0jKE7EXOuQ16khzeGgNyMVN28nruJhuavjU77no_FxAyPMjs3EMI-ZpaJ0TrDm0WgnV95wIIMj0YTiezwZHqhQWNJlcw1IY3tv90DtJa970SCbfRUyE-1ctRiHR3mixhggN9vxS6VbuyJ13jk9_HT7Qo3-v1yDBqks9re2YTY9iJR-ozx_yXOjuULKPVRHBpA_6yh54HTlIG5qFfSW3r2g33W0OlnPYMlZ7FcfYBvQtDBTz0iDfQkqk30ft2Gw4ctPJHdB6I72PPewc72vbHsd7HnjQOpDGQxh1p3JHGljRekP6E_h7-OTs4ImG_DKKgwQSpqCwZp5XUlRSxhK8wpTqlhpVU0ZgrBV8er5RMyySNEhGVheEwAIhTHWslhKKf0Up9XZsvCBesKqAvq4wCG66CdtpjEVTEC5txThTJFtqEJrq88RlRLkPDbSHcNllX5Be-8_aWr88--A2tL4ToO1qBNzU_0Fp5N5s0tz8dtke5jVTQ |
| linkProvider | ISSN International Centre |
| openUrl | ctx_ver=Z39.88-2004&ctx_enc=info%3Aofi%2Fenc%3AUTF-8&rfr_id=info%3Asid%2Fsummon.serialssolutions.com&rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&rft.genre=article&rft.atitle=RRR-SMR%3A+Reduce%2C+Reuse%2C+Recycle%3A+Better+Methods+for+Practical+Lock-Free+Data+Structures&rft.jtitle=Proceedings+of+ACM+on+programming+languages&rft.au=Arovi%2C+Md+Amit+Hasan&rft.au=Nikolaev%2C+Ruslan&rft.date=2025-06-10&rft.pub=ACM&rft.eissn=2475-1421&rft.volume=9&rft.issue=PLDI&rft.spage=2156&rft.epage=2179&rft_id=info:doi/10.1145%2F3729337&rft.externalDocID=3729337 |
| thumbnail_l | http://covers-cdn.summon.serialssolutions.com/index.aspx?isbn=/lc.gif&issn=2475-1421&client=summon |
| thumbnail_m | http://covers-cdn.summon.serialssolutions.com/index.aspx?isbn=/mc.gif&issn=2475-1421&client=summon |
| thumbnail_s | http://covers-cdn.summon.serialssolutions.com/index.aspx?isbn=/sc.gif&issn=2475-1421&client=summon |