In this series we will implement a double buffer library, similar to left-right but a lot more general.

Here is a preview of what is to come

  • Humble Beginnings - see how double buffers are used, figure out use-cases, and implement a straight-forward single-threaded double-buffer
  • A Fresh Start - use what we learned in Humble Beginnings to implement a better to use double buffer library
  • Interlude on Unsafe - explore how unsafe interacts with various parts of Rust, what are safety contracts more
  • Concurrent Updates Part 1 - adapt the single-threaded library to an naive consistent multi-threaded double buffer
  • Interlude on Atomics - convert the naive double buffer to an eventually consistent multi-threaded double buffer
  • Concurrent Updates Part 2 - convert the naive double buffer to an eventually consistent multi-threaded double buffer
  • Delayed Swaps - implement an important optimization to reduce the overhead of swaps
  • Concurrent HashMap - implement a concurrent, eventually consistent, hashmap with a completely safe interface (including retain!)
  • Generalized Strategy - generalize the strategy used to synchronize the two buffers
  • Generalized Strategy Part 2 - generalize the data structure to work with the generalized strategy
  • A Better Strategy - implement a better strategy designed by Cassy343 in flashmap
  • Async Compatibility - extend support to allow async buffer swaps
  • Subtle Tricks - explore some tricks to regain some more power out of our double buffer library

At the end of each section, I will leave you with some questions. These will usually be covered in the next section, but it will be good for you to work them out yourself, cause that’s where you’ll learn.