swap-buffer-queue 0.2.1

A buffering MPSC queue.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

use std::task;

use crossbeam_utils::CachePadded;

use crate::{
    loom::sync::{
        atomic::{AtomicBool, Ordering},
        Mutex,
    },
    synchronized::waker::Waker,
};

#[derive(Debug, Default)]
pub(super) struct WakerList {
    wakers: Mutex<Vec<Waker>>,
    non_empty: CachePadded<AtomicBool>,
}

impl WakerList {
    pub(super) fn register(&self, cx: Option<&task::Context>) {
        let waker = Waker::new(cx);
        let mut wakers = self.wakers.lock().unwrap();
        if wakers.is_empty() {
            self.non_empty.store(true, Ordering::SeqCst);
        }
        wakers.push(waker);
    }

    #[inline]
    pub(super) fn wake(&self) {
        if self.non_empty.load(Ordering::Relaxed)
            && self
                .non_empty
                .compare_exchange(true, false, Ordering::SeqCst, Ordering::SeqCst)
                .is_ok()
        {
            self.wake_all();
        }
    }

    // not inlined
    fn wake_all(&self) {
        for waker in self.wakers.lock().unwrap().drain(..) {
            match waker {
                Waker::Async(waker) => waker.wake(),
                Waker::Sync(thread) => thread.unpark(),
            }
        }
    }
}