
Linux-insides: sequential locks in the Linux kernel - 0xAX
https://github.com/0xAX/linux-insides/blob/master/SyncPrim/sync-6.md
======
Amanieu
I wrote an implementation of sequential locks in Rust [1]. It is extensively
commented, which makes it a good way to learn how the algorithm works.

[1]
[https://github.com/Amanieu/seqlock/blob/master/src/lib.rs](https://github.com/Amanieu/seqlock/blob/master/src/lib.rs)

------
gpderetta
On a related note, take a look a Hans Boehm's paper "Can Seqlocks Get Along
With Programming Language Memory Models?" [1].

[1]
[http://www.hpl.hp.com/techreports/2012/HPL-2012-68.html](http://www.hpl.hp.com/techreports/2012/HPL-2012-68.html)

~~~
caf
I enjoyed footnote 3:

    
    
      ... in spite of my earlier claims in the previously
      mentioned mailing list discussion.

------
caf
This is in error: _" So, no one reader or writer can't access protected data.
"_ (in reference to read_seqlock_excl()).

Readers using read_seqbegin() can still access the protected data.

------
tfigment
Not an expert but RCU is more complex with respect to checking the CPU states
for activity to ensure consistency. Sequential locks use spinlocks and a
counter and allows for concurrent reads. This link [1] actually answers it
specifically (sorry about the quora link).

[1] [https://www.quora.com/What-is-difference-between-the-RCU-
rea...](https://www.quora.com/What-is-difference-between-the-RCU-read-copy-
update-and-the-sequential-locks-in-Linux-Kernel)

~~~
r4um
LWN's coverage is pretty good
[https://lwn.net/Articles/262464/](https://lwn.net/Articles/262464/)

------
sriram_malhar
Where do these stand with respect to RCU locks? Are they a replacement, or are
these used in different situations?

~~~
Amanieu
The main downside of seqlocks is that you usually can't have pointers in them.
Since the basic scheme is read, do stuff, check if sequence counter changed,
you need to make sure that you don't dereference a potentially invalid pointer
in the "do stuff" phase if another thread is concurrently modifying the data.

RCU avoids this issue by essentially delaying freeing of objects until there
are no longer any threads accessing it. But it requires very complicated
mechanisms to track all active threads, whereas a seqlock is a very simple and
self-contained.

In both cases the read-side overhead is tiny: for example on x86, you don't
need any memory barrier or atomic instructions.

