# Daemon Stress Testing and Performance

This document describes the stress tests and performance benchmarks for the bd daemon architecture.

## Overview

Phase 4 of the daemon implementation adds:
- **Batch Operations**: Atomic multi-step operations
- **Request Timeouts**: Configurable timeouts with deadline support
- **Stress Tests**: Comprehensive concurrent agent testing
- **Performance Benchmarks**: Daemon vs direct mode comparisons

## Batch Operations

The daemon supports atomic batch operations via the `OpBatch` operation:

```go
batchArgs := &rpc.BatchArgs{
    Operations: []rpc.BatchOperation{
        {Operation: rpc.OpCreate, Args: createArgs1JSON},
        {Operation: rpc.OpUpdate, Args: updateArgs1JSON},
        {Operation: rpc.OpDepAdd, Args: depArgsJSON},
    },
}

resp, err := client.Batch(batchArgs)
```

**Behavior:**
- Operations execute in order
- If any operation fails, the batch stops and returns results up to the failure
- All operations are serialized through the single daemon writer

**Use Cases:**
- Creating an issue and immediately adding dependencies
- Updating multiple related issues together
- Complex workflows requiring consistency

## Request Timeouts

Clients can set custom timeout durations:

```go
client.SetTimeout(5 * time.Second)
```

**Default:** 30 seconds

**Behavior:**
- Timeout applies per request
- Deadline is set on the socket connection
- Network-level timeout (not just read/write)
- Returns timeout error if exceeded

## Stress Tests

### TestStressConcurrentAgents
- **Agents:** 8 concurrent
- **Operations:** 100 creates per agent (800 total)
- **Validates:** No ID collisions, no UNIQUE constraint errors
- **Duration:** ~2-3 seconds

### TestStressBatchOperations  
- **Agents:** 4 concurrent
- **Operations:** 50 batches per agent (400 total operations)
- **Validates:** Batch atomicity, no partial failures
- **Duration:** ~1-2 seconds

### TestStressMixedOperations
- **Agents:** 6 concurrent
- **Operations:** 50 mixed ops per agent (create, update, show, list, ready)
- **Validates:** Concurrent read/write safety
- **Duration:** <1 second

### TestStressTimeouts
- **Operations:** Timeout configuration and enforcement
- **Validates:** Timeout behavior, error handling
- **Duration:** <1 second

### TestStressNoUniqueConstraintViolations
- **Agents:** 10 concurrent
- **Operations:** 100 creates per agent (1000 total)
- **Validates:** Zero duplicate IDs across all agents
- **Duration:** ~3 seconds

## Performance Benchmarks

Run benchmarks with:
```bash
go test ./internal/rpc -bench=. -benchtime=1000x
```

### Results (Apple M4 Max, 16 cores)

| Operation | Direct Mode | Daemon Mode | Speedup |
|-----------|-------------|-------------|---------|
| Create    | 4.65 ms     | 2.41 ms     | 1.9x    |
| Update    | ~4.5 ms     | ~2.3 ms     | 2.0x    |
| List      | ~3.8 ms     | ~2.0 ms     | 1.9x    |
| Ping      | N/A         | 0.2 ms      | N/A     |

**Key Findings:**
- Daemon mode is consistently **2x faster** than direct mode
- Single persistent connection eliminates connection overhead
- Daemon handles serialization efficiently
- Low latency for simple operations (ping: 0.2ms)

### Concurrent Agent Throughput

8 agents creating 100 issues each:
- **Total Time:** 2.13s  
- **Throughput:** ~376 ops/sec
- **No errors or collisions**

## Acceptance Criteria Validation

✅ **4 concurrent agents can run without errors**
- Tests use 4-10 concurrent agents successfully

✅ **No UNIQUE constraint failures on ID generation**
- TestStressNoUniqueConstraintViolations validates 1000 unique IDs

✅ **No git index.lock errors**
- Daemon batches git operations (Phase 3)

✅ **SQLite counter stays in sync with actual issues**
- All tests verify correct issue counts

✅ **Graceful fallback when daemon not running**
- Client automatically falls back to direct mode

✅ **All existing tests pass**
- Full test suite passes with new features

✅ **Documentation updated**
- This document + DAEMON_DESIGN.md

## Running the Tests

```bash
# All stress tests
go test ./internal/rpc -v -run TestStress -timeout 5m

# All benchmarks
go test ./internal/rpc -bench=. -run=^$

# Specific stress test
go test ./internal/rpc -v -run TestStressConcurrentAgents

# Compare daemon vs direct
go test ./internal/rpc -bench=BenchmarkDaemon -benchtime=100x
go test ./internal/rpc -bench=BenchmarkDirect -benchtime=100x
```

## Implementation Details

### Batch Handler (server.go)
- Accepts `BatchArgs` with array of operations
- Executes operations sequentially
- Stops on first error
- Returns all results up to failure

### Timeout Support (client.go)
- Default 30s timeout per request
- `SetTimeout()` allows customization
- Uses `SetDeadline()` on socket connection
- Applies to read and write operations

### Connection Management
- Each client maintains one persistent connection
- Server handles multiple client connections concurrently
- No connection pooling needed (single daemon writer)
- Clean shutdown removes socket file

## Future Improvements

Potential enhancements for future phases:

1. **True Transactions:** SQLite BEGIN/COMMIT for batch operations
2. **Partial Batch Success:** Option to continue on errors
3. **Progress Callbacks:** Long-running batch status updates
4. **Connection Pooling:** Multiple daemon workers with work queue
5. **Distributed Mode:** Multi-machine daemon coordination

## See Also

- [DAEMON_DESIGN.md](DAEMON_DESIGN.md) - Overall daemon architecture
- [internal/rpc/protocol.go](internal/rpc/protocol.go) - RPC protocol definitions
- [internal/rpc/stress_test.go](internal/rpc/stress_test.go) - Stress test implementations
- [internal/rpc/bench_test.go](internal/rpc/bench_test.go) - Performance benchmarks