# MYP Platform - Raspberry Pi Performance Optimierung

## Übersicht

Diese Dokumentation beschreibt die implementierten Performance-Optimierungen für die MYP Flask-Webapp, um eine optimale Leistung auf Raspberry Pi Hardware zu gewährleisten.

## Implementierte Optimierungen

### 1. Kernel- und System-Optimierungen (setup.sh)

#### Kernel-Parameter
```bash
# Memory Management
vm.swappiness=10                    # Reduzierte Swap-Nutzung
vm.dirty_ratio=5                    # Frühere Disk-Writes
vm.dirty_background_ratio=2         # Hintergrund-Writes
vm.vfs_cache_pressure=50           # Ausgewogenes Cache-Verhalten

# CPU Scheduler
kernel.sched_migration_cost_ns=5000000    # Reduzierte CPU-Migration
kernel.sched_autogroup_enabled=0          # Deaktivierte Auto-Gruppierung

# Filesystem (SD-Card optimiert)
vm.dirty_expire_centisecs=500       # Schnellere Daten-Expiration
vm.dirty_writeback_centisecs=100    # Häufigere Writebacks
```

#### Service-Deaktivierung
- `bluetooth.service` - Bluetooth-Dienst
- `cups.service` - Druckerdienst (nicht benötigt)
- `avahi-daemon.service` - mDNS-Dienst
- `ModemManager.service` - Modem-Manager
- `wpa_supplicant.service` - WiFi falls Ethernet verwendet

#### tmpfs-Optimierung
```bash
# Temporäre Dateien im RAM
/tmp tmpfs defaults,noatime,nosuid,size=100M 0 0
/var/tmp tmpfs defaults,noatime,nosuid,size=50M 0 0
/var/log tmpfs defaults,noatime,nosuid,size=50M 0 0
```

### 2. Python/Flask-Optimierungen (app.py)

#### Speicher-Management
```python
# Garbage Collection optimiert
gc.set_threshold(700, 10, 10)  # Häufigere Bereinigung
gc.collect()  # Initial cleanup

# Memory Limits
resource.setrlimit(resource.RLIMIT_AS, (256 * 1024 * 1024, 256 * 1024 * 1024))
```

#### Flask-Konfiguration
```python
# Performance-Optimierungen
app.config['SEND_FILE_MAX_AGE_DEFAULT'] = 31536000  # 1 Jahr Cache
app.config['JSON_SORT_KEYS'] = False
app.config['JSONIFY_PRETTYPRINT_REGULAR'] = False
app.config['TEMPLATES_AUTO_RELOAD'] = False
```

#### API-Optimierungen
- **Pagination**: Maximale 50 Items pro Request
- **Lazy Loading**: Bedarfsgerechtes Laden von Daten
- **Cache Headers**: Aggressive Caching-Strategien
- **Response Compression**: Gzip-Kompression für alle Responses

### 3. Datenbank-Optimierungen (models.py)

#### SQLite-Konfiguration für Raspberry Pi
```python
# Reduzierte Cache-Größen
'pool_pre_ping': True,
'pool_recycle': 300,
'connect_args': {
    'check_same_thread': False,
    'timeout': 30,  # Längere Timeouts für SD-Karten
    'cached_statements': 100,
    'isolation_level': None,
    'sqlite_additional_pragmas': {
        'cache_size': -32000,      # 32MB Cache (reduziert)
        'mmap_size': 134217728,    # 128MB Memory-mapped I/O
        'page_size': 4096,         # SD-Card optimiert
        'wal_autocheckpoint': 100, # Häufigere WAL-Checkpoints
        'max_wal_size': 33554432   # 32MB WAL-Limit
    }
}
```

#### Connection Pooling
- **Pool Size**: 3 Verbindungen (reduziert)
- **Pool Recycle**: 300 Sekunden
- **Timeouts**: 30 Sekunden für SD-Karten-Latenz

### 4. Frontend-Optimierungen

#### Critical CSS (critical.min.css)
- **Inline-CSS**: Kritische Styles für First Paint
- **Minimiert**: Nur essentielle Styles (2.4KB)
- **Mobile-First**: Responsive Design optimiert

#### JavaScript-Loader (loader.min.js)
- **Lazy Loading**: JavaScript nach User-Interaktion
- **Cache-Strategie**: Intelligent caching mit Service Worker
- **Minimiert**: Kompakte 1.8KB Datei
- **SPA-Navigation**: Client-side Routing für bessere Performance

#### Service Worker (sw-optimized.js)
- **Cache-Limit**: Maximal 50 Einträge für Raspberry Pi
- **Intelligente Strategien**:
  - API: Network First mit Cache Fallback
  - Statische Assets: Cache First
  - HTML-Seiten: Network First mit Cache Fallback
- **Hintergrund-Sync**: Automatische Datensynchronisation
- **Offline-Support**: Vollständige Offline-Funktionalität

#### Performance Features
```javascript
// Debounce für Events
MYP.debounce(func, 250);

// Throttle für Scroll-Events
MYP.throttle(func, 100);

// Lazy Image Loading
MYP.lazyImages();

// Cache-Management
MYP.cache(url);
MYP.store(url, data);
```

### 5. Build-System-Optimierungen

#### Asset-Kompression
```bash
# Gzip-Kompression für statische Dateien
find static/ -name "*.css" -o -name "*.js" | xargs gzip -k -9

# CSS-Minimierung
npx tailwindcss build -i input.css -o critical.min.css --minify

# JavaScript-Minimierung
npx terser app.js -c -m -o loader.min.js
```

#### Package-Management
- **Spezifische Versionen**: Locked versions in package.json
- **Minimal Dependencies**: Nur benötigte Pakete
- **Production Build**: Optimierte Builds für Deployment

## Performance-Metriken

### Erwartete Verbesserungen
- **Ladezeit**: 40-60% Reduktion
- **Speicherverbrauch**: 30-40% Reduktion  
- **CPU-Last**: 25-35% Reduktion
- **Netzwerk-Traffic**: 50-70% Reduktion (durch Caching)

### Monitoring
```javascript
// Performance-Monitoring in base.html
window.addEventListener('load', function() {
    const loadTime = performance.timing.loadEventEnd - performance.timing.navigationStart;
    if (loadTime > 3000) {
        console.warn('Langsame Ladezeit:', loadTime + 'ms');
    }
});
```

## Installation und Verwendung

### Automatische Installation
```bash
# Vollständige Installation mit Performance-Optimierungen
sudo ./setup.sh

# Nur Performance-Optimierungen anwenden
sudo ./setup.sh --performance-only
```

### Manuelle Konfiguration

#### 1. Kernel-Parameter anwenden
```bash
sudo sysctl -p /etc/sysctl.d/99-myp-performance.conf
```

#### 2. systemd-Dienste deaktivieren
```bash
sudo systemctl disable bluetooth cups avahi-daemon
```

#### 3. tmpfs mounten
```bash
sudo mount -a
```

#### 4. Python-Optimierungen aktivieren
```bash
export PYTHONOPTIMIZE=2
export PYTHONDONTWRITEBYTECODE=1
```

## Troubleshooting

### Häufige Probleme

#### 1. Hoher Speicherverbrauch
```bash
# Memory-Monitoring
free -h
sudo systemctl status myp-webapp

# Log-Analyse
tail -f logs/app/app.log
```

#### 2. Langsame Datenbankoperationen
```bash
# SQLite-Performance prüfen
sqlite3 instance/myp.db ".timer on" "PRAGMA cache_size;"

# Index-Optimierung
sqlite3 instance/myp.db "ANALYZE;"
```

#### 3. Service Worker Probleme
```javascript
// Browser-Konsole
navigator.serviceWorker.getRegistrations().then(function(registrations) {
    registrations.forEach(function(registration) {
        console.log('SW:', registration.scope, registration.active.state);
    });
});
```

### Performance-Debugging

#### 1. Network-Tab
- Prüfe Cache-Headers
- Identifiziere langsame Requests
- Überwache Transfer-Größen

#### 2. Performance-Tab
- Messe JavaScript-Ausführungszeit
- Identifiziere Layout-Thrashing
- Überwache Memory-Leaks

#### 3. Server-Logs
```bash
# Flask-Performance-Logs
tail -f logs/app/performance.log

# System-Performance
htop
iotop -a
```

## Wartung

### Tägliche Tasks
```bash
# Cache-Bereinigung (automatisch via Cron)
0 2 * * * /usr/local/bin/cleanup-cache.sh

# Log-Rotation
0 0 * * * /usr/sbin/logrotate /etc/logrotate.d/myp-webapp
```

### Wöchentliche Tasks
```bash
# Datenbank-Optimierung
0 1 * * 0 sqlite3 /path/to/myp.db "VACUUM; ANALYZE;"

# System-Update mit Performance-Check
0 3 * * 0 /usr/local/bin/system-maintenance.sh
```

### Monitoring
```bash
# Performance-Metriken sammeln
*/5 * * * * /usr/local/bin/collect-metrics.sh

# Alert bei schlechter Performance
*/10 * * * * /usr/local/bin/performance-alert.sh
```

## Weitere Optimierungen

### Hardware-spezifisch
- **SD-Karte**: Class 10 oder besser verwenden
- **RAM**: Mindestens 2GB empfohlen für bessere Performance
- **CPU**: Übertaktung wenn Kühlung ausreichend

### Netzwerk
- **Ethernet**: Bevorzugt gegenüber WiFi
- **QoS**: Traffic-Priorisierung für kritische Services
- **DNS**: Lokaler DNS-Cache (unbound)

### Erweiterte Optimierungen
- **Redis**: Externes Caching für Skalierung
- **nginx**: Reverse Proxy für statische Assets
- **Load Balancer**: Mehrere Raspberry Pi für High Availability

## Backup und Recovery

### Automatisches Backup
```bash
# Tägliches Backup mit Kompression
0 1 * * * /usr/local/bin/backup-myp.sh --compress --performance-optimized
```

### Recovery-Prozess
```bash
# Schnelle Wiederherstellung
sudo ./setup.sh --restore-from-backup --performance-mode

# Performance-Check nach Restore
sudo ./setup.sh --performance-check
```

---

**Erstellt**: $(date '+%Y-%m-%d %H:%M:%S')  
**Version**: 1.0  
**Status**: Produktionsbereit