Struct MemoryPool

pub struct MemoryPool<F: Float + Debug> { /* private fields */ }

Memory pool for efficient tensor allocation and reuse

Implementations

impl<F: Float + Debug + Clone + 'static> MemoryPool<F>

pub fn new(max_pool_size_mb: usize) -> Self

Create a new memory pool

Examples found in repository

examples/memory_efficient_example.rs (line 47)

fn demo_memory_pool() -> Result<()> {
    println!("\n🔄 Memory Pool Demo");
    println!("------------------");

    let mut pool = MemoryPool::<f32>::new(50); // 50MB max pool size

    // Allocate several tensors
    println!("Allocating tensors...");
    let tensor1 = pool.allocate(&[1000, 500]); // ~2MB
    let tensor2 = pool.allocate(&[500, 200]); // ~400KB
    let tensor3 = pool.allocate(&[100, 100]); // ~40KB

    let stats = pool.get_pool_stats();
    println!("Pool stats after allocation:");
    print_pool_stats(&stats);

    // Return tensors to pool
    println!("Returning tensors to pool...");
    pool.deallocate(tensor1);
    pool.deallocate(tensor2);
    pool.deallocate(tensor3);

    let stats = pool.get_pool_stats();
    println!("Pool stats after deallocation:");
    print_pool_stats(&stats);

    // Reuse tensors
    println!("Reusing tensors (should be faster)...");
    let start = Instant::now();
    let _reused1 = pool.allocate(&[1000, 500]);
    let _reused2 = pool.allocate(&[500, 200]);
    let reuse_time = start.elapsed();
    println!("Reuse time: {:?}", reuse_time);

    let stats = pool.get_pool_stats();
    println!("Final pool stats:");
    print_pool_stats(&stats);

    Ok(())
}

pub fn allocate(&mut self, shape: &[usize]) -> ArrayD<F>

Allocate or reuse a tensor with the given shape

Examples found in repository

examples/memory_efficient_example.rs (line 51)

fn demo_memory_pool() -> Result<()> {
    println!("\n🔄 Memory Pool Demo");
    println!("------------------");

    let mut pool = MemoryPool::<f32>::new(50); // 50MB max pool size

    // Allocate several tensors
    println!("Allocating tensors...");
    let tensor1 = pool.allocate(&[1000, 500]); // ~2MB
    let tensor2 = pool.allocate(&[500, 200]); // ~400KB
    let tensor3 = pool.allocate(&[100, 100]); // ~40KB

    let stats = pool.get_pool_stats();
    println!("Pool stats after allocation:");
    print_pool_stats(&stats);

    // Return tensors to pool
    println!("Returning tensors to pool...");
    pool.deallocate(tensor1);
    pool.deallocate(tensor2);
    pool.deallocate(tensor3);

    let stats = pool.get_pool_stats();
    println!("Pool stats after deallocation:");
    print_pool_stats(&stats);

    // Reuse tensors
    println!("Reusing tensors (should be faster)...");
    let start = Instant::now();
    let _reused1 = pool.allocate(&[1000, 500]);
    let _reused2 = pool.allocate(&[500, 200]);
    let reuse_time = start.elapsed();
    println!("Reuse time: {:?}", reuse_time);

    let stats = pool.get_pool_stats();
    println!("Final pool stats:");
    print_pool_stats(&stats);

    Ok(())
}

pub fn deallocate(&mut self, tensor: ArrayD<F>)

Return a tensor to the pool for reuse

Examples found in repository

examples/memory_efficient_example.rs (line 61)

fn demo_memory_pool() -> Result<()> {
    println!("\n🔄 Memory Pool Demo");
    println!("------------------");

    let mut pool = MemoryPool::<f32>::new(50); // 50MB max pool size

    // Allocate several tensors
    println!("Allocating tensors...");
    let tensor1 = pool.allocate(&[1000, 500]); // ~2MB
    let tensor2 = pool.allocate(&[500, 200]); // ~400KB
    let tensor3 = pool.allocate(&[100, 100]); // ~40KB

    let stats = pool.get_pool_stats();
    println!("Pool stats after allocation:");
    print_pool_stats(&stats);

    // Return tensors to pool
    println!("Returning tensors to pool...");
    pool.deallocate(tensor1);
    pool.deallocate(tensor2);
    pool.deallocate(tensor3);

    let stats = pool.get_pool_stats();
    println!("Pool stats after deallocation:");
    print_pool_stats(&stats);

    // Reuse tensors
    println!("Reusing tensors (should be faster)...");
    let start = Instant::now();
    let _reused1 = pool.allocate(&[1000, 500]);
    let _reused2 = pool.allocate(&[500, 200]);
    let reuse_time = start.elapsed();
    println!("Reuse time: {:?}", reuse_time);

    let stats = pool.get_pool_stats();
    println!("Final pool stats:");
    print_pool_stats(&stats);

    Ok(())
}

pub fn get_usage(&self) -> MemoryUsage

Get current memory usage

pub fn clear(&mut self)

Clear the memory pool

pub fn get_pool_stats(&self) -> PoolStatistics

Get pool statistics

Examples found in repository

examples/memory_efficient_example.rs (line 55)

fn demo_memory_pool() -> Result<()> {
    println!("\n🔄 Memory Pool Demo");
    println!("------------------");

    let mut pool = MemoryPool::<f32>::new(50); // 50MB max pool size

    // Allocate several tensors
    println!("Allocating tensors...");
    let tensor1 = pool.allocate(&[1000, 500]); // ~2MB
    let tensor2 = pool.allocate(&[500, 200]); // ~400KB
    let tensor3 = pool.allocate(&[100, 100]); // ~40KB

    let stats = pool.get_pool_stats();
    println!("Pool stats after allocation:");
    print_pool_stats(&stats);

    // Return tensors to pool
    println!("Returning tensors to pool...");
    pool.deallocate(tensor1);
    pool.deallocate(tensor2);
    pool.deallocate(tensor3);

    let stats = pool.get_pool_stats();
    println!("Pool stats after deallocation:");
    print_pool_stats(&stats);

    // Reuse tensors
    println!("Reusing tensors (should be faster)...");
    let start = Instant::now();
    let _reused1 = pool.allocate(&[1000, 500]);
    let _reused2 = pool.allocate(&[500, 200]);
    let reuse_time = start.elapsed();
    println!("Reuse time: {:?}", reuse_time);

    let stats = pool.get_pool_stats();
    println!("Final pool stats:");
    print_pool_stats(&stats);

    Ok(())
}