Skill: Performance Profiling

Purpose

Analyze code for performance characteristics, identify bottlenecks, memory issues, and optimization opportunities through static and dynamic analysis.

When to Use

• Performance regression investigation
• Pre-release performance validation
• Code review for critical paths
• Architecture decision support
• Capacity planning
• Optimization prioritization

---

Profiling Dimensions

CPU Profiling

Aspect	Focus	Indicators
Algorithm Complexity	Big O analysis	Loop depth, recursion
Hot Paths	Frequently executed code	Call frequency
Blocking Operations	Synchronous waits	I/O calls, sleep
Computation Density	CPU-intensive work	Math, parsing, serialization

Memory Profiling

Aspect	Focus	Indicators
Allocation Patterns	Object creation	new/malloc frequency
Memory Leaks	Unreleased memory	Growing heap, retained refs
GC Pressure	Garbage collection	Short-lived objects
Memory Footprint	Total usage	Peak memory, baseline

I/O Profiling

Aspect	Focus	Indicators
Database	Query patterns	N+1, missing indexes
Network	API calls	Latency, payload size
File System	Disk operations	Read/write patterns
Caching	Cache efficiency	Hit ratio, invalidation

Async/Concurrency

Aspect	Focus	Indicators
Event Loop	Blocking detection	Long tasks
Promise Chains	Async patterns	Unhandled, chaining
Thread Pools	Resource utilization	Pool exhaustion
Race Conditions	Concurrency bugs	Data races

---

Profiling Process

Static Analysis

## Static Performance Analysis

### Complexity Analysis

#### Function: processOrders()
**Location:** src/services/order.ts:145

**Complexity Assessment:**
- Time Complexity: O(n²)
- Space Complexity: O(n)

**Analysis:**
```typescript
// Current implementation - O(n²)
orders.forEach(order => {
  const customer = customers.find(c => c.id === order.customerId);
  // ...
});

Issue: Nested iteration creates quadratic complexity

Optimized Approach:

// Optimized - O(n)
const customerMap = new Map(customers.map(c => [c.id, c]));
orders.forEach(order => {
  const customer = customerMap.get(order.customerId);
  // ...
});

Impact: 10x improvement at 1000 orders, 100x at 10000 orders

### Dynamic Analysis

```markdown
## Dynamic Performance Profile

### Execution Trace

| Function | Calls | Total Time | Self Time | % |
|----------|-------|------------|-----------|---|
| processOrders | 1 | 2340ms | 45ms | 100% |
| → findCustomer | 1000 | 2100ms | 2100ms | 89.7% |
| → calculateTax | 1000 | 150ms | 150ms | 6.4% |
| → formatOutput | 1000 | 45ms | 45ms | 1.9% |

### Bottleneck Identified
**findCustomer** consumes 89.7% of execution time

### Memory Allocation

| Phase | Allocated | Peak | GC Events |
|-------|-----------|------|-----------|
| Init | 12 MB | 12 MB | 0 |
| Process | 245 MB | 312 MB | 47 |
| Cleanup | 15 MB | 15 MB | 3 |

### GC Analysis
- 47 GC events during processing indicates high allocation rate
- Short-lived objects suggest optimization opportunity

---

Profile Report Template

## Performance Profile Report

**Target:** {{target}}
**Date:** {{date}}
**Duration:** {{duration}}
**Environment:** {{environment}}

### Executive Summary

| Metric | Value | Target | Status |
|--------|-------|--------|--------|
| Avg Response | 234ms | <200ms | ⚠️ WARN |
| P95 Latency | 890ms | <500ms | ❌ FAIL |
| Memory Peak | 512MB | <256MB | ❌ FAIL |
| CPU Peak | 78% | <60% | ⚠️ WARN |

### Performance Grade: C (Needs Improvement)

---

### Hotspots Identified

#### Hotspot #1: Database Query Loop
**Location:** src/api/reports.ts:67
**Impact:** HIGH
**Time Consumed:** 67% of request time

**Current Code:**
```typescript
for (const userId of userIds) {
  const data = await db.query(
    'SELECT * FROM metrics WHERE user_id = ?',
    [userId]
  );
  results.push(data);
}

Issue: N+1 query pattern - 100 users = 100 queries

Recommended Fix:

const data = await db.query(
  'SELECT * FROM metrics WHERE user_id IN (?)',
  [userIds]
);
const resultMap = groupBy(data, 'user_id');

Expected Improvement: 100 queries → 1 query (95%+ reduction)

---

Hotspot #2: Memory Leak in Event Handler

Location: src/services/websocket.ts:123 Impact: CRITICAL Memory Growth: 2MB per hour

Issue: Event listener not cleaned up on disconnect

Current Code:

socket.on('connect', () => {
  eventBus.on('update', handler);
});

Fixed Code:

socket.on('connect', () => {
  eventBus.on('update', handler);
});
socket.on('disconnect', () => {
  eventBus.off('update', handler);
});

---

Recommendations Priority

Priority	Issue	Effort	Impact
1	N+1 query pattern	2h	High
2	Memory leak	1h	Critical
3	Missing cache	4h	Medium
4	Sync file read	1h	Medium

Before/After Projections

Metric	Current	After Fixes	Improvement
Avg Response	234ms	~80ms	66% faster
P95 Latency	890ms	~200ms	77% faster
Memory Peak	512MB	~128MB	75% less

---

## Language-Specific Profiling

### JavaScript/TypeScript

```markdown
### JS/TS Performance Patterns

#### Event Loop Blocking
```typescript
// BAD: Blocks event loop
const data = fs.readFileSync('large-file.json');

// GOOD: Non-blocking
const data = await fs.promises.readFile('large-file.json');

Memory Leaks

// BAD: Closure retains large object
function createHandler(largeData) {
  return () => console.log(largeData.length);
}

// GOOD: Extract only needed value
function createHandler(largeData) {
  const length = largeData.length;
  return () => console.log(length);
}

### Python

```markdown
### Python Performance Patterns

#### Generator vs List
```python
# BAD: Creates full list in memory
def get_items():
    return [process(x) for x in large_dataset]

# GOOD: Generator yields one at a time
def get_items():
    for x in large_dataset:
        yield process(x)

String Concatenation

# BAD: Creates new string each iteration
result = ""
for item in items:
    result += str(item)

# GOOD: Join is optimized
result = "".join(str(item) for item in items)

### Java

```markdown
### Java Performance Patterns

#### Object Pool for Expensive Objects
```java
// BAD: Creates new connection each time
public Data fetch() {
    Connection conn = new Connection();
    return conn.query();
}

// GOOD: Use connection pool
public Data fetch() {
    Connection conn = connectionPool.acquire();
    try {
        return conn.query();
    } finally {
        connectionPool.release(conn);
    }
}

---

## Agents Using This Skill

- **Software Architect** - Performance architecture
- **Senior Developer** - Code optimization
- **DevOps Engineer** - Runtime profiling

## Related Skills

- `performance-benchmarking` - Performance measurement
- `performance-optimization` - Optimization implementation
- `analysis-code` - General code analysis

## MCP Tools Used

- None (analysis skill)
- Results documented via `confluence-technical-docs`