Struct MemoryAwareBatchProcessor

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

Memory-aware batch processor for handling large datasets

Implementations

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

pub fn new( max_memory_mb: usize, memory_threshold_mb: f64, pool_size_mb: usize, ) -> Self

Create a new memory-aware batch processor

Examples found in repository

examples/memory_efficient_example.rs (lines 181-185)

fn demo_memory_aware_batch_processing() -> Result<()> {
    println!("\n🔀 Memory-Aware Batch Processing Demo");
    println!("------------------------------------");

    let mut processor = MemoryAwareBatchProcessor::<f32>::new(
        200,   // 200MB max memory
        150.0, // 150MB threshold
        50,    // 50MB pool size
    );

    // Create a large dataset that needs to be processed in chunks
    println!("Creating large dataset (1000 samples x 784 features)...");
    let large_dataset = Array2::from_shape_fn((1000, 784), |(i, j)| {
        (i as f32 * 0.01 + j as f32 * 0.001).sin()
    })
    .into_dyn();

    println!("Dataset shape: {:?}", large_dataset.shape());
    println!(
        "Estimated memory: {:.2} MB",
        (large_dataset.len() * std::mem::size_of::<f32>()) as f64 / (1024.0 * 1024.0)
    );

    // Process in memory-aware batches
    println!("Processing with automatic batch size adjustment...");
    let start = Instant::now();

    let results = processor.process_batches(&large_dataset, |batch| {
        // Simulate some processing (e.g., forward pass through a layer)
        let processed = batch.mapv(|x| x.tanh()); // Apply activation
        Ok(processed.to_owned())
    })?;

    let processing_time = start.elapsed();

    println!("Processing completed in {:?}", processing_time);
    println!("Number of result batches: {}", results.len());

    // Print statistics
    let stats = processor.get_stats();
    println!("Batch processor statistics:");
    print_batch_processor_stats(&stats);

    Ok(())
}

pub fn process_batches<ProcessFn>( &mut self, input: &ArrayD<F>, process_fn: ProcessFn, ) -> Result<Vec<ArrayD<F>>>

where ProcessFn: FnMut(&ArrayView<'_, F, IxDyn>) -> Result<ArrayD<F>>,

Process batches with automatic size adjustment based on memory usage

Examples found in repository

examples/memory_efficient_example.rs (lines 204-208)

fn demo_memory_aware_batch_processing() -> Result<()> {
    println!("\n🔀 Memory-Aware Batch Processing Demo");
    println!("------------------------------------");

    let mut processor = MemoryAwareBatchProcessor::<f32>::new(
        200,   // 200MB max memory
        150.0, // 150MB threshold
        50,    // 50MB pool size
    );

    // Create a large dataset that needs to be processed in chunks
    println!("Creating large dataset (1000 samples x 784 features)...");
    let large_dataset = Array2::from_shape_fn((1000, 784), |(i, j)| {
        (i as f32 * 0.01 + j as f32 * 0.001).sin()
    })
    .into_dyn();

    println!("Dataset shape: {:?}", large_dataset.shape());
    println!(
        "Estimated memory: {:.2} MB",
        (large_dataset.len() * std::mem::size_of::<f32>()) as f64 / (1024.0 * 1024.0)
    );

    // Process in memory-aware batches
    println!("Processing with automatic batch size adjustment...");
    let start = Instant::now();

    let results = processor.process_batches(&large_dataset, |batch| {
        // Simulate some processing (e.g., forward pass through a layer)
        let processed = batch.mapv(|x| x.tanh()); // Apply activation
        Ok(processed.to_owned())
    })?;

    let processing_time = start.elapsed();

    println!("Processing completed in {:?}", processing_time);
    println!("Number of result batches: {}", results.len());

    // Print statistics
    let stats = processor.get_stats();
    println!("Batch processor statistics:");
    print_batch_processor_stats(&stats);

    Ok(())
}

pub fn get_stats(&self) -> BatchProcessorStats

Get current batch processor statistics

Examples found in repository

examples/memory_efficient_example.rs (line 216)

fn demo_memory_aware_batch_processing() -> Result<()> {
    println!("\n🔀 Memory-Aware Batch Processing Demo");
    println!("------------------------------------");

    let mut processor = MemoryAwareBatchProcessor::<f32>::new(
        200,   // 200MB max memory
        150.0, // 150MB threshold
        50,    // 50MB pool size
    );

    // Create a large dataset that needs to be processed in chunks
    println!("Creating large dataset (1000 samples x 784 features)...");
    let large_dataset = Array2::from_shape_fn((1000, 784), |(i, j)| {
        (i as f32 * 0.01 + j as f32 * 0.001).sin()
    })
    .into_dyn();

    println!("Dataset shape: {:?}", large_dataset.shape());
    println!(
        "Estimated memory: {:.2} MB",
        (large_dataset.len() * std::mem::size_of::<f32>()) as f64 / (1024.0 * 1024.0)
    );

    // Process in memory-aware batches
    println!("Processing with automatic batch size adjustment...");
    let start = Instant::now();

    let results = processor.process_batches(&large_dataset, |batch| {
        // Simulate some processing (e.g., forward pass through a layer)
        let processed = batch.mapv(|x| x.tanh()); // Apply activation
        Ok(processed.to_owned())
    })?;

    let processing_time = start.elapsed();

    println!("Processing completed in {:?}", processing_time);
    println!("Number of result batches: {}", results.len());

    // Print statistics
    let stats = processor.get_stats();
    println!("Batch processor statistics:");
    print_batch_processor_stats(&stats);

    Ok(())
}