Struct ComputePool 

pub struct ComputePool { /* private fields */ }

A compute pool that manages CPU-intensive operations

Implementations

impl ComputePool

pub fn new(config: ComputeConfig) -> Result<Self>

Create a new compute pool with the given configuration

pub fn with_defaults() -> Result<Self>

Create a compute pool with default configuration

pub fn execute_sync<F, R>(&self, f: F) -> R

where F: FnOnce() -> R + Send, R: Send,

Execute a synchronous computation on the thread pool

This method is designed to be called from within spawn_blocking or other synchronous contexts. It has minimal overhead as it directly uses Rayon without the async bridge.

Example

tokio::task::spawn_blocking(move || {
    pool.execute_sync(|| {
        // CPU-intensive work
        expensive_computation()
    })
});

pub async fn execute<F, R>(&self, f: F) -> Result<R>

where F: FnOnce() -> R + Send + 'static, R: Send + 'static,

Execute a compute task in the Rayon pool

This bridges from async context to the Rayon thread pool, allowing CPU-intensive work to run without blocking Tokio workers.

Note: This method has ~25μs overhead for small tasks due to the async channel communication. For very small computations (<100μs), consider running directly on Tokio or using spawn_blocking with execute_sync.

pub async fn execute_scoped<F, R>(&self, f: F) -> Result<R>

where F: FnOnce(&Scope<'_>) -> R + Send + 'static, R: Send + 'static,

Execute a function with a Rayon scope

This allows spawning multiple parallel tasks within the scope, with the guarantee that all tasks complete before returning.

pub async fn execute_scoped_fifo<F, R>(&self, f: F) -> Result<R>

where F: FnOnce(&ScopeFifo<'_>) -> R + Send + 'static, R: Send + 'static,

Execute a function with a FIFO scope

Similar to execute_scoped, but tasks are prioritized in FIFO order rather than the default LIFO order.

pub async fn join<F1, F2, R1, R2>(&self, f1: F1, f2: F2) -> Result<(R1, R2)>

where F1: FnOnce() -> R1 + Send + 'static, F2: FnOnce() -> R2 + Send + 'static, R1: Send + 'static, R2: Send + 'static,

Join two computations in parallel

pub fn metrics(&self) -> &ComputeMetrics

Get metrics for this compute pool

pub fn num_threads(&self) -> usize

Get the number of threads in the pool

pub async fn install<F, R>(&self, f: F) -> Result<R>

where F: FnOnce() -> R + Send + 'static, R: Send + 'static,

Install this pool as the Rayon pool for the given closure

This method is essential for using Rayon’s parallel iterators (like par_iter, par_chunks, etc.) with this specific thread pool. Any parallel iterator operations within the closure will execute on this pool’s threads.

Example

use rayon::prelude::*;

// Process data using parallel iterators
let result = pool.install(|| {
    data.par_chunks(100)
        .map(|chunk| process_chunk(chunk))
        .collect::<Vec<_>>()
}).await?;

Concurrent Usage

Multiple async tasks can call install() concurrently on the same pool. The Rayon work-stealing scheduler will efficiently distribute work from all concurrent operations:

// These can run concurrently without interference
let task1 = pool.install(|| data1.par_iter().map(f1).collect());
let task2 = pool.install(|| data2.par_chunks(50).map(f2).collect());

Trait Implementations

impl Clone for ComputePool

fn clone(&self) -> ComputePool

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl ComputePoolExt for ComputePool

fn parallel_batch<'life0, 'async_trait, T, F, R>( &'life0 self, items: Vec<T>, batch_size: usize, f: F, ) -> Pin<Box<dyn Future<Output = Result<Vec<R>>> + Send + 'async_trait>>

where T: Send + Sync + 'static + 'async_trait, F: Fn(&[T]) -> Vec<R> + Send + Sync + 'static + 'async_trait, R: Send + 'static + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Process items in parallel batches

fn parallel_map<'life0, 'async_trait, T, F, R>( &'life0 self, items: Vec<T>, f: F, ) -> Pin<Box<dyn Future<Output = Result<Vec<R>>> + Send + 'async_trait>>

where T: Send + Sync + 'static + 'async_trait, F: Fn(T) -> R + Send + Sync + 'static + 'async_trait, R: Send + 'static + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Map over items in parallel using Rayon’s par_iter

impl Debug for ComputePool

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

Formats the value using the given formatter.