Struct ThreadLocalPoolManager 

pub struct ThreadLocalPoolManager { /* private fields */ }

Manager for thread-local memory pools

This provides a global interface to thread-local pools with zero contention. Each thread maintains its own pools for f32 and f64 buffers.

Thread Safety

Thread-local pools are completely thread-safe without any locks because each thread has its own storage. There is no contention between threads.

Example

use tenrso_exec::executor::thread_local_pool::ThreadLocalPoolManager;
use std::thread;

let manager = ThreadLocalPoolManager::new();
manager.enable();

// Spawn threads - each will use its own pool
let handles: Vec<_> = (0..4)
    .map(|_| {
        let mgr = manager.clone();
        thread::spawn(move || {
            for _ in 0..100 {
                let buf = mgr.acquire_f64(&[1000]);
                mgr.release_f64(&[1000], buf);
            }
        })
    })
    .collect();

for h in handles {
    h.join().unwrap();
}

// Get aggregated statistics from the main thread
let stats = manager.aggregated_stats_f64();
println!("Main thread hit rate: {:.2}%", stats.overall_hit_rate * 100.0);

Implementations

impl ThreadLocalPoolManager

pub fn new() -> Self

Create a new thread-local pool manager

pub fn enable(&self)

Enable thread-local pooling

pub fn disable(&self)

Disable thread-local pooling

pub fn is_enabled(&self) -> bool

Check if pooling is enabled

pub fn acquire_f32(&self, shape: &[usize]) -> Vec<f32>

Acquire an f32 buffer from the current thread’s pool

pub fn release_f32(&self, shape: &[usize], buffer: Vec<f32>)

Release an f32 buffer back to the current thread’s pool

pub fn acquire_f64(&self, shape: &[usize]) -> Vec<f64>

Acquire an f64 buffer from the current thread’s pool

pub fn release_f64(&self, shape: &[usize], buffer: Vec<f64>)

Release an f64 buffer back to the current thread’s pool

pub fn thread_stats_f32(&self) -> ThreadLocalPoolStats

Get statistics for the current thread’s f32 pool

pub fn thread_stats_f64(&self) -> ThreadLocalPoolStats

Get statistics for the current thread’s f64 pool

pub fn clear_thread_f32(&self)

Clear the current thread’s f32 pool

pub fn clear_thread_f64(&self)

Clear the current thread’s f64 pool

pub fn aggregated_stats_f32(&self) -> AggregatedPoolStats

Get aggregated statistics from all threads (f32)

Note: This requires cooperation from all threads. The returned statistics only include the current thread’s data since we can’t access other threads’ thread-local storage directly.

For true multi-thread statistics, use the shared MemoryPool instead.

pub fn aggregated_stats_f64(&self) -> AggregatedPoolStats

Get aggregated statistics from all threads (f64)

Trait Implementations

impl Clone for ThreadLocalPoolManager

fn clone(&self) -> ThreadLocalPoolManager

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for ThreadLocalPoolManager

fn default() -> Self

Returns the “default value” for a type.