use std::sync::Mutex;
use std::sync::mpsc::{Receiver, Sender, channel};
use std::thread::JoinHandle;
struct JobPtr(*const (dyn Fn() + Sync));
unsafe impl Send for JobPtr {}
enum Msg {
Run(JobPtr),
Stop,
}
pub(crate) struct ThreadPool {
inner: Mutex<Inner>,
n: usize,
handles: Vec<Option<JoinHandle<()>>>,
}
struct Inner {
txs: Vec<Sender<Msg>>,
done_rx: Receiver<bool>,
}
impl ThreadPool {
pub(crate) fn new(n: usize) -> Self {
let n = n.max(1);
let (done_tx, done_rx) = channel::<bool>();
let mut txs = Vec::with_capacity(n);
let mut handles = Vec::with_capacity(n);
for _ in 0..n {
let (tx, rx) = channel::<Msg>();
let done_tx = done_tx.clone();
let handle = std::thread::spawn(move || {
#[allow(clippy::while_let_loop)]
loop {
match rx.recv() {
Ok(Msg::Run(JobPtr(job))) => {
let job: &(dyn Fn() + Sync) = unsafe { &*job };
let ok =
std::panic::catch_unwind(std::panic::AssertUnwindSafe(job)).is_ok();
let _ = done_tx.send(ok);
}
Ok(Msg::Stop) | Err(_) => break,
}
}
});
txs.push(tx);
handles.push(Some(handle));
}
Self {
inner: Mutex::new(Inner { txs, done_rx }),
n,
handles,
}
}
pub(crate) fn workers(&self) -> usize {
self.n
}
pub(crate) fn run<'env>(&self, n_active: usize, job: &(dyn Fn() + Sync + 'env)) {
let inner = self.inner.lock().unwrap_or_else(|e| e.into_inner());
let helpers = n_active.min(self.n + 1).saturating_sub(1);
let job_erased: *const (dyn Fn() + Sync) =
unsafe { std::mem::transmute::<*const (dyn Fn() + Sync + 'env), _>(job) };
for tx in inner.txs.iter().take(helpers) {
let _ = tx.send(Msg::Run(JobPtr(job_erased)));
}
job();
let mut panicked = false;
for _ in 0..helpers {
if let Ok(false) = inner.done_rx.recv() {
panicked = true
}
}
if panicked {
panic!("a tealdust pool worker panicked");
}
}
}
impl Drop for ThreadPool {
fn drop(&mut self) {
if let Ok(inner) = self.inner.lock() {
for tx in &inner.txs {
let _ = tx.send(Msg::Stop);
}
}
for h in &mut self.handles {
if let Some(h) = h.take() {
let _ = h.join();
}
}
}
}
pub(crate) fn dispatch<'env>(
pool: Option<&ThreadPool>,
n_active: usize,
job: &(dyn Fn() + Sync + 'env),
) {
match pool {
Some(p) => p.run(n_active, job),
None => {
std::thread::scope(|scope| {
for _ in 1..n_active {
scope.spawn(job);
}
job();
});
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::sync::atomic::{AtomicUsize, Ordering};
#[test]
fn pool_dynamic_fill_is_correct_and_reusable() {
let pool = ThreadPool::new(4);
for _ in 0..3 {
let n = 1000usize;
let out: Vec<AtomicUsize> = (0..n).map(|_| AtomicUsize::new(0)).collect();
let cursor = AtomicUsize::new(0);
let job = || loop {
let i = cursor.fetch_add(1, Ordering::Relaxed);
if i >= n {
break;
}
out[i].store(i * i, Ordering::Relaxed);
};
pool.run(pool.workers() + 1, &job);
for (i, v) in out.iter().enumerate() {
assert_eq!(v.load(Ordering::Relaxed), i * i);
}
}
}
#[test]
fn pool_single_active_runs_on_caller() {
let pool = ThreadPool::new(4);
let hit = AtomicUsize::new(0);
let job = || {
hit.fetch_add(1, Ordering::Relaxed);
};
pool.run(1, &job);
assert_eq!(hit.load(Ordering::Relaxed), 1);
}
#[test]
fn dispatch_scope_fallback() {
let n = 500usize;
let out: Vec<AtomicUsize> = (0..n).map(|_| AtomicUsize::new(0)).collect();
let cursor = AtomicUsize::new(0);
let job = || loop {
let i = cursor.fetch_add(1, Ordering::Relaxed);
if i >= n {
break;
}
out[i].store(i + 1, Ordering::Relaxed);
};
dispatch(None, 4, &job);
for (i, v) in out.iter().enumerate() {
assert_eq!(v.load(Ordering::Relaxed), i + 1);
}
}
}