Struct ThreadPool

pub struct ThreadPool { /* private fields */ }

Simple thread pool to allow benchmarks to run on pre-warmed threads instead of creating new threads for every batch of iterations. Thread reuse reduces benchmark harness overhead.

Threads in the pool are bound to specific processors according to the provided processor set, ensuring consistent processor affinity across benchmark runs.

Examples

use many_cpus::ProcessorSet;
use new_zealand::nz;
use par_bench::ThreadPool;

// Create a thread pool using the default processor set
let pool = ThreadPool::new(&ProcessorSet::default());
println!("Default pool has {} threads", pool.thread_count());

// Create a thread pool with a specific processor set
if let Some(processors) = ProcessorSet::builder().take(nz!(2)) {
    let pool = ThreadPool::new(&processors);
    assert_eq!(pool.thread_count().get(), 2);
}

Lifecycle

Dropping the pool will wait for all threads to finish executing their tasks.

Implementations

impl ThreadPool

pub fn new(processors: &ProcessorSet) -> Self

Creates a thread pool with one thread per processor in the provided processor set.

Each thread will be bound to its corresponding processor, ensuring consistent processor affinity for benchmark execution.

Examples

use many_cpus::ProcessorSet;
use new_zealand::nz;
use par_bench::ThreadPool;

// Create pool with specific processors
if let Some(processors) = ProcessorSet::builder().take(nz!(4)) {
    let pool = ThreadPool::new(&processors);
    assert_eq!(pool.thread_count().get(), 4);
}

pub fn thread_count(&self) -> NonZero<usize>

Returns the number of threads in the pool.

This is always equal to the number of processors in the processor set used to create the pool.

Examples

use many_cpus::ProcessorSet;
use par_bench::ThreadPool;

let pool = ThreadPool::new(&ProcessorSet::default());
println!("Pool has {} worker threads", pool.thread_count());

Trait Implementations

impl Debug for ThreadPool

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Drop for ThreadPool

fn drop(&mut self)

Executes the destructor for this type.