Skip to main content

Extension System Performance Guide

This document provides performance guidelines, benchmarks, and optimization strategies for the Radium extension system.

Performance Targets​

The extension system is designed to meet the following performance targets:

  • Discovery: <100ms for discovering all extensions
  • Installation: <500ms for typical extension installation
  • Marketplace queries: <200ms for search operations
  • Signature verification: <50ms per extension
  • Dependency resolution: <100ms for typical dependency chains

Benchmarking​

Running Benchmarks​

Run extension system benchmarks:

cargo bench -p radium-core --bench extension_benchmarks

Benchmark Coverage​

The benchmark suite covers:

  • Manifest parsing
  • Extension discovery (single and multiple paths)
  • Extension installation (local, archive, URL)
  • Conflict detection
  • Marketplace queries
  • Signature verification
  • Dependency graph construction

Performance Optimization Strategies​

1. Discovery Optimization​

Caching: Extension discovery results are cached to avoid redundant filesystem operations.

Parallel Scanning: For multiple search paths, use parallel directory scanning:

use rayon::prelude::*;

let extensions: Vec<_> = search_paths
    .par_iter()
    .flat_map(|path| discover_in_path(path))
    .collect();

Lazy Loading: Load extension manifests only when needed, not during discovery.

2. Installation Optimization​

Incremental Parsing: Parse manifests incrementally rather than loading entire files.

Parallel Downloads: When installing multiple extensions, download in parallel:

use futures::future::join_all;

let downloads: Vec<_> = extensions.iter()
    .map(|ext| download_extension(ext))
    .collect();
join_all(downloads).await;

Streaming Archives: Stream archive extraction rather than loading entire archive into memory.

3. Marketplace Optimization​

Connection Pooling: Reuse HTTP connections for marketplace queries.

Caching: Cache marketplace responses with appropriate TTL (default: 5 minutes).

Batch Queries: When possible, batch multiple queries into single requests.

4. Memory Optimization​

Lazy Component Loading: Load extension components (prompts, commands) only when accessed.

Efficient Data Structures: Use appropriate data structures:

  • HashMap for O(1) lookups
  • Vec for sequential access
  • HashSet for membership tests

Avoid Unnecessary Clones: Use references where possible, clone only when necessary.

Profiling​

Using Criterion​

Criterion is used for benchmarking. Results are saved in target/criterion/.

Using Flamegraph​

Generate flamegraphs to identify hot paths:

cargo install flamegraph
cargo flamegraph --bench extension_benchmarks

Using perf​

On Linux, use perf for profiling:

perf record --call-graph dwarf cargo bench -p radium-core --bench extension_benchmarks
perf report

Common Performance Issues​

Slow Discovery​

Symptoms: Extension discovery takes >100ms

Solutions:

  • Reduce number of search paths
  • Enable discovery caching
  • Use validate_structure: false for faster discovery

Slow Installation​

Symptoms: Installation takes >500ms

Solutions:

  • Use local installations instead of URLs when possible
  • Pre-validate extensions before installation
  • Disable unnecessary validation steps

High Memory Usage​

Symptoms: High memory consumption with many extensions

Solutions:

  • Enable lazy loading
  • Clear caches periodically
  • Limit number of loaded extensions

Best Practices for Extension Authors​

Manifest Optimization​

  • Keep manifest files small (less than 10KB)
  • Minimize metadata
  • Use efficient JSON structure

Component Organization​

  • Organize components in subdirectories
  • Use glob patterns efficiently
  • Avoid deeply nested structures

Dependency Management​

  • Minimize dependencies
  • Avoid circular dependencies
  • Use version constraints appropriately

Performance Monitoring​

Metrics Collection​

Key metrics to monitor:

  • Discovery time
  • Installation time
  • Marketplace query time
  • Memory usage
  • Cache hit rates

Logging Slow Operations​

Enable performance logging:

use std::time::Instant;

let start = Instant::now();
// ... operation ...
let duration = start.elapsed();
if duration.as_millis() > 100 {
    log::warn!("Slow operation: {:?} took {:?}", operation, duration);
}

CI Performance Checks​

Performance regression tests run in CI:

  • Compare benchmark results against baseline
  • Fail if regression >10%
  • Generate performance reports

Next Steps​