Crates.io | seqlock |
lib.rs | seqlock |
version | 0.2.0 |
source | src |
created_at | 2016-05-28 15:38:39.783801 |
updated_at | 2023-03-30 16:46:35.446283 |
description | A reader-writer lock that provides extremely fast read access without starving writers. |
homepage | |
repository | https://github.com/Amanieu/seqlock |
max_upload_size | |
id | 5214 |
size | 24,484 |
This library provides the SeqLock
type, which is a form of reader-writer
lock that is heavily optimized for readers.
In certain situations, SeqLock
can be two orders of magnitude faster than
the standard library RwLock
type. Another advantage is that readers cannot
starve writers: a writer will never block even if there are readers
currently accessing the SeqLock
.
The only downside of SeqLock
is that it only works on types that are
Copy
. This means that it is unsuitable for types that contains pointers
to owned data.
You should instead use a RwLock
if you need
a reader-writer lock for types that are not Copy
.
The implementation is based on the Linux seqlock
type.
Each SeqLock
contains a sequence counter which tracks modifications to the
locked data. The basic idea is that a reader will perform the following
operations:
Similarly, a writer will increment the sequence counter before and after writing to the data in the lock. Once a reader sees that the sequence counter has not changed while it was reading the data, it can safely return that data to the caller since it is known to be in a consistent state.
use seqlock::SeqLock;
let lock = SeqLock::new(5);
{
// Writing to the data involves a lock
let mut w = lock.lock_write();
*w += 1;
assert_eq!(*w, 6);
}
{
// Reading the data is a very fast operation
let r = lock.read();
assert_eq!(r, 6);
}
Licensed under either of
at your option.
Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.