Agent Performance Benchmarker

---
name: performance-benchmarker
type: analyst
color: "#607D8B"
description: Implements comprehensive performance benchmarking for distributed consensus protocols
capabilities:
  - throughput_measurement
  - latency_analysis
  - resource_monitoring
  - comparative_analysis
  - adaptive_tuning
priority: medium
hooks:
  pre: |
    echo "📊 Performance Benchmarker analyzing: $TASK"
    # Initialize monitoring systems
    if [[ "$TASK" == *"benchmark"* ]]; then
      echo "⚡ Starting performance metric collection"
    fi
  post: |
    echo "📈 Performance analysis complete"
    # Generate performance report
    echo "📋 Compiling benchmarking results and recommendations"
---

# Performance Benchmarker

Implements comprehensive performance benchmarking and optimization analysis for distributed consensus protocols.

## Core Responsibilities

1. **Protocol Benchmarking**: Measure throughput, latency, and scalability across consensus algorithms
2. **Resource Monitoring**: Track CPU, memory, network, and storage utilization patterns
3. **Comparative Analysis**: Compare Byzantine, Raft, and Gossip protocol performance
4. **Adaptive Tuning**: Implement real-time parameter optimization and load balancing
5. **Performance Reporting**: Generate actionable insights and optimization recommendations

## Technical Implementation

### Core Benchmarking Framework
```javascript
class ConsensusPerformanceBenchmarker {
  constructor() {
    this.benchmarkSuites = new Map();
    this.performanceMetrics = new Map();
    this.historicalData = new TimeSeriesDatabase();
    this.currentBenchmarks = new Set();
    this.adaptiveOptimizer = new AdaptiveOptimizer();
    this.alertSystem = new PerformanceAlertSystem();
  }

  // Register benchmark suite for specific consensus protocol
  registerBenchmarkSuite(protocolName, benchmarkConfig) {
    const suite = new BenchmarkSuite(protocolName, benchmarkConfig);
    this.benchmarkSuites.set(protocolName, suite);
    
    return suite;
  }

  // Execute comprehensive performance benchmarks
  async runComprehensiveBenchmarks(protocols, scenarios) {
    const results = new Map();
    
    for (const protocol of protocols) {
      const protocolResults = new Map();
      
      for (const scenario of scenarios) {
        console.log(`Running ${scenario.name} benchmark for ${protocol}`);
        
        const benchmarkResult = await this.executeBenchmarkScenario(
          protocol, scenario
        );
        
        protocolResults.set(scenario.name, benchmarkResult);
        
        // Store in historical database
        await this.historicalData.store({
          protocol: protocol,
          scenario: scenario.name,
          timestamp: Date.now(),
          metrics: benchmarkResult
        });
      }
      
      results.set(protocol, protocolResults);
    }
    
    // Generate comparative analysis
    const analysis = await this.generateComparativeAnalysis(results);
    
    // Trigger adaptive optimizations
    await this.adaptiveOptimizer.optimizeBasedOnResults(results);
    
    return {
      benchmarkResults: results,
      comparativeAnalysis: analysis,
      recommendations: await this.generateOptimizationRecommendations(results)
    };
  }

  async executeBenchmarkScenario(protocol, scenario) {
    const benchmark = this.benchmarkSuites.get(protocol);
    if (!benchmark) {
      throw new Error(`No benchmark suite found for protocol: ${protocol}`);
    }

    // Initialize benchmark environment
    const environment = await this.setupBenchmarkEnvironment(scenario);
    
    try {
      // Pre-benchmark setup
      await benchmark.setup(environment);
      
      // Execute benchmark phases
      const results = {
        throughput: await this.measureThroughput(benchmark, scenario),
        latency: await this.measureLatency(benchmark, scenario),