@tachui/core 0.7.0-alpha1

package/src/validation/performance-optimizer.ts

@@ -0,0 +1,599 @@
+/**
+ * Performance Optimization System - Phase 1C
+ * 
+ * Advanced performance optimizations to reduce validation overhead
+ * to <5% impact in development mode with smart caching and batching.
+ */
+
+import { ProductionModeManager } from './production-bypass'
+import { validationDebugger } from './debug-tools'
+
+/**
+ * Performance optimization configuration
+ */
+export interface PerformanceOptimizerConfig {
+  enabled: boolean
+  targetOverhead: number // percentage (5 = 5%)
+  batchSize: number
+  cacheStrategy: 'aggressive' | 'moderate' | 'conservative'
+  asyncValidation: boolean
+  throttleMs: number
+  skipFrames: number // Skip validation every N frames
+}
+
+/**
+ * Validation operation metrics
+ */
+export interface ValidationMetrics {
+  operationCount: number
+  totalTime: number
+  averageTime: number
+  maxTime: number
+  cacheHitRate: number
+  skipRate: number
+}
+
+/**
+ * Performance optimization engine
+ */
+export class PerformanceOptimizer {
+  private static instance: PerformanceOptimizer
+  private config: PerformanceOptimizerConfig
+  private metrics = new Map<string, ValidationMetrics>()
+  private operationQueue: Array<() => void> = []
+  private frameCounter = 0
+  private lastBatchTime = 0
+  private throttleTimers = new Map<string, number>()
+  
+  // Advanced caching
+  private resultCache = new Map<string, { result: any; timestamp: number; hits: number }>()
+  
+  // Performance monitoring
+  private performanceObserver?: PerformanceObserver
+  private frameTimeTarget = 16.67 // 60fps target
+
+  constructor(config: Partial<PerformanceOptimizerConfig> = {}) {
+    this.config = {
+      enabled: process.env.NODE_ENV !== 'production',
+      targetOverhead: 5, // 5% overhead target
+      batchSize: 10,
+      cacheStrategy: 'moderate',
+      asyncValidation: true,
+      throttleMs: 16, // One frame
+      skipFrames: 0, // Don't skip by default
+      ...config
+    }
+
+    this.initializePerformanceMonitoring()
+  }
+
+  static getInstance(config?: Partial<PerformanceOptimizerConfig>): PerformanceOptimizer {
+    if (!this.instance) {
+      this.instance = new PerformanceOptimizer(config)
+    }
+    return this.instance
+  }
+
+  /**
+   * Optimize validation function with caching and batching
+   */
+  optimizeValidation<T>(
+    key: string,
+    validationFn: () => T,
+    options: {
+      cache?: boolean
+      batch?: boolean
+      throttle?: boolean
+      priority?: 'high' | 'medium' | 'low'
+    } = {}
+  ): T | Promise<T> {
+    // Skip optimization in production
+    if (ProductionModeManager.shouldBypassValidation()) {
+      return validationFn()
+    }
+
+    const {
+      cache = true,
+      batch = false,
+      throttle = false,
+      priority = 'medium'
+    } = options
+
+    // Check cache first
+    if (cache) {
+      const cached = this.getCachedResult(key)
+      if (cached !== undefined) {
+        this.updateMetrics(key, 0, true, false) // Cache hit
+        return cached
+      }
+    }
+
+    // Apply frame skipping if configured
+    if (this.shouldSkipFrame()) {
+      this.updateMetrics(key, 0, false, true) // Skipped
+      return this.getFallbackResult()
+    }
+
+    // Apply throttling
+    if (throttle && this.isThrottled(key)) {
+      return this.getFallbackResult()
+    }
+
+    const startTime = performance.now()
+
+    try {
+      let result: T
+
+      if (batch && priority !== 'high') {
+        // Add to batch queue for low priority operations
+        return this.addToBatch(key, validationFn, cache) as Promise<T>
+      } else {
+        // Execute immediately
+        result = validationFn()
+      }
+
+      const endTime = performance.now()
+      const duration = endTime - startTime
+
+      // Cache result if enabled
+      if (cache) {
+        this.cacheResult(key, result)
+      }
+
+      // Update metrics
+      this.updateMetrics(key, duration, false, false)
+
+      // Check performance impact
+      this.checkPerformanceImpact(duration)
+
+      return result
+
+    } catch (error) {
+      const endTime = performance.now()
+      this.updateMetrics(key, endTime - startTime, false, false)
+      throw error
+    }
+  }
+
+  /**
+   * Smart caching with TTL and popularity-based eviction
+   */
+  private getCachedResult(key: string): any {
+    const cached = this.resultCache.get(key)
+    if (!cached) return undefined
+
+    // Check TTL based on cache strategy
+    const ttl = this.getCacheTTL()
+    if (Date.now() - cached.timestamp > ttl) {
+      this.resultCache.delete(key)
+      return undefined
+    }
+
+    // Update hit count
+    cached.hits++
+    return cached.result
+  }
+
+  /**
+   * Cache result with intelligent eviction
+   */
+  private cacheResult(key: string, result: any): void {
+    const maxCacheSize = this.getMaxCacheSize()
+    
+    // Evict least popular entries if cache is full
+    if (this.resultCache.size >= maxCacheSize) {
+      this.evictLeastPopular()
+    }
+
+    this.resultCache.set(key, {
+      result,
+      timestamp: Date.now(),
+      hits: 1
+    })
+  }
+
+  /**
+   * Evict least popular cache entries
+   */
+  private evictLeastPopular(): void {
+    const entries = Array.from(this.resultCache.entries())
+    
+    // Sort by hits (ascending) and timestamp (ascending)
+    entries.sort((a, b) => {
+      if (a[1].hits !== b[1].hits) {
+        return a[1].hits - b[1].hits
+      }
+      return a[1].timestamp - b[1].timestamp
+    })
+
+    // Remove bottom 25%
+    const removeCount = Math.floor(entries.length * 0.25)
+    for (let i = 0; i < removeCount; i++) {
+      this.resultCache.delete(entries[i][0])
+    }
+  }
+
+  /**
+   * Get cache TTL based on strategy
+   */
+  private getCacheTTL(): number {
+    switch (this.config.cacheStrategy) {
+      case 'aggressive': return 300000 // 5 minutes
+      case 'moderate': return 60000   // 1 minute
+      case 'conservative': return 10000 // 10 seconds
+      default: return 60000
+    }
+  }
+
+  /**
+   * Get max cache size based on strategy
+   */
+  private getMaxCacheSize(): number {
+    switch (this.config.cacheStrategy) {
+      case 'aggressive': return 1000
+      case 'moderate': return 500
+      case 'conservative': return 100
+      default: return 500
+    }
+  }
+
+  /**
+   * Check if operation should skip this frame
+   */
+  private shouldSkipFrame(): boolean {
+    if (this.config.skipFrames === 0) return false
+    
+    this.frameCounter++
+    return this.frameCounter % (this.config.skipFrames + 1) !== 0
+  }
+
+  /**
+   * Check if operation is throttled
+   */
+  private isThrottled(key: string): boolean {
+    const lastTime = this.throttleTimers.get(key) || 0
+    const now = Date.now()
+    
+    if (now - lastTime < this.config.throttleMs) {
+      return true
+    }
+    
+    this.throttleTimers.set(key, now)
+    return false
+  }
+
+  /**
+   * Add operation to batch queue
+   */
+  private addToBatch<T>(key: string, fn: () => T, cache: boolean): Promise<T> {
+    return new Promise((resolve, reject) => {
+      this.operationQueue.push(() => {
+        try {
+          const result = fn()
+          if (cache) {
+            this.cacheResult(key, result)
+          }
+          resolve(result)
+        } catch (error) {
+          reject(error)
+        }
+      })
+
+      // Process batch if it's full or enough time has passed
+      this.processBatchIfReady()
+    })
+  }
+
+  /**
+   * Process batch queue if conditions are met
+   */
+  private processBatchIfReady(): void {
+    const now = Date.now()
+    const shouldProcess = 
+      this.operationQueue.length >= this.config.batchSize ||
+      (this.operationQueue.length > 0 && now - this.lastBatchTime > this.config.throttleMs)
+
+    if (shouldProcess) {
+      this.processBatch()
+    }
+  }
+
+  /**
+   * Process batch queue
+   */
+  private processBatch(): void {
+    if (this.operationQueue.length === 0) return
+
+    const batch = this.operationQueue.splice(0, this.config.batchSize)
+    this.lastBatchTime = Date.now()
+
+    if (this.config.asyncValidation) {
+      // Process asynchronously to not block the main thread
+      setTimeout(() => {
+        batch.forEach(operation => operation())
+      }, 0)
+    } else {
+      // Process synchronously
+      batch.forEach(operation => operation())
+    }
+  }
+
+  /**
+   * Update operation metrics
+   */
+  private updateMetrics(key: string, duration: number, cacheHit: boolean, skipped: boolean): void {
+    let metrics = this.metrics.get(key)
+    if (!metrics) {
+      metrics = {
+        operationCount: 0,
+        totalTime: 0,
+        averageTime: 0,
+        maxTime: 0,
+        cacheHitRate: 0,
+        skipRate: 0
+      }
+      this.metrics.set(key, metrics)
+    }
+
+    metrics.operationCount++
+    
+    if (!cacheHit && !skipped) {
+      metrics.totalTime += duration
+      metrics.averageTime = metrics.totalTime / metrics.operationCount
+      metrics.maxTime = Math.max(metrics.maxTime, duration)
+    }
+
+    // Update rates
+    const totalOperations = metrics.operationCount
+    const cacheHits = Math.floor(metrics.cacheHitRate * totalOperations) + (cacheHit ? 1 : 0)
+    const skips = Math.floor(metrics.skipRate * totalOperations) + (skipped ? 1 : 0)
+    
+    metrics.cacheHitRate = cacheHits / totalOperations
+    metrics.skipRate = skips / totalOperations
+  }
+
+  /**
+   * Check if performance impact exceeds target
+   */
+  private checkPerformanceImpact(duration: number): void {
+    const frameTime = this.frameTimeTarget
+    const impactPercentage = (duration / frameTime) * 100
+
+    if (impactPercentage > this.config.targetOverhead) {
+      // Automatically adjust optimization settings
+      this.autoOptimize(impactPercentage)
+      
+      validationDebugger.logEvent(
+        'performance-warning',
+        `Validation overhead: ${impactPercentage.toFixed(1)}% (target: ${this.config.targetOverhead}%)`,
+        { duration, target: this.config.targetOverhead, actual: impactPercentage }
+      )
+    }
+  }
+
+  /**
+   * Automatically adjust optimization settings
+   */
+  private autoOptimize(currentImpact: number): void {
+    const factor = currentImpact / this.config.targetOverhead
+
+    if (factor > 2) {
+      // Very high impact - aggressive optimization
+      this.config.cacheStrategy = 'aggressive'
+      this.config.skipFrames = Math.max(1, this.config.skipFrames)
+      this.config.throttleMs = Math.max(this.config.throttleMs, 32)
+      this.config.batchSize = Math.min(this.config.batchSize, 5)
+    } else if (factor > 1.5) {
+      // High impact - moderate optimization
+      this.config.cacheStrategy = 'aggressive'
+      this.config.throttleMs = Math.max(this.config.throttleMs, 16)
+    }
+  }
+
+  /**
+   * Get fallback result for skipped/throttled operations
+   */
+  private getFallbackResult(): any {
+    // Return a safe default that won't cause errors
+    // In practice, this would be context-specific
+    return true
+  }
+
+  /**
+   * Initialize performance monitoring
+   */
+  private initializePerformanceMonitoring(): void {
+    if (typeof PerformanceObserver !== 'undefined') {
+      try {
+        this.performanceObserver = new PerformanceObserver((list) => {
+          const entries = list.getEntries()
+          entries.forEach((entry) => {
+            if (entry.name.includes('tachui-validation')) {
+              this.analyzePerformanceEntry(entry)
+            }
+          })
+        })
+        
+        this.performanceObserver.observe({ entryTypes: ['measure', 'navigation', 'paint'] })
+      } catch (_error) {
+        // PerformanceObserver not supported
+      }
+    }
+  }
+
+  /**
+   * Analyze performance entry
+   */
+  private analyzePerformanceEntry(entry: PerformanceEntry): void {
+    if (entry.duration > this.frameTimeTarget) {
+      console.warn(`⚠️ Slow validation operation: ${entry.name} took ${entry.duration.toFixed(2)}ms`)
+    }
+  }
+
+  /**
+   * Get performance statistics
+   */
+  getPerformanceStats() {
+    const totalOperations = Array.from(this.metrics.values())
+      .reduce((sum, metrics) => sum + metrics.operationCount, 0)
+    
+    const totalTime = Array.from(this.metrics.values())
+      .reduce((sum, metrics) => sum + metrics.totalTime, 0)
+    
+    const averageTime = totalOperations > 0 ? totalTime / totalOperations : 0
+    
+    const cacheHitRate = Array.from(this.metrics.values())
+      .reduce((sum, metrics) => sum + metrics.cacheHitRate, 0) / this.metrics.size || 0
+    
+    const skipRate = Array.from(this.metrics.values())
+      .reduce((sum, metrics) => sum + metrics.skipRate, 0) / this.metrics.size || 0
+
+    return {
+      config: this.config,
+      totalOperations,
+      totalTime,
+      averageTime,
+      cacheHitRate,
+      skipRate,
+      cacheSize: this.resultCache.size,
+      queueSize: this.operationQueue.length,
+      frameImpact: (averageTime / this.frameTimeTarget) * 100,
+      targetMet: (averageTime / this.frameTimeTarget) * 100 <= this.config.targetOverhead,
+      operations: Object.fromEntries(this.metrics)
+    }
+  }
+
+  /**
+   * Clear all caches and reset metrics
+   */
+  reset(): void {
+    this.resultCache.clear()
+    this.metrics.clear()
+    this.operationQueue = []
+    this.throttleTimers.clear()
+    this.frameCounter = 0
+    this.lastBatchTime = 0
+  }
+
+  /**
+   * Configure optimizer
+   */
+  configure(config: Partial<PerformanceOptimizerConfig>): void {
+    this.config = { ...this.config, ...config }
+  }
+
+  /**
+   * Force process all batched operations
+   */
+  flush(): void {
+    while (this.operationQueue.length > 0) {
+      this.processBatch()
+    }
+  }
+
+  /**
+   * Get cache statistics
+   */
+  getCacheStats() {
+    const entries = Array.from(this.resultCache.values())
+    const totalHits = entries.reduce((sum, entry) => sum + entry.hits, 0)
+    const averageAge = entries.length > 0 
+      ? entries.reduce((sum, entry) => sum + (Date.now() - entry.timestamp), 0) / entries.length
+      : 0
+
+    return {
+      size: this.resultCache.size,
+      maxSize: this.getMaxCacheSize(),
+      totalHits,
+      averageAge,
+      strategy: this.config.cacheStrategy,
+      ttl: this.getCacheTTL()
+    }
+  }
+}
+
+// Global optimizer instance
+export const performanceOptimizer = PerformanceOptimizer.getInstance()
+
+// Performance optimization utilities
+export const PerformanceOptimizationUtils = {
+  /**
+   * Configure performance optimizer
+   */
+  configure: (config: Partial<PerformanceOptimizerConfig>) => 
+    performanceOptimizer.configure(config),
+
+  /**
+   * Get performance statistics
+   */
+  getStats: () => performanceOptimizer.getPerformanceStats(),
+
+  /**
+   * Get cache statistics
+   */
+  getCacheStats: () => performanceOptimizer.getCacheStats(),
+
+  /**
+   * Reset optimizer
+   */
+  reset: () => performanceOptimizer.reset(),
+
+  /**
+   * Flush batched operations
+   */
+  flush: () => performanceOptimizer.flush(),
+
+  /**
+   * Optimize validation function
+   */
+  optimize: <T>(
+    key: string,
+    fn: () => T,
+    options?: {
+      cache?: boolean
+      batch?: boolean
+      throttle?: boolean
+      priority?: 'high' | 'medium' | 'low'
+    }
+  ) => performanceOptimizer.optimizeValidation(key, fn, options),
+
+  /**
+   * Test performance optimization
+   */
+  test: () => {
+    console.group('⚡ Performance Optimization Test')
+    
+    try {
+      const startTime = performance.now()
+      
+      // Test optimization with different scenarios
+      const results = []
+      
+      // Test caching
+      for (let i = 0; i < 100; i++) {
+        const result = performanceOptimizer.optimizeValidation(
+          'test-cache',
+          () => Math.random(),
+          { cache: true }
+        )
+        results.push(result)
+      }
+      
+      const endTime = performance.now()
+      const duration = endTime - startTime
+      const stats = performanceOptimizer.getPerformanceStats()
+      
+      console.info('✅ Optimization system active:', stats.config.enabled)
+      console.info('✅ Test duration:', `${duration.toFixed(2)}ms`)
+      console.info('✅ Cache hit rate:', `${(stats.cacheHitRate * 100).toFixed(1)}%`)
+      console.info('✅ Frame impact:', `${stats.frameImpact.toFixed(1)}% (target: ${stats.config.targetOverhead}%)`)
+      console.info('✅ Target met:', stats.targetMet)
+      console.info('✅ Performance optimization is working correctly')
+      
+    } catch (error) {
+      console.error('❌ Performance optimization test failed:', error)
+    }
+    
+    console.groupEnd()
+  }
+}