use std::collections::VecDeque;
use std::io;
use std::sync::{Arc, Condvar, Mutex};
use windows_threadpool_sys::work::ThreadpoolWork;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum Drain {
Idle,
Scheduled,
}
#[derive(Debug)]
pub struct Rejected<T>(pub(crate) T);
struct Queue<T> {
items: VecDeque<T>,
drain: Drain,
closed: bool,
rings: u64,
discarded: u64,
publishing: usize,
}
struct Shared<T> {
queue: Mutex<Queue<T>>,
published: Condvar,
#[cfg(test)]
pause_before_publish: PauseBeforePublish,
}
#[cfg(test)]
#[derive(Default)]
pub(crate) struct PauseBeforePublish {
armed: std::sync::atomic::AtomicBool,
state: Mutex<(bool, bool)>,
changed: Condvar,
}
#[cfg(test)]
impl PauseBeforePublish {
pub(crate) fn arm(&self) {
*self.state.lock().unwrap_or_else(|p| p.into_inner()) = (false, false);
self.armed.store(true, std::sync::atomic::Ordering::SeqCst);
}
fn wait(&self) {
if !self.armed.swap(false, std::sync::atomic::Ordering::SeqCst) {
return;
}
let mut state = self.state.lock().unwrap_or_else(|p| p.into_inner());
state.0 = true;
self.changed.notify_all();
while !state.1 {
state = self.changed.wait(state).unwrap_or_else(|p| p.into_inner());
}
}
pub(crate) fn await_parked(&self) {
let mut state = self.state.lock().unwrap_or_else(|p| p.into_inner());
while !state.0 {
state = self.changed.wait(state).unwrap_or_else(|p| p.into_inner());
}
}
pub(crate) fn release(&self) {
self.state.lock().unwrap_or_else(|p| p.into_inner()).1 = true;
self.changed.notify_all();
}
}
pub(crate) struct Servicer<T: Send + 'static> {
shared: Arc<Shared<T>>,
work: ThreadpoolWork,
}
impl<T: Send + 'static> Servicer<T> {
pub(crate) fn new<H>(handle: H) -> io::Result<Self>
where
H: Fn(T) + Send + Sync + 'static,
{
let shared = Arc::new(Shared {
queue: Mutex::new(Queue {
items: VecDeque::new(),
drain: Drain::Idle,
closed: false,
rings: 0,
discarded: 0,
publishing: 0,
}),
published: Condvar::new(),
#[cfg(test)]
pause_before_publish: PauseBeforePublish::default(),
});
let queue = Arc::clone(&shared);
let work = ThreadpoolWork::new(move || drain(&queue, &handle), None)?;
Ok(Self { shared, work })
}
pub(crate) fn submit(&self, item: T) -> Result<(), Rejected<T>> {
let ring = {
let mut queue = lock(&self.shared.queue);
if queue.closed {
return Err(Rejected(item));
}
queue.items.push_back(item);
let ring = queue.drain == Drain::Idle;
if ring {
queue.drain = Drain::Scheduled;
queue.rings += 1;
queue.publishing += 1;
}
ring
};
if ring {
#[cfg(test)]
self.shared.pause_before_publish.wait();
self.work.submit();
let mut queue = lock(&self.shared.queue);
queue.publishing -= 1;
if queue.publishing == 0 {
self.shared.published.notify_all();
}
}
Ok(())
}
pub(crate) fn shut_down(&self) {
{
let mut queue = lock(&self.shared.queue);
queue.closed = true;
queue.discarded += queue.items.len() as u64;
queue.items.clear();
while queue.publishing > 0 {
queue = self
.shared
.published
.wait(queue)
.unwrap_or_else(|poison| poison.into_inner());
}
}
self.work.cancel_pending();
}
pub(crate) fn is_open(&self) -> bool {
!lock(&self.shared.queue).closed
}
pub(crate) fn quiesce(&self) {
self.work.wait();
}
#[cfg(test)]
pub(crate) fn pending(&self) -> usize {
lock(&self.shared.queue).items.len()
}
#[cfg(test)]
pub(crate) fn rings(&self) -> u64 {
lock(&self.shared.queue).rings
}
#[cfg(test)]
pub(crate) fn pause_gate(&self) -> &PauseBeforePublish {
&self.shared.pause_before_publish
}
#[cfg(test)]
pub(crate) fn discarded(&self) -> u64 {
lock(&self.shared.queue).discarded
}
}
impl<T: Send + 'static> Drop for Servicer<T> {
fn drop(&mut self) {
self.shut_down();
}
}
impl<T: Send + 'static> std::fmt::Debug for Servicer<T> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let queue = lock(&self.shared.queue);
f.debug_struct("Servicer")
.field("pending", &queue.items.len())
.field("drain", &queue.drain)
.field("closed", &queue.closed)
.field("rings", &queue.rings)
.finish_non_exhaustive()
}
}
fn drain<T, H>(shared: &Shared<T>, handle: &H)
where
H: Fn(T),
{
loop {
let next = {
let mut queue = lock(&shared.queue);
match queue.items.pop_front() {
Some(item) => item,
None => {
queue.drain = Drain::Idle;
return;
}
}
};
handle(next);
}
}
fn lock<T>(mutex: &Mutex<T>) -> std::sync::MutexGuard<'_, T> {
mutex.lock().unwrap_or_else(|poison| poison.into_inner())
}
#[cfg(test)]
mod tests;