performance-analysis

Performance Analysis Skill

Comprehensive performance analysis suite for identifying bottlenecks, profiling swarm operations, generating detailed reports, and providing actionable optimization recommendations.

Overview

This skill consolidates all performance analysis capabilities:

Bottleneck Detection: Identify performance bottlenecks across communication, processing, memory, and network
Performance Profiling: Real-time monitoring and historical analysis of swarm operations
Report Generation: Create comprehensive performance reports in multiple formats
Optimization Recommendations: AI-powered suggestions for improving performance

Quick Start

Basic Bottleneck Detection

npx claude-flow bottleneck detect

Generate Performance Report

npx claude-flow analysis performance-report --format html --include-metrics

Analyze and Auto-Fix

npx claude-flow bottleneck detect --fix --threshold 15

Reference

The full detail lives in references/ and loads only when needed:

references/capabilities.md — core capabilities & analysis details.

Executive Summary

Overall Score: 87/100
Analysis Period: Last 24 hours
Swarms Analyzed: 3
Critical Issues: 1

Key Metrics

Metric	Value	Trend	Target
Avg Task Time	42s	↓ 12%	35s
Agent Utilization	78%	↑ 5%	85%
Cache Hit Rate	91%	→	90%
Parallel Efficiency	2.3x	↑ 0.4x	2.5x

Bottleneck Analysis

Critical

Agent Communication Delay (Impact: 35%)
- Coordinator → Coder messages delayed by 2.3s avg
- Fix: Switch to hierarchical topology

Warnings

Memory Access Pattern (Impact: 18%)
- Neural pattern loading: 1.8s per access
- Fix: Enable memory caching

Recommendations

High Priority: Switch to hierarchical topology (40% improvement)
Medium Priority: Enable memory caching (25% improvement)
Low Priority: Increase agent concurrency to 8 (20% improvement)


### 4. Optimization Recommendations

#### Automatic Fixes
When using `--fix`, the following optimizations may be applied:

**1. Topology Optimization**
- Switch to more efficient topology (mesh → hierarchical)
- Adjust communication patterns
- Reduce coordination overhead
- Optimize message routing

**2. Caching Enhancement**
- Enable memory caching
- Optimize cache strategies
- Preload common patterns
- Implement cache warming

**3. Concurrency Tuning**
- Adjust agent counts
- Optimize parallel execution
- Balance workload distribution
- Implement load balancing

**4. Priority Adjustment**
- Reorder task queues
- Prioritize critical paths
- Reduce wait times
- Implement fair scheduling

**5. Resource Optimization**
- Optimize memory usage
- Reduce I/O operations
- Batch API calls
- Implement connection pooling

#### Performance Impact
Typical improvements after bottleneck resolution:

- **Communication**: 30-50% faster message delivery
- **Processing**: 20-40% reduced task completion time
- **Memory**: 40-60% fewer cache misses
- **Network**: 25-45% reduced API latency
- **Overall**: 25-45% total performance improvement

## Advanced Usage

### Continuous Monitoring
```bash
# Monitor performance in real-time
npx claude-flow swarm monitor --interval 5

# Generate hourly reports
while true; do
  npx claude-flow analysis performance-report \
    --format json \
    --output logs/perf-$(date +%Y%m%d-%H%M).json
  sleep 3600
done

CI/CD Integration

# .github/workflows/performance.yml
name: Performance Analysis
on: [push, pull_request]

jobs:
  analyze:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - name: Run Performance Analysis
        run: |
          npx claude-flow analysis performance-report \
            --format json \
            --output performance.json
      - name: Check Performance Thresholds
        run: |
          npx claude-flow bottleneck detect \
            --threshold 15 \
            --export bottlenecks.json
      - name: Upload Reports
        uses: actions/upload-artifact@v2
        with:
          name: performance-reports
          path: |
            performance.json
            bottlenecks.json

Custom Analysis Scripts

// scripts/analyze-performance.js
const { exec } = require('child_process');
const fs = require('fs');

async function analyzePerformance() {
  // Run bottleneck detection
  const bottlenecks = await runCommand(
    'npx claude-flow bottleneck detect --format json'
  );

  // Generate performance report
  const report = await runCommand(
    'npx claude-flow analysis performance-report --format json'
  );

  // Analyze results
  const analysis = {
    bottlenecks: JSON.parse(bottlenecks),
    performance: JSON.parse(report),
    timestamp: new Date().toISOString()
  };

  // Save combined analysis
  fs.writeFileSync(
    'analysis/combined-report.json',
    JSON.stringify(analysis, null, 2)
  );

  // Generate alerts if needed
  if (analysis.bottlenecks.critical.length > 0) {
    console.error('CRITICAL: Performance bottlenecks detected!');
    process.exit(1);
  }
}

function runCommand(cmd) {
  return new Promise((resolve, reject) => {
    exec(cmd, (error, stdout, stderr) => {
      if (error) reject(error);
      else resolve(stdout);
    });
  });
}

analyzePerformance().catch(console.error);

Best Practices

1. Regular Analysis

Run bottleneck detection after major changes
Generate weekly performance reports
Monitor trends over time
Set up automated alerts

2. Threshold Tuning

Start with default threshold (20%)
Lower for production systems (10-15%)
Higher for development (25-30%)
Adjust based on requirements

3. Fix Strategy

Always review before applying --fix
Test fixes in development first
Apply fixes incrementally
Monitor impact after changes

4. Report Integration

Include in documentation
Share with team regularly
Track improvements over time
Use for capacity planning

5. Continuous Optimization

Learn from each analysis
Build performance budgets
Establish baselines
Set improvement goals

Troubleshooting

Common Issues

High Memory Usage

# Analyze memory bottlenecks
npx claude-flow bottleneck detect --threshold 10

# Check cache performance
npx claude-flow cache manage --action stats

# Review memory metrics
npx claude-flow memory usage

Slow Task Execution

# Identify slow tasks
npx claude-flow task status --detailed

# Analyze coordination overhead
npx claude-flow bottleneck detect --time-range 1h

# Check agent utilization
npx claude-flow agent metrics

Poor Cache Performance

# Analyze cache hit rates
npx claude-flow analysis performance-report --sections metrics

# Review cache strategy
npx claude-flow cache manage --action analyze

# Enable cache warming
npx claude-flow bottleneck detect --fix

Integration with Other Skills

swarm-orchestration: Use performance data to optimize topology
memory-management: Improve cache strategies based on analysis
task-coordination: Adjust scheduling based on bottlenecks
neural-training: Train patterns from performance data

Related Commands

npx claude-flow swarm monitor - Real-time monitoring
npx claude-flow token usage - Token optimization analysis
npx claude-flow cache manage - Cache optimization
npx claude-flow agent metrics - Agent performance metrics
npx claude-flow task status - Task execution analysis

About this skill