{"id":10769,"date":"2025-06-02T09:54:01","date_gmt":"2025-06-02T09:54:01","guid":{"rendered":"https:\/\/www.modernescpp.com\/?p=10769"},"modified":"2025-07-03T14:42:05","modified_gmt":"2025-07-03T14:42:05","slug":"read-copy-update-rcu","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/read-copy-update-rcu\/","title":{"rendered":"Read-copy-update (RCU)"},"content":{"rendered":"\n

Read-copy-update is strong in multithreading environments where a data structure is read almost exclusively but rarely written.<\/p>\n\n\n\n

\"\"<\/figure>\n\n\n\n

First of all, what is RCU? The excellent Wikipedia page on Read-copy-update <\/a>provides a good introduction:<\/p>\n\n\n\n

In computer science<\/a>, read-copy-update<\/strong> (RCU<\/strong>) is a synchronization<\/a> mechanism that avoids the use of lock<\/a> primitives while multiple threads<\/a> concurrently read and update elements that are linked through pointers<\/a> and that belong to shared data structures<\/a> (e.g., linked lists<\/a>, trees<\/a>, hash tables<\/a>).[1]<\/a><\/sup><\/em><\/p>\n\n\n\n

Whenever a thread is inserting or deleting elements of data structures in shared memory<\/a>, all readers are guaranteed to see and traverse either the older or the new structure, therefore avoiding inconsistencies (e.g., dereferencing null pointers<\/a>).[1]<\/a><\/sup><\/em><\/p>\n\n\n\n

It is used when performance of reads is crucial and is an example of space\u2013time tradeoff<\/a>, enabling fast operations at the cost of more space. This makes all readers proceed as if there were no synchronization<\/a> involved, hence they will be fast, but also making updates more difficult.<\/em><\/p>\n\n\n\n

The name RCU was coined by the writer’s workflow. It first reads the current data, copies it to the new data, and then updates the current data.<\/p>\n\n\n\n

Proposal P2545R4 <\/a><\/span>provides three use cases for RCU, comparing them with reader-writer locks.<\/a><\/p>\n\n\n\n

Three Use Cases<\/h2>\n\n\n\n

The three use cases compare reader-writer locks.<\/a> with intrusive, non-intrusive, and synchronous RCU.<\/p>\n\n\n\n

Intrusive RCU<\/h3>\n\n\n\n
\"\"<\/figure>\n\n\n\n

Non-Intrusive RCU<\/h3>\n\n\n\n
\"\"<\/figure>\n\n\n\n

Synchronous RCU<\/h3>\n\n\n\n
\"\"<\/figure>\n\n\n\n


The main difference between intrusive and non-intrusive RCU is that in the intrusive case, Data <\/code>is derived directly from the class struct Data : std::rcu_obj_base<Data>.<\/code> This technique, in which a template has itself as a parameter, is known as the Curiously Recurring Template Pattern <\/a>(CRTP). On the reader side, std::scoped_lock l(std::rcu_default_domain()) <\/code>is used. On the writer side, either retire() <\/code>or std::rcu_synchronize() <\/code>is used.<\/p>\n\n\n\n

This raises the question: when should similar techniques such as atomic shared pointers, read-write locks, hazard pointers, and RCU be used? The Proposal P2545R4 <\/a><\/span>provides a simple rule: As a very rough rule of thumb, Hazard Pointers can be considered to be a scalable replacement for reference counters and RCU can be considered to be a scalable replacement for reader-writer locking. A high-level comparison of reference counting, Hazard Pointers, and RCU is displayed in Table 1.
<\/em><\/p>\n\n\n\n

Here is Table 1:<\/p>\n\n\n\n

\"\"<\/figure>\n\n\n\n

To conclude this article, here is the interface of RCU.<\/p>\n\n\n\n

Interface<\/h2>\n\n\n\n

The interface consists of two classes, rcu_obj_base <\/code>and rcu_domain<\/code> and four functions, rcu_default_domain<\/code>, rcu_synchronize<\/code>, rcu_barrier<\/code>, and rcu_retire<\/code>.<\/p>\n\n\n\n

cppreference <\/a>provides a concise description:<\/p>\n\n\n\n

Classes<\/h3>\n\n\n\n
    \n
  • rcu_obj_base<\/code>: allows an object to be protected by RCU<\/li>\n\n\n\n
  • rcu_domain<\/code>: provides regions of RCU protection<\/li>\n<\/ul>\n\n\n\n

    Functions<\/h3>\n\n\n\n
      \n
    • rcu_default_domain<\/code>: returns a reference to a static-duration object of type std::rcu_domain<\/code><\/li>\n\n\n\n
    • rcu_synchronize<\/code>: blocks until a protection region unlocks on a RCU domain<\/li>\n\n\n\n
    • rcu_barrier<\/code>: may evaluate scheduled operations on a RCU domain and blocks until all preceding evaluations are complete<\/li>\n\n\n\n
    • rcu_retire<\/code>: schedules the evaluation of a specified function on a RCU domain, potentially allocating memory, and invoking scheduled evaluations<\/li>\n<\/ul>\n\n\n\n

      What\u2019s next?<\/h2>\n\n\n\n

      The Data-parallel types (SIMD) library provides data-parallel types and operations on them. I will take a closer look at this library in my next article.<\/p>\n","protected":false},"excerpt":{"rendered":"

      Read-copy-update is strong in multithreading environments where a data structure is read almost exclusively but rarely written. First of all, what is RCU? The excellent Wikipedia page on Read-copy-update provides a good introduction: In computer science, read-copy-update (RCU) is a synchronization mechanism that avoids the use of lock primitives while multiple threads concurrently read and […]<\/p>\n","protected":false},"author":21,"featured_media":10580,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[559],"tags":[564],"class_list":["post-10769","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-c26-blog","tag-rcu"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/10769","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/users\/21"}],"replies":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/comments?post=10769"}],"version-history":[{"count":8,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/10769\/revisions"}],"predecessor-version":[{"id":10782,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/10769\/revisions\/10782"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/10580"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=10769"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=10769"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=10769"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}