Skip to content

PERFORMANCE_SUMMARY.md

Latest commit

 

History

History
143 lines (114 loc) · 5.58 KB

PERFORMANCE_SUMMARY.md

File metadata and controls

143 lines (114 loc) · 5.58 KB

Performance Comparison Summary

Benchmark Environment

Hardware Specifications

  • Machine: MacBook Air (Model Identifier: MacBookAir10,1)
  • Processor: Apple M1 (8 cores: 4 performance + 4 efficiency)
  • Memory: 16 GB
  • Architecture: ARM64 (Apple Silicon)
  • Operating System: macOS 24.6.0 (Darwin Kernel Version 24.6.0)

Software Specifications

  • Rust Version: 1.85.0 (4d91de4e4 2025-02-17)
  • Cargo Version: 1.85.0 (d73d2caf9 2024-12-31)
  • Key-Paths-Core: 1.0.9
  • Rayon: 1.11.0 (parallel processing)
  • Tokio: 1.48.0 (async runtime)

Test Configuration

  • Compilation: Debug mode (unoptimized)
  • Threading: Default rayon thread pool (8 threads on M1)
  • Memory: No specific memory constraints
  • Thermal: Normal operating conditions

Apple M1 Performance Notes

  • Heterogeneous Architecture: 4 performance cores + 4 efficiency cores
  • Unified Memory: Shared memory between CPU and GPU
  • High Memory Bandwidth: ~68 GB/s memory bandwidth
  • Power Efficiency: Excellent performance per watt
  • Parallel Processing: Benefits from both performance and efficiency cores

🏆 Key Results: Parallel vs Traditional vs Async

CPU-Intensive Operations (Best Case for Parallel)

Dataset Size Traditional Parallel Speedup Winner
10K 29.79ms 4.93ms 6.04x 🏆 Parallel
50K 78.45ms 15.98ms 4.91x 🏆 Parallel
100K 156.82ms 27.87ms 5.63x 🏆 Parallel
500K 784.28ms 142.27ms 5.51x 🏆 Parallel
1M 1.57s 277.07ms 5.68x 🏆 Parallel

Simple Operations (Best Case for Traditional)

Dataset Size Traditional Parallel Speedup Winner
1K 114µs 6.99ms 0.02x 🏆 Traditional
10K 484µs 33.43ms 0.01x 🏆 Traditional
50K 1.40ms 66.42ms 0.02x 🏆 Traditional
100K 3.02ms 236.69ms 0.01x 🏆 Traditional
500K 21.56ms 865.22ms 0.02x 🏆 Traditional

📊 Performance Characteristics

Parallel Processing Benefits

  • ✅ CPU-Intensive Operations: 5-6x speedup
  • ✅ Large Datasets: 100K+ items
  • ✅ Complex Filtering: 2-3x speedup
  • ✅ Sorting Operations: 2-3x speedup
  • ✅ Aggregation Operations: 1.5-2x speedup

Traditional Processing Benefits

  • ✅ Simple Operations: 40-130x faster
  • ✅ Small Datasets: <50K items
  • ✅ Low Memory Usage: Minimal overhead
  • ✅ Low Latency: No parallelization overhead

Async Processing Benefits

  • ✅ I/O Operations: Network, file operations
  • ✅ Concurrent Tasks: Multiple independent operations
  • ✅ Streaming Data: Processing data as it arrives
  • ⚠️ CPU Operations: Slower due to runtime overhead

🎯 Recommendations

Use Parallel When:

  • Dataset size > 100K items
  • CPU-intensive calculations
  • Complex filtering operations
  • Sorting large datasets
  • Statistical aggregations

Use Traditional When:

  • Dataset size < 50K items
  • Simple map/filter operations
  • Memory-constrained environments
  • Real-time processing requirements
  • Low-latency applications

Use Async When:

  • I/O-bound operations
  • Network requests
  • File operations
  • Concurrent processing
  • Non-blocking operations

🚀 Performance Thresholds

Operation Type Parallel Becomes Beneficial Typical Speedup
CPU-Intensive 10K+ items 5-6x
Complex Filter 50K+ items 2-3x
Aggregation 100K+ items 1.5-2x
Sorting Any size 2-3x
Simple Ops Never (overhead too high) 0.01-0.02x

💡 Key Insights

  1. Parallel processing excels for CPU-intensive work on large datasets
  2. Traditional processing is optimal for simple operations on small datasets
  3. The crossover point is around 50K-100K items for most operations
  4. Sorting operations always benefit from parallelization
  5. Memory usage increases with parallel processing but throughput improves significantly

🔧 Implementation Strategy

// Choose based on dataset size and operation complexity
if dataset_size > 100_000 && is_cpu_intensive {
    // Use parallel processing
    data.par_iter().map(operation).collect()
} else if is_io_bound {
    // Use async processing
    async_operation(data).await
} else {
    // Use traditional processing
    data.iter().map(operation).collect()
}

This analysis demonstrates that the KeyPath library provides excellent performance characteristics across all three approaches, allowing developers to choose the optimal strategy based on their specific requirements.

Apple M1 Performance Impact

The benchmark results are particularly relevant for Apple M1 systems:

  • Heterogeneous Architecture: 4 performance + 4 efficiency cores excel at parallel processing
  • Unified Memory: Shared memory reduces data movement overhead
  • High Memory Bandwidth: ~68 GB/s supports high-throughput operations
  • Power Efficiency: Maintains performance while minimizing power consumption

These characteristics make the Apple M1 particularly well-suited for parallel processing workloads, explaining the significant speedups observed in CPU-intensive operations.