Skip to content

Commit

Permalink
Use "Relaxed" for reading tail in producer and head in consumer
Browse files Browse the repository at this point in the history
  • Loading branch information
mgeier committed Dec 9, 2023
1 parent a019f5e commit 80c6842
Show file tree
Hide file tree
Showing 2 changed files with 18 additions and 9 deletions.
15 changes: 10 additions & 5 deletions src/chunks.rs
Original file line number Diff line number Diff line change
Expand Up @@ -238,7 +238,8 @@ impl<T> Producer<T> {
/// For a safe alternative that provides mutable slices of [`Default`]-initialized slots,
/// see [`Producer::write_chunk()`].
pub fn write_chunk_uninit(&mut self, n: usize) -> Result<WriteChunkUninit<'_, T>, ChunkError> {
let tail = self.buffer.tail.load(Ordering::Acquire);
// "tail" is only ever written by the producer thread, "Relaxed" is enough
let tail = self.buffer.tail.load(Ordering::Relaxed);

// Check if the queue has *possibly* not enough slots.
if self.buffer.capacity - self.buffer.distance(self.cached_head.get(), tail) < n {
Expand Down Expand Up @@ -287,7 +288,8 @@ impl<T> Consumer<T> {
///
/// See the documentation of the [`chunks`](crate::chunks#examples) module.
pub fn read_chunk(&mut self, n: usize) -> Result<ReadChunk<'_, T>, ChunkError> {
let head = self.buffer.head.load(Ordering::Acquire);
// "head" is only ever written by the consumer thread, "Relaxed" is enough
let head = self.buffer.head.load(Ordering::Relaxed);

// Check if the queue has *possibly* not enough slots.
if self.buffer.distance(head, self.cached_tail.get()) < n {
Expand Down Expand Up @@ -499,7 +501,8 @@ impl<T> WriteChunkUninit<'_, T> {

unsafe fn commit_unchecked(self, n: usize) -> usize {
let p = self.producer;
let tail = p.buffer.tail.load(Ordering::Acquire);
// "tail" is only ever written by the producer thread, "Relaxed" is enough
let tail = p.buffer.tail.load(Ordering::Relaxed);
let tail = p.buffer.increment(tail, n);
p.buffer.tail.store(tail, Ordering::Release);
n
Expand Down Expand Up @@ -735,7 +738,8 @@ impl<T> ReadChunk<'_, T> {
self.second_ptr.add(i).drop_in_place();
}
let c = self.consumer;
let head = c.buffer.head.load(Ordering::Acquire);
// "head" is only ever written by the consumer thread, "Relaxed" is enough
let head = c.buffer.head.load(Ordering::Relaxed);
let head = c.buffer.increment(head, n);
c.buffer.head.store(head, Ordering::Release);
n
Expand Down Expand Up @@ -789,7 +793,8 @@ impl<'a, T> Drop for ReadChunkIntoIter<'a, T> {
/// Non-iterated items remain in the ring buffer and are *not* dropped.
fn drop(&mut self) {
let c = &self.chunk.consumer;
let head = c.buffer.head.load(Ordering::Acquire);
// "head" is only ever written by the consumer thread, "Relaxed" is enough
let head = c.buffer.head.load(Ordering::Relaxed);
let head = c.buffer.increment(head, self.iterated);
c.buffer.head.store(head, Ordering::Release);
}
Expand Down
12 changes: 8 additions & 4 deletions src/lib.rs
Original file line number Diff line number Diff line change
Expand Up @@ -337,7 +337,8 @@ impl<T> Producer<T> {
pub fn slots(&self) -> usize {
let head = self.buffer.head.load(Ordering::Acquire);
self.cached_head.set(head);
let tail = self.buffer.tail.load(Ordering::Acquire);
// "tail" is only ever written by the producer thread, "Relaxed" is enough
let tail = self.buffer.tail.load(Ordering::Relaxed);
self.buffer.capacity - self.buffer.distance(head, tail)
}

Expand Down Expand Up @@ -433,7 +434,8 @@ impl<T> Producer<T> {
/// This is a strict subset of the functionality implemented in `write_chunk_uninit()`.
/// For performance, this special case is immplemented separately.
fn next_tail(&self) -> Option<usize> {
let tail = self.buffer.tail.load(Ordering::Acquire);
// "tail" is only ever written by the producer thread, "Relaxed" is enough
let tail = self.buffer.tail.load(Ordering::Relaxed);

// Check if the queue is *possibly* full.
if self.buffer.distance(self.cached_head.get(), tail) == self.buffer.capacity {
Expand Down Expand Up @@ -569,9 +571,10 @@ impl<T> Consumer<T> {
/// assert_eq!(c.slots(), 0);
/// ```
pub fn slots(&self) -> usize {
let head = self.buffer.head.load(Ordering::Acquire);
let tail = self.buffer.tail.load(Ordering::Acquire);
self.cached_tail.set(tail);
// "head" is only ever written by the consumer thread, "Relaxed" is enough
let head = self.buffer.head.load(Ordering::Relaxed);
self.buffer.distance(head, tail)
}

Expand Down Expand Up @@ -666,7 +669,8 @@ impl<T> Consumer<T> {
/// This is a strict subset of the functionality implemented in `read_chunk()`.
/// For performance, this special case is immplemented separately.
fn next_head(&self) -> Option<usize> {
let head = self.buffer.head.load(Ordering::Acquire);
// "head" is only ever written by the consumer thread, "Relaxed" is enough
let head = self.buffer.head.load(Ordering::Relaxed);

// Check if the queue is *possibly* empty.
if head == self.cached_tail.get() {
Expand Down

0 comments on commit 80c6842

Please sign in to comment.