Struct Builder 

pub struct Builder { /* private fields */ }

Implementations

impl Builder

pub fn new() -> Builder

Initiate a new Builder.

Examples

let builder = affinitypool::Builder::new();

pub fn worker_threads(self, num_threads: usize) -> Builder

Set the maximum number of worker-threads that will be alive at any given moment by the built Threadpool. If not specified, defaults the number of threads to the number of CPUs.

Panics

This method will panic if num_threads is 0.

Examples

No more than eight threads will be alive simultaneously for this pool:

use std::thread;

let pool = affinitypool::Builder::new()
        .worker_threads(8)
        .build();

    for _ in 0..10 {
        pool.spawn(|| {
            println!("Hello from a worker thread!")
        }).await;
    }

pub fn thread_name(self, name: impl Into<String>) -> Builder

Set the thread name for each of the threads spawned by the built Threadpool. If not specified, threads spawned by the thread pool will be unnamed.

Examples

Each thread spawned by this pool will have the name “foo”:

use std::thread;

let pool = affinitypool::Builder::new()
    .thread_name("foo")
    .build();

    for _ in 0..10 {
        pool.spawn(|| {
            assert_eq!(thread::current().name(), Some("foo"));
        }).await;
    }

pub fn thread_stack_size(self, size: usize) -> Builder

Set the stack size (in bytes) for each of the threads spawned by the built Threadpool. If not specified, threads spawned by the threadpool will have a stack size [as specified in the std::thread documentation][thread].

Examples

Each thread spawned by this pool will have a 4 MB stack:

let pool = affinitypool::Builder::new()
    .thread_stack_size(4_000_000)
    .build();

    for _ in 0..10 {
        pool.spawn(|| {
            println!("This thread has a 4 MB stack size!");
        }).await;
    }

pub fn thread_per_core(self, enabled: bool) -> Builder

Set whether a thread should be spawned per core.

Examples

Each thread spawned will be linked to a separate core:

let pool = affinitypool::Builder::new()
    .thread_per_core(true)
    .build();

    for _ in 0..10 {
        pool.spawn(|| {
            println!("This is executed on individual cores!");
        }).await;
    }

pub fn build(self) -> Threadpool

Finalize the Builder and build the Threadpool.

Examples

let pool = affinitypool::Builder::new()
    .worker_threads(8)
    .thread_stack_size(4_000_000)
    .build();

Trait Implementations

impl Clone for Builder

fn clone(&self) -> Builder

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for Builder

fn default() -> Builder

Returns the “default value” for a type.