# Tikker Performance Optimization Guide
## Performance Benchmarks
Baseline performance metrics on standard hardware (2CPU, 2GB RAM):
### API Service (C Tools Integration)
- Health Check: ~15ms (p50), <50ms (p99)
- Daily Stats: ~80ms (p50), <150ms (p99)
- Top Words: ~120ms (p50), <250ms (p99)
- Throughput: ~40-60 req/s
### AI Service
- Health Check: ~10ms (p50), <50ms (p99)
- Text Analysis: ~2-5s (depends on text length and API availability)
- Throughput: ~0.5 req/s (limited by OpenAI API)
### Visualization Service
- Health Check: ~12ms (p50), <50ms (p99)
- Bar Chart: ~150ms (p50), <300ms (p99)
- Line Chart: ~160ms (p50), <320ms (p99)
- Pie Chart: ~140ms (p50), <280ms (p99)
- Throughput: ~5-8 req/s
## Running Benchmarks
### Quick Benchmark
```bash
python scripts/benchmark.py
```
### Benchmark Against Remote Server
```bash
python scripts/benchmark.py http://production-server
```
### Detailed Test Results
```bash
pytest tests/test_performance.py -v --tb=short
```
## Optimization Strategies
### 1. Database Optimization
#### Vacuum Database
Regular database maintenance improves query performance.
```bash
docker-compose exec api sqlite3 tikker.db "VACUUM;"
```
Impact: 5-15% query speed improvement
#### Create Indexes
Add indexes for frequently queried columns:
```sql
CREATE INDEX idx_words_frequency ON words(frequency DESC);
CREATE INDEX idx_events_timestamp ON events(timestamp);
CREATE INDEX idx_events_date ON events(date);
```
Impact: 30-50% improvement for indexed queries
#### Query Optimization
Use EXPLAIN QUERY PLAN to analyze slow queries:
```bash
sqlite3 tikker.db "EXPLAIN QUERY PLAN SELECT * FROM words ORDER BY frequency LIMIT 10;"
```
### 2. Caching Strategies
#### Redis Caching for Frequent Queries
Add Redis for popular word list caching:
```python
import redis
cache = redis.Redis(host='localhost', port=6379)
def get_top_words(limit=10):
key = f"top_words:{limit}"
cached = cache.get(key)
if cached:
return json.loads(cached)
result = query_database(limit)
cache.setex(key, 3600, json.dumps(result))
return result
```
Impact: 10-100x improvement for cached queries
#### Add to docker-compose.yml:
```yaml
redis:
image: redis:7-alpine
ports:
- "6379:6379"
volumes:
- redis_data:/data
```
### 3. Python Optimization
#### Enable Optimization
```dockerfile
ENV PYTHONOPTIMIZE=2
ENV PYTHONDONTWRITEBYTECODE=1
```
#### Use Async I/O
Current API already uses FastAPI (async), good baseline.
#### Profile Code
Identify bottlenecks:
```bash
python -m cProfile -s cumtime -m pytest tests/test_services.py
```
### 4. C Tools Optimization
#### Compile Flags
Update Makefile with optimization flags:
```makefile
CFLAGS = -O3 -march=native -Wall -Wextra
```
Impact: 20-40% improvement in execution speed
#### Binary Stripping
Reduce binary size:
```bash
strip build/bin/tikker-*
```
Impact: Faster loading, reduced disk I/O
### 5. Network Optimization
#### Connection Pooling
Add HTTP connection pooling in wrapper:
```python
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry
session = requests.Session()
retry_strategy = Retry(
total=3,
backoff_factor=1,
status_forcelist=[429, 500, 502, 503, 504]
)
adapter = HTTPAdapter(max_retries=retry_strategy)
session.mount("http://", adapter)
```
#### Service Co-location
Run services on same host to reduce latency:
- Typical inter-service latency: ~5-10ms
- Same-host latency: <1ms
### 6. Memory Optimization
#### Monitor Memory Usage
```bash
docker stats
# Or detailed analysis
docker-compose exec api ps aux
```
#### Reduce Buffer Sizes
In c_tools_wrapper.py:
```python
# Limit concurrent subprocess calls
from concurrent.futures import ThreadPoolExecutor
executor = ThreadPoolExecutor(max_workers=4)
```
#### Garbage Collection Tuning
```python
import gc
gc.set_threshold(10000)
```
### 7. Container Resource Limits
Update docker-compose.yml:
```yaml
services:
api:
deploy:
resources:
limits:
cpus: '2'
memory: 2G
reservations:
cpus: '1'
memory: 1G
```
### 8. Load Balancing
For production deployments with multiple instances:
```yaml
nginx:
image: nginx:latest
ports:
- "8000:8000"
volumes:
- ./nginx.conf:/etc/nginx/nginx.conf:ro
depends_on:
- api1
- api2
- api3
```
nginx.conf:
```nginx
upstream api {
server api1:8000;
server api2:8000;
server api3:8000;
}
server {
listen 8000;
location / {
proxy_pass http://api;
proxy_connect_timeout 5s;
proxy_read_timeout 10s;
}
}
```
## Performance Tuning Checklist
- [ ] Database vacuumed and indexed
- [ ] Python optimization flags enabled
- [ ] C compilation optimizations applied
- [ ] Connection pooling configured
- [ ] Caching strategy implemented
- [ ] Memory limits set appropriately
- [ ] Load balancing configured (if needed)
- [ ] Monitoring and logging enabled
- [ ] Benchmarks show acceptable latency
- [ ] Throughput meets SLA requirements
## Monitoring Performance
### Key Metrics to Track
1. **Latency (p50, p95, p99)**
- Target: p50 <100ms, p99 <500ms
2. **Throughput (req/s)**
- Target: >20 req/s per service
3. **Error Rate**
- Target: <0.1%
4. **Resource Usage**
- CPU: <80% sustained
- Memory: <80% allocated
- Disk: <90% capacity
### Prometheus Metrics
Add to FastAPI apps:
```python
from prometheus_client import Counter, Histogram, generate_latest
request_count = Counter('api_requests_total', 'Total requests')
request_duration = Histogram('api_request_duration_seconds', 'Request duration')
@app.middleware("http")
async def add_metrics(request, call_next):
start = time.time()
response = await call_next(request)
duration = time.time() - start
request_count.inc()
request_duration.observe(duration)
return response
@app.get("/metrics")
def metrics():
return generate_latest()
```
## Troubleshooting Performance Issues
### High CPU Usage
1. Profile code: `python -m cProfile`
2. Check for infinite loops in C tools
3. Reduce concurrent operations
### High Memory Usage
1. Monitor with `docker stats`
2. Check for memory leaks in C code
3. Implement garbage collection tuning
4. Use connection pooling
### Slow Queries
1. Run EXPLAIN QUERY PLAN
2. Add missing indexes
3. Verify statistics are current
4. Consider query rewriting
### Network Latency
1. Check service co-location
2. Verify DNS resolution
3. Monitor with `tcpdump`
4. Consider service mesh (istio)
### Database Lock Issues
1. Check for long-running transactions
2. Verify concurrent access limits
3. Consider read replicas
4. Increase timeout values
## Advanced Optimization
### Async Database Access
Consider async SQLite driver for true async I/O:
```python
from aiosqlite import connect
async def get_stats():
async with connect('tikker.db') as db:
cursor = await db.execute('SELECT * FROM events')
return await cursor.fetchall()
```
### Compiled C Extensions
Convert performance-critical Python code to C extensions:
```c
// stats.c
PyObject* get_daily_stats(PyObject* self, PyObject* args) {
// High-performance C implementation
}
```
### Graph Query Optimization
For complex analyses, consider graph database:
```
Events → Words → Patterns
Analysis becomes graph traversal instead of SQL joins
```
## SLA Targets
Recommended SLA targets for Tikker:
| Metric | Target | Priority |
|--------|--------|----------|
| API Availability | 99.5% | Critical |
| Health Check Latency | <50ms | Critical |
| Stats Query Latency | <200ms | High |
| Word Search Latency | <300ms | High |
| Report Generation | <5s | Medium |
| AI Analysis | <10s | Low |
## Performance Testing in CI/CD
Add performance regression testing:
```bash
# Run baseline benchmark
python scripts/benchmark.py baseline
# Run benchmark
python scripts/benchmark.py current
# Compare and fail if regression
python scripts/compare_benchmarks.py baseline current --fail-if-slower 10%
```
## Further Reading
- SQLite Performance: https://www.sqlite.org/bestcase.html
- FastAPI Performance: https://fastapi.tiangolo.com/
- Python Optimization: https://docs.python.org/3/library/profile.html
Reference in New Issue View Git Blame Copy Permalink