sri ramkrishna n.
Skip this Video
Download Presentation
What is RCU, fundamentally?

Loading in 2 Seconds...

play fullscreen
1 / 14

What is RCU, fundamentally? - PowerPoint PPT Presentation

  • Uploaded on

Sri Ramkrishna. What is RCU, fundamentally?. Intro. RCU stands for Read Copy Update A synchronization method that allows reads to occur concurrently with updates. Supports concurrency between single updater and multiple readers

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
Download Presentation

PowerPoint Slideshow about 'What is RCU, fundamentally?' - flavian-myles

Download Now An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
  • RCU stands for Read Copy Update
    • A synchronization method that allows reads to occur concurrently with updates.
    • Supports concurrency between single updater and multiple readers
      • while maintaining multiple versions of objects and ensuring that they are not freed up till all reads are complete.
    • Compares favorably with locking where you have to lock a critical section regardless of readers or writers.
  • RCU is made up of three fundamental mechanisms:
    • Publish Subscribe mechanism
    • Wait for pre-existing RCU readers to complete
    • Maintain multiple versions of RCU objects.
publish subscribe
Publish Subscribe
  • Allows you to read data even though it's being updated.
  • Some background:
    • We've seen that there is no guarantee that reads (or writes) are going to be in program order
    • Values could be assigned or viewed in the wrong order.
  • A Publish mechanism is simply a mechanism that when a memory location is updated it forces the cpu and the compiler to execute pointer assignments and object initializations in the right order.
subscribe publish
Subscribe Publish
  • For some architectures like the DEC Alpha, this isn't enough as some compilers do some wacky optimization.
    • it optimizes by guessing and checks if their guess is right.
  • For these, RCU introduces a rcu_deference primitive.
    • Really only useful on DEC Alpha architectures. Safe to not use it elsewhere.
subscribe publish1
Subscribe Publish
  • The rcu_dereference primitive uses memory barriers and compiler directives to force thecpu and compiler to fetch values in the proper order.
  • Example:
  • rcu_read_lock ()‏
  • p = rc__dereference (gp)‏
  • if (p != NULL)‏
  • do_something_with (p->a, p->b, p->c)‏
  • rcu_read_unlock ()‏
subscribe publish2
Subscribe Publish
  • The rcu_read_lock and rcu_read_unlock calls are used to declare a read-side critical section.
    • make sure that you don't sleep or block in this part.
    • don't actually do anything on some architectures.

Wait for Pre-Existing RCU Readers to Complete

  • There are many ways to wait for something to finish using refcounts, reader/writer locks etc.
  • Has the advantage of scability as it doesn't explicitly have to track any of the threads.
  • Uses reader-side critical sections
    • can contain anything as long as it doesn't block or sleep.
      • Can create performance problems since all readers won't be able to complete because some threads are blocking.
wait for pre existing rcu readers to complete
Wait for Pre-Existing RCU Readers to Complete
  • Basic operation is:
    • Make a change to an object
    • Wait for all pre-existing RCU read-side critical sections to complete using synchronize_rcu primtive
    • Clean up
      • This removes all unused objects and frees memory.
      • Forces a context switch to a cpu. A context switch can't happen until all critical sections are complete.
      • If a context switch happens it means that we have no readers going through their critical sections and probably not referencing the memory.

Wait for Pre-Existing RCU Readers to Complete

  • synchronize_rcu primitive is really a technique to force a context switch on all cpus.
    • if a context switch happens, then we know that there are no readers and we can safely reclaim the memory.

1 struct foo {

2 struct list head list;

3 int a;

4 int b;

5 int c;

6 };

7 LIST_HEAD (head);

8 / * . . . */

9 p = search (head, key);

10 if (p == NULL) {

11 /* do something */

12 }

13 q = kmalloc (sizeof (*p), GFP_KERNEL);

14 q = *p;

15 q->b = 2;

16 q->c = 3;

17 list_replace_rcu (&p->list, &q->list);

18 synchronize_rcu ();

19 kfree(p)‏


Maintaining Multiple Versions of Recently Updated Objects

  • RCU will make a new copy every time an RCU object has been modified to.
  • Readers will continue to see the old copy.
  • When synchronize_rcu is called and returns, RCU will garbage collect reader's version of the object and update all the readers views since it won't complete till all the readers are done.