Struct PerformanceProfiler

pub struct PerformanceProfiler { /* private fields */ }

Performance profiler for neural network operations

Tracks timing information for neural network operations to identify performance bottlenecks and optimize training pipelines.

Implementations

impl PerformanceProfiler

pub fn new(enabled: bool) -> Self

Create a new performance profiler

Arguments

• enabled - Whether profiling is enabled

Examples

use scirs2_neural::performance::threading::PerformanceProfiler;

let mut profiler = PerformanceProfiler::new(true);

let timer = profiler.start_timer("forward_pass");
// ... perform operation
profiler.end_timer("forward_pass".to_string(), timer);

pub fn start_timer(&mut self, name: &str) -> Option<Instant>

Start timing an operation

Examples found in repository

examples/new_features_showcase.rs (line 166)

fn demonstrate_performance_optimizations() -> Result<(), Box<dyn std::error::Error>> {
    println!("⚡ Performance Optimizations Demonstration");
    println!("========================================\n");

    // 1. Thread Pool Manager
    println!("1. Thread Pool Manager:");
    let thread_pool = ThreadPoolManager::new(Some(4))?;
    println!(
        "   Created thread pool with {} threads",
        thread_pool.num_threads()
    );

    // Demonstrate parallel matrix multiplication
    let matrix_a = Array::from_elem((100, 50), 2.0f32).into_dyn();
    let matrix_b = Array::from_elem((50, 75), 3.0f32).into_dyn();

    let start_time = std::time::Instant::now();
    let result = thread_pool.parallel_matmul(&matrix_a, &matrix_b)?;
    let elapsed = start_time.elapsed();

    println!(
        "   Parallel matrix multiplication: {}x{} * {}x{} = {}x{}",
        matrix_a.shape()[0],
        matrix_a.shape()[1],
        matrix_b.shape()[0],
        matrix_b.shape()[1],
        result.shape()[0],
        result.shape()[1]
    );
    println!("   Time elapsed: {:.3}ms", elapsed.as_secs_f64() * 1000.0);
    println!("   Result sample: {:.1}", result[[0, 0]]);

    // 2. Performance Profiler
    println!("\n2. Performance Profiler:");
    let mut optimizer = PerformanceOptimizer::new(Some(1024), Some(512), Some(4), true)?;

    // Simulate some operations with profiling
    {
        let timer = optimizer.profiler_mut().start_timer("matrix_setup");
        let test_matrix_a = Array::from_elem((200, 100), 1.5f32).into_dyn();
        let test_matrix_b = Array::from_elem((100, 150), 2.5f32).into_dyn();
        optimizer
            .profiler_mut()
            .end_timer("matrix_setup".to_string(), timer);

        let _result = optimizer.optimized_matmul(&test_matrix_a, &test_matrix_b)?;
    }

    println!("   Performance profile summary:");
    optimizer.profiler().print_summary();

    // 3. Optimization Capabilities
    println!("\n3. Optimization Capabilities:");
    let capabilities = optimizer.get_capabilities();
    println!("{}", capabilities);

    println!("✅ Performance optimizations demonstration completed!\n");
    Ok(())
}

pub fn end_timer(&mut self, name: String, start_time: Option<Instant>)

End timing an operation and record the result

Examples found in repository

examples/new_features_showcase.rs (line 171)

fn demonstrate_performance_optimizations() -> Result<(), Box<dyn std::error::Error>> {
    println!("⚡ Performance Optimizations Demonstration");
    println!("========================================\n");

    // 1. Thread Pool Manager
    println!("1. Thread Pool Manager:");
    let thread_pool = ThreadPoolManager::new(Some(4))?;
    println!(
        "   Created thread pool with {} threads",
        thread_pool.num_threads()
    );

    // Demonstrate parallel matrix multiplication
    let matrix_a = Array::from_elem((100, 50), 2.0f32).into_dyn();
    let matrix_b = Array::from_elem((50, 75), 3.0f32).into_dyn();

    let start_time = std::time::Instant::now();
    let result = thread_pool.parallel_matmul(&matrix_a, &matrix_b)?;
    let elapsed = start_time.elapsed();

    println!(
        "   Parallel matrix multiplication: {}x{} * {}x{} = {}x{}",
        matrix_a.shape()[0],
        matrix_a.shape()[1],
        matrix_b.shape()[0],
        matrix_b.shape()[1],
        result.shape()[0],
        result.shape()[1]
    );
    println!("   Time elapsed: {:.3}ms", elapsed.as_secs_f64() * 1000.0);
    println!("   Result sample: {:.1}", result[[0, 0]]);

    // 2. Performance Profiler
    println!("\n2. Performance Profiler:");
    let mut optimizer = PerformanceOptimizer::new(Some(1024), Some(512), Some(4), true)?;

    // Simulate some operations with profiling
    {
        let timer = optimizer.profiler_mut().start_timer("matrix_setup");
        let test_matrix_a = Array::from_elem((200, 100), 1.5f32).into_dyn();
        let test_matrix_b = Array::from_elem((100, 150), 2.5f32).into_dyn();
        optimizer
            .profiler_mut()
            .end_timer("matrix_setup".to_string(), timer);

        let _result = optimizer.optimized_matmul(&test_matrix_a, &test_matrix_b)?;
    }

    println!("   Performance profile summary:");
    optimizer.profiler().print_summary();

    // 3. Optimization Capabilities
    println!("\n3. Optimization Capabilities:");
    let capabilities = optimizer.get_capabilities();
    println!("{}", capabilities);

    println!("✅ Performance optimizations demonstration completed!\n");
    Ok(())
}

pub fn time_operation<F, R>(&mut self, name: &str, operation: F) -> R

where F: FnOnce() -> R,

Time a closure and return its result

pub fn get_timings(&self) -> &HashMap<String, Duration>

Get timing information

pub fn get_call_counts(&self) -> &HashMap<String, usize>

Get call counts

pub fn get_average_time(&self, name: &str) -> Option<Duration>

Get average timing for an operation

pub fn clear(&mut self)

Clear all timing information

pub fn print_summary(&self)

Print timing summary

Examples found in repository

examples/new_features_showcase.rs (line 177)

fn demonstrate_performance_optimizations() -> Result<(), Box<dyn std::error::Error>> {
    println!("⚡ Performance Optimizations Demonstration");
    println!("========================================\n");

    // 1. Thread Pool Manager
    println!("1. Thread Pool Manager:");
    let thread_pool = ThreadPoolManager::new(Some(4))?;
    println!(
        "   Created thread pool with {} threads",
        thread_pool.num_threads()
    );

    // Demonstrate parallel matrix multiplication
    let matrix_a = Array::from_elem((100, 50), 2.0f32).into_dyn();
    let matrix_b = Array::from_elem((50, 75), 3.0f32).into_dyn();

    let start_time = std::time::Instant::now();
    let result = thread_pool.parallel_matmul(&matrix_a, &matrix_b)?;
    let elapsed = start_time.elapsed();

    println!(
        "   Parallel matrix multiplication: {}x{} * {}x{} = {}x{}",
        matrix_a.shape()[0],
        matrix_a.shape()[1],
        matrix_b.shape()[0],
        matrix_b.shape()[1],
        result.shape()[0],
        result.shape()[1]
    );
    println!("   Time elapsed: {:.3}ms", elapsed.as_secs_f64() * 1000.0);
    println!("   Result sample: {:.1}", result[[0, 0]]);

    // 2. Performance Profiler
    println!("\n2. Performance Profiler:");
    let mut optimizer = PerformanceOptimizer::new(Some(1024), Some(512), Some(4), true)?;

    // Simulate some operations with profiling
    {
        let timer = optimizer.profiler_mut().start_timer("matrix_setup");
        let test_matrix_a = Array::from_elem((200, 100), 1.5f32).into_dyn();
        let test_matrix_b = Array::from_elem((100, 150), 2.5f32).into_dyn();
        optimizer
            .profiler_mut()
            .end_timer("matrix_setup".to_string(), timer);

        let _result = optimizer.optimized_matmul(&test_matrix_a, &test_matrix_b)?;
    }

    println!("   Performance profile summary:");
    optimizer.profiler().print_summary();

    // 3. Optimization Capabilities
    println!("\n3. Optimization Capabilities:");
    let capabilities = optimizer.get_capabilities();
    println!("{}", capabilities);

    println!("✅ Performance optimizations demonstration completed!\n");
    Ok(())
}

pub fn get_stats(&self) -> ProfilingStats

Get profiling statistics

pub fn set_enabled(&mut self, enabled: bool)

Enable or disable profiling