CPU Usage Optimization - Complete Guide

# JavaScript CPU Profiling

# 1. Chrome DevTools Profiler
# Steps to profile CPU usage:
# 1. Open DevTools > Performance tab
# 2. Click record button
# 3. Perform operations to profile
# 4. Stop recording
# 5. Analyze CPU usage graph

# 2. Custom Performance Profiler
class PerformanceProfiler {
    constructor() {
        this.profiles = new Map();
        this.isProfiling = false;
    }
    
    startProfiling(name) {
        if (this.isProfiling) return;
        
        this.isProfiling = true;
        this.currentProfile = {
            name: name,
            startTime: performance.now(),
            marks: [],
            measures: []
        };
    }
    
    mark(label) {
        if (!this.isProfiling) return;
        
        const mark = {
            label: label,
            timestamp: performance.now()
        };
        
        this.currentProfile.marks.push(mark);
        performance.mark(label);
    }
    
    measure(name, startMark, endMark) {
        if (!this.isProfiling) return;
        
        const measure = {
            name: name,
            startMark: startMark,
            endMark: endMark,
            duration: performance.now() - this.currentProfile.startTime
        };
        
        this.currentProfile.measures.push(measure);
        performance.measure(name, startMark, endMark);
    }
    
    stopProfiling() {
        if (!this.isProfiling) return;
        
        this.currentProfile.endTime = performance.now();
        this.currentProfile.totalDuration = this.currentProfile.endTime - this.currentProfile.startTime;
        
        this.profiles.set(this.currentProfile.name, this.currentProfile);
        this.isProfiling = false;
        
        return this.currentProfile;
    }
    
    getProfile(name) {
        return this.profiles.get(name);
    }
    
    getAllProfiles() {
        return Array.from(this.profiles.values());
    }
}

# 3. Function Performance Monitor
class FunctionPerformanceMonitor {
    constructor() {
        this.functions = new Map();
        this.isMonitoring = false;
    }
    
    startMonitoring() {
        this.isMonitoring = true;
    }
    
    stopMonitoring() {
        this.isMonitoring = false;
    }
    
    wrapFunction(fn, name) {
        const self = this;
        
        return function(...args) {
            if (!self.isMonitoring) {
                return fn.apply(this, args);
            }
            
            const startTime = performance.now();
            const result = fn.apply(this, args);
            const endTime = performance.now();
            
            self.recordFunctionCall(name, endTime - startTime);
            
            return result;
        };
    }
    
    recordFunctionCall(name, duration) {
        if (!this.functions.has(name)) {
            this.functions.set(name, {
                calls: 0,
                totalDuration: 0,
                averageDuration: 0,
                minDuration: Infinity,
                maxDuration: 0
            });
        }
        
        const stats = this.functions.get(name);
        stats.calls++;
        stats.totalDuration += duration;
        stats.averageDuration = stats.totalDuration / stats.calls;
        stats.minDuration = Math.min(stats.minDuration, duration);
        stats.maxDuration = Math.max(stats.maxDuration, duration);
    }
    
    getFunctionStats(name) {
        return this.functions.get(name);
    }
    
    getAllStats() {
        return Array.from(this.functions.entries()).map(([name, stats]) => ({
            name,
            ...stats
        }));
    }
    
    getTopSlowestFunctions(limit = 10) {
        return this.getAllStats()
            .sort((a, b) => b.averageDuration - a.averageDuration)
            .slice(0, limit);
    }
}

# 4. CPU Usage Monitor
class CPUUsageMonitor {
    constructor() {
        this.isMonitoring = false;
        this.measurements = [];
        this.callback = null;
    }
    
    startMonitoring(callback, interval = 1000) {
        if (this.isMonitoring) return;
        
        this.isMonitoring = true;
        this.callback = callback;
        
        this.monitor(interval);
    }
    
    stopMonitoring() {
        this.isMonitoring = false;
        this.callback = null;
    }
    
    monitor(interval) {
        if (!this.isMonitoring) return;
        
        const measurement = this.getCPUUsage();
        this.measurements.push(measurement);
        
        if (this.callback) {
            this.callback(measurement);
        }
        
        setTimeout(() => this.monitor(interval), interval);
    }
    
    getCPUUsage() {
        const start = performance.now();
        
        // Perform a small computation to measure CPU usage
        let sum = 0;
        for (let i = 0; i < 1000000; i++) {
            sum += Math.random();
        }
        
        const end = performance.now();
        const duration = end - start;
        
        return {
            timestamp: Date.now(),
            duration: duration,
            cpuUsage: this.calculateCPUUsage(duration)
        };
    }
    
    calculateCPUUsage(duration) {
        // Simplified CPU usage calculation
        // In reality, you'd need more sophisticated measurement
        return Math.min(duration / 10, 100);
    }
    
    getAverageCPUUsage() {
        if (this.measurements.length === 0) return 0;
        
        const total = this.measurements.reduce((sum, m) => sum + m.cpuUsage, 0);
        return total / this.measurements.length;
    }
    
    getMeasurements() {
        return this.measurements;
    }
}

# 5. Performance Observer
class PerformanceObserver {
    constructor() {
        this.observers = new Map();
        this.isObserving = false;
    }
    
    startObserving() {
        if (this.isObserving) return;
        
        this.isObserving = true;
        
        // Observe navigation timing
        if ('PerformanceObserver' in window) {
            const navObserver = new window.PerformanceObserver((list) => {
                for (const entry of list.getEntries()) {
                    this.handleNavigationEntry(entry);
                }
            });
            
            navObserver.observe({ entryTypes: ['navigation'] });
            this.observers.set('navigation', navObserver);
        }
        
        // Observe resource timing
        if ('PerformanceObserver' in window) {
            const resourceObserver = new window.PerformanceObserver((list) => {
                for (const entry of list.getEntries()) {
                    this.handleResourceEntry(entry);
                }
            });
            
            resourceObserver.observe({ entryTypes: ['resource'] });
            this.observers.set('resource', resourceObserver);
        }
    }
    
    stopObserving() {
        this.isObserving = false;
        
        for (const observer of this.observers.values()) {
            observer.disconnect();
        }
        
        this.observers.clear();
    }
    
    handleNavigationEntry(entry) {
        console.log('Navigation entry:', {
            name: entry.name,
            duration: entry.duration,
            loadTime: entry.loadEventEnd - entry.loadEventStart,
            domContentLoaded: entry.domContentLoadedEventEnd - entry.domContentLoadedEventStart
        });
    }
    
    handleResourceEntry(entry) {
        console.log('Resource entry:', {
            name: entry.name,
            duration: entry.duration,
            size: entry.transferSize,
            type: entry.initiatorType
        });
    }
}

# JavaScript Optimization Strategies

# 1. Loop Optimization
// Bad - Inefficient loop
function inefficientLoop(array) {
    let result = [];
    for (let i = 0; i < array.length; i++) {
        if (array[i] > 0) {
            result.push(array[i] * 2);
        }
    }
    return result;
}

// Good - Optimized loop
function optimizedLoop(array) {
    const result = [];
    const length = array.length;
    
    for (let i = 0; i < length; i++) {
        const item = array[i];
        if (item > 0) {
            result.push(item * 2);
        }
    }
    
    return result;
}

// Better - Using modern methods
function modernLoop(array) {
    return array
        .filter(item => item > 0)
        .map(item => item * 2);
}

# 2. Function Optimization
// Bad - Inefficient function
function inefficientFunction(data) {
    let result = [];
    for (let i = 0; i < data.length; i++) {
        let processed = data[i];
        processed = processed.toUpperCase();
        processed = processed.trim();
        processed = processed.replace(/\s+/g, ' ');
        result.push(processed);
    }
    return result;
}

// Good - Optimized function
function optimizedFunction(data) {
    const result = [];
    const length = data.length;
    
    for (let i = 0; i < length; i++) {
        const processed = data[i]
            .toUpperCase()
            .trim()
            .replace(/\s+/g, ' ');
        result.push(processed);
    }
    
    return result;
}

# 3. Object Property Access Optimization
// Bad - Repeated property access
function inefficientPropertyAccess(obj) {
    if (obj.user && obj.user.profile && obj.user.profile.name) {
        return obj.user.profile.name.toUpperCase();
    }
    return '';
}

// Good - Cached property access
function optimizedPropertyAccess(obj) {
    const name = obj.user?.profile?.name;
    return name ? name.toUpperCase() : '';
}

# 4. String Optimization
// Bad - String concatenation in loop
function inefficientStringConcat(items) {
    let result = '';
    for (let i = 0; i < items.length; i++) {
        result += items[i] + ', ';
    }
    return result;
}

// Good - Array join
function optimizedStringConcat(items) {
    return items.join(', ');
}

# 5. Array Optimization
// Bad - Inefficient array operations
function inefficientArrayOps(array) {
    let result = [];
    for (let i = 0; i < array.length; i++) {
        if (array[i] > 0) {
            result.push(array[i]);
        }
    }
    return result;
}

// Good - Optimized array operations
function optimizedArrayOps(array) {
    return array.filter(item => item > 0);
}

# 6. Memory-Efficient Algorithms
class EfficientAlgorithms {
    // Efficient sorting
    static quickSort(array) {
        if (array.length <= 1) return array;
        
        const pivot = array[Math.floor(array.length / 2)];
        const left = array.filter(x => x < pivot);
        const middle = array.filter(x => x === pivot);
        const right = array.filter(x => x > pivot);
        
        return [...this.quickSort(left), ...middle, ...this.quickSort(right)];
    }
    
    // Efficient searching
    static binarySearch(array, target) {
        let left = 0;
        let right = array.length - 1;
        
        while (left <= right) {
            const mid = Math.floor((left + right) / 2);
            
            if (array[mid] === target) {
                return mid;
            } else if (array[mid] < target) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        
        return -1;
    }
    
    // Efficient deduplication
    static deduplicate(array) {
        const seen = new Set();
        const result = [];
        
        for (const item of array) {
            if (!seen.has(item)) {
                seen.add(item);
                result.push(item);
            }
        }
        
        return result;
    }
}

# 7. Caching and Memoization
class MemoizationCache {
    constructor() {
        this.cache = new Map();
    }
    
    memoize(fn, keyGenerator) {
        const self = this;
        
        return function(...args) {
            const key = keyGenerator ? keyGenerator(...args) : JSON.stringify(args);
            
            if (self.cache.has(key)) {
                return self.cache.get(key);
            }
            
            const result = fn.apply(this, args);
            self.cache.set(key, result);
            
            return result;
        };
    }
    
    clear() {
        this.cache.clear();
    }
    
    size() {
        return this.cache.size;
    }
}

// Usage
const cache = new MemoizationCache();
const expensiveFunction = (n) => {
    let result = 0;
    for (let i = 0; i < n; i++) {
        result += i;
    }
    return result;
};

const memoizedFunction = cache.memoize(expensiveFunction);

# 8. Debouncing and Throttling
class PerformanceOptimizer {
    static debounce(func, wait) {
        let timeout;
        return function executedFunction(...args) {
            const later = () => {
                clearTimeout(timeout);
                func(...args);
            };
            clearTimeout(timeout);
            timeout = setTimeout(later, wait);
        };
    }
    
    static throttle(func, limit) {
        let inThrottle;
        return function executedFunction(...args) {
            if (!inThrottle) {
                func.apply(this, args);
                inThrottle = true;
                setTimeout(() => inThrottle = false, limit);
            }
        };
    }
    
    static requestAnimationFrameThrottle(func) {
        let rafId;
        return function executedFunction(...args) {
            if (rafId) return;
            
            rafId = requestAnimationFrame(() => {
                func.apply(this, args);
                rafId = null;
            });
        };
    }
}

# Node.js CPU Optimization

# 1. Cluster Module for CPU Utilization
const cluster = require('cluster');
const numCPUs = require('os').cpus().length;

if (cluster.isMaster) {
    console.log(`Master ${process.pid} is running`);
    
    // Fork workers
    for (let i = 0; i < numCPUs; i++) {
        cluster.fork();
    }
    
    cluster.on('exit', (worker, code, signal) => {
        console.log(`Worker ${worker.process.pid} died`);
        cluster.fork(); // Restart worker
    });
} else {
    // Worker process
    const express = require('express');
    const app = express();
    
    app.get('/', (req, res) => {
        res.json({ pid: process.pid, message: 'Hello World' });
    });
    
    app.listen(3000, () => {
        console.log(`Worker ${process.pid} started`);
    });
}

# 2. Worker Threads for CPU-Intensive Tasks
const { Worker, isMainThread, parentPort, workerData } = require('worker_threads');

if (isMainThread) {
    // Main thread
    class CPUIntensiveTask {
        constructor() {
            this.workers = [];
            this.taskQueue = [];
        }
        
        async processTask(data) {
            return new Promise((resolve, reject) => {
                const worker = new Worker(__filename, {
                    workerData: data
                });
                
                worker.on('message', (result) => {
                    resolve(result);
                    worker.terminate();
                });
                
                worker.on('error', reject);
                worker.on('exit', (code) => {
                    if (code !== 0) {
                        reject(new Error(`Worker stopped with exit code ${code}`));
                    }
                });
            });
        }
    }
    
    const taskProcessor = new CPUIntensiveTask();
    
    // Example usage
    taskProcessor.processTask({ numbers: [1, 2, 3, 4, 5] })
        .then(result => console.log('Result:', result))
        .catch(error => console.error('Error:', error));
        
} else {
    // Worker thread
    const { numbers } = workerData;
    
    // CPU-intensive computation
    let result = 0;
    for (let i = 0; i < numbers.length; i++) {
        result += numbers[i] * numbers[i];
    }
    
    parentPort.postMessage({ result });
}

# 3. Process Monitoring
const os = require('os');
const fs = require('fs');

class ProcessMonitor {
    constructor() {
        this.metrics = {
            cpuUsage: 0,
            memoryUsage: 0,
            uptime: 0,
            loadAverage: [0, 0, 0]
        };
    }
    
    getCPUUsage() {
        const cpus = os.cpus();
        let totalIdle = 0;
        let totalTick = 0;
        
        cpus.forEach(cpu => {
            for (const type in cpu.times) {
                totalTick += cpu.times[type];
            }
            totalIdle += cpu.times.idle;
        });
        
        return {
            idle: totalIdle,
            total: totalTick,
            usage: 100 - (100 * totalIdle / totalTick)
        };
    }
    
    getMemoryUsage() {
        const total = os.totalmem();
        const free = os.freemem();
        const used = total - free;
        
        return {
            total: total,
            used: used,
            free: free,
            usage: (used / total) * 100
        };
    }
    
    getLoadAverage() {
        return os.loadavg();
    }
    
    getSystemInfo() {
        return {
            platform: os.platform(),
            arch: os.arch(),
            cpus: os.cpus().length,
            uptime: os.uptime(),
            hostname: os.hostname()
        };
    }
    
    startMonitoring(interval = 5000) {
        setInterval(() => {
            this.metrics = {
                cpuUsage: this.getCPUUsage(),
                memoryUsage: this.getMemoryUsage(),
                loadAverage: this.getLoadAverage(),
                timestamp: Date.now()
            };
            
            this.logMetrics();
        }, interval);
    }
    
    logMetrics() {
        console.log('System Metrics:', {
            cpu: `${this.metrics.cpuUsage.usage.toFixed(2)}%`,
            memory: `${this.metrics.memoryUsage.usage.toFixed(2)}%`,
            load: this.metrics.loadAverage.map(load => load.toFixed(2))
        });
    }
}

# 4. Performance Profiling
const v8 = require('v8');
const fs = require('fs');

class NodePerformanceProfiler {
    constructor() {
        this.profiles = [];
    }
    
    startProfiling(name) {
        v8.setFlagsFromString('--prof');
        console.log(`Started profiling: ${name}`);
    }
    
    stopProfiling(name) {
        v8.setFlagsFromString('--no-prof');
        console.log(`Stopped profiling: ${name}`);
    }
    
    takeHeapSnapshot(filename) {
        const snapshot = v8.getHeapSnapshot();
        const file = fs.createWriteStream(filename);
        snapshot.pipe(file);
        
        return new Promise((resolve, reject) => {
            file.on('finish', resolve);
            file.on('error', reject);
        });
    }
    
    getHeapStatistics() {
        return v8.getHeapStatistics();
    }
    
    getHeapSpaceStatistics() {
        return v8.getHeapSpaceStatistics();
    }
    
    forceGC() {
        if (global.gc) {
            global.gc();
        } else {
            console.warn('Garbage collection not available. Run with --expose-gc flag.');
        }
    }
}

# 5. CPU-Intensive Task Optimization
class CPUOptimizer {
    constructor() {
        this.taskQueue = [];
        this.isProcessing = false;
        this.maxConcurrentTasks = os.cpus().length;
        this.activeTasks = 0;
    }
    
    async addTask(task) {
        return new Promise((resolve, reject) => {
            this.taskQueue.push({
                task,
                resolve,
                reject
            });
            
            this.processQueue();
        });
    }
    
    async processQueue() {
        if (this.isProcessing || this.activeTasks >= this.maxConcurrentTasks) {
            return;
        }
        
        this.isProcessing = true;
        
        while (this.taskQueue.length > 0 && this.activeTasks < this.maxConcurrentTasks) {
            const { task, resolve, reject } = this.taskQueue.shift();
            this.activeTasks++;
            
            try {
                const result = await this.executeTask(task);
                resolve(result);
            } catch (error) {
                reject(error);
            } finally {
                this.activeTasks--;
            }
        }
        
        this.isProcessing = false;
    }
    
    async executeTask(task) {
        // Simulate CPU-intensive task
        return new Promise((resolve) => {
            setImmediate(() => {
                const result = task();
                resolve(result);
            });
        });
    }
}

# 6. Memory and CPU Optimization
class ResourceOptimizer {
    constructor() {
        this.memoryThreshold = 0.8; // 80% memory usage
        this.cpuThreshold = 0.8; // 80% CPU usage
        this.isOptimizing = false;
    }
    
    startOptimization() {
        setInterval(() => {
            this.checkAndOptimize();
        }, 10000); // Check every 10 seconds
    }
    
    checkAndOptimize() {
        const memoryUsage = this.getMemoryUsage();
        const cpuUsage = this.getCPUUsage();
        
        if (memoryUsage > this.memoryThreshold || cpuUsage > this.cpuThreshold) {
            this.optimize();
        }
    }
    
    getMemoryUsage() {
        const memUsage = process.memoryUsage();
        const totalMem = require('os').totalmem();
        return memUsage.heapUsed / totalMem;
    }
    
    getCPUUsage() {
        const startUsage = process.cpuUsage();
        const startTime = Date.now();
        
        return new Promise((resolve) => {
            setTimeout(() => {
                const endUsage = process.cpuUsage(startUsage);
                const endTime = Date.now();
                
                const cpuPercent = (endUsage.user + endUsage.system) / 1000 / (endTime - startTime);
                resolve(cpuPercent);
            }, 100);
        });
    }
    
    optimize() {
        if (this.isOptimizing) return;
        
        this.isOptimizing = true;
        
        // Force garbage collection
        if (global.gc) {
            global.gc();
        }
        
        // Clear caches if needed
        this.clearCaches();
        
        this.isOptimizing = false;
    }
    
    clearCaches() {
        // Clear application caches
        if (global.appCache) {
            global.appCache.clear();
        }
    }
}

# Browser CPU Optimization

# 1. RequestAnimationFrame Optimization
class AnimationOptimizer {
    constructor() {
        this.animations = new Map();
        this.isRunning = false;
    }
    
    addAnimation(id, animationFunction) {
        this.animations.set(id, animationFunction);
        
        if (!this.isRunning) {
            this.startAnimationLoop();
        }
    }
    
    removeAnimation(id) {
        this.animations.delete(id);
        
        if (this.animations.size === 0) {
            this.stopAnimationLoop();
        }
    }
    
    startAnimationLoop() {
        this.isRunning = true;
        this.animate();
    }
    
    stopAnimationLoop() {
        this.isRunning = false;
    }
    
    animate() {
        if (!this.isRunning) return;
        
        // Execute all animations
        for (const animation of this.animations.values()) {
            animation();
        }
        
        // Schedule next frame
        requestAnimationFrame(() => this.animate());
    }
}

# 2. Web Workers for CPU-Intensive Tasks
class WebWorkerManager {
    constructor() {
        this.workers = new Map();
        this.taskQueue = [];
        this.maxWorkers = navigator.hardwareConcurrency || 4;
    }
    
    async executeTask(taskData, taskFunction) {
        return new Promise((resolve, reject) => {
            const worker = this.getAvailableWorker();
            
            if (worker) {
                this.executeTaskOnWorker(worker, taskData, taskFunction, resolve, reject);
            } else {
                this.taskQueue.push({ taskData, taskFunction, resolve, reject });
            }
        });
    }
    
    getAvailableWorker() {
        for (const [id, worker] of this.workers) {
            if (worker.busy === false) {
                return worker;
            }
        }
        
        if (this.workers.size < this.maxWorkers) {
            return this.createWorker();
        }
        
        return null;
    }
    
    createWorker() {
        const workerId = `worker-${Date.now()}`;
        const worker = new Worker(URL.createObjectURL(new Blob([`
            self.onmessage = function(e) {
                const { taskData, taskFunction } = e.data;
                
                try {
                    const result = eval('(' + taskFunction + ')')(taskData);
                    self.postMessage({ success: true, result });
                } catch (error) {
                    self.postMessage({ success: false, error: error.message });
                }
            };
        `], { type: 'application/javascript' })));
        
        worker.busy = false;
        this.workers.set(workerId, worker);
        
        return worker;
    }
    
    executeTaskOnWorker(worker, taskData, taskFunction, resolve, reject) {
        worker.busy = true;
        
        const handleMessage = (e) => {
            worker.removeEventListener('message', handleMessage);
            worker.busy = false;
            
            if (e.data.success) {
                resolve(e.data.result);
            } else {
                reject(new Error(e.data.error));
            }
            
            this.processQueue();
        };
        
        worker.addEventListener('message', handleMessage);
        worker.postMessage({ taskData, taskFunction });
    }
    
    processQueue() {
        if (this.taskQueue.length === 0) return;
        
        const worker = this.getAvailableWorker();
        if (worker) {
            const { taskData, taskFunction, resolve, reject } = this.taskQueue.shift();
            this.executeTaskOnWorker(worker, taskData, taskFunction, resolve, reject);
        }
    }
}

# 3. CPU Usage Monitor
class BrowserCPUMonitor {
    constructor() {
        this.isMonitoring = false;
        this.measurements = [];
        this.callback = null;
    }
    
    startMonitoring(callback, interval = 1000) {
        if (this.isMonitoring) return;
        
        this.isMonitoring = true;
        this.callback = callback;
        
        this.monitor(interval);
    }
    
    stopMonitoring() {
        this.isMonitoring = false;
        this.callback = null;
    }
    
    monitor(interval) {
        if (!this.isMonitoring) return;
        
        const measurement = this.measureCPUUsage();
        this.measurements.push(measurement);
        
        if (this.callback) {
            this.callback(measurement);
        }
        
        setTimeout(() => this.monitor(interval), interval);
    }
    
    measureCPUUsage() {
        const start = performance.now();
        
        // Perform a small computation to measure CPU usage
        let sum = 0;
        for (let i = 0; i < 100000; i++) {
            sum += Math.random();
        }
        
        const end = performance.now();
        const duration = end - start;
        
        return {
            timestamp: Date.now(),
            duration: duration,
            cpuUsage: this.calculateCPUUsage(duration)
        };
    }
    
    calculateCPUUsage(duration) {
        // Simplified CPU usage calculation
        return Math.min(duration / 5, 100);
    }
    
    getAverageCPUUsage() {
        if (this.measurements.length === 0) return 0;
        
        const total = this.measurements.reduce((sum, m) => sum + m.cpuUsage, 0);
        return total / this.measurements.length;
    }
}

# 4. Performance Budget Monitor
class PerformanceBudgetMonitor {
    constructor(budget) {
        this.budget = {
            maxCPUUsage: 50, // 50% CPU usage
            maxMemoryUsage: 100, // 100MB memory usage
            maxExecutionTime: 100, // 100ms execution time
            ...budget
        };
        
        this.violations = [];
    }
    
    checkBudget(metrics) {
        const violations = [];
        
        if (metrics.cpuUsage > this.budget.maxCPUUsage) {
            violations.push({
                type: 'cpu_usage',
                value: metrics.cpuUsage,
                limit: this.budget.maxCPUUsage,
                severity: 'warning'
            });
        }
        
        if (metrics.memoryUsage > this.budget.maxMemoryUsage) {
            violations.push({
                type: 'memory_usage',
                value: metrics.memoryUsage,
                limit: this.budget.maxMemoryUsage,
                severity: 'error'
            });
        }
        
        if (metrics.executionTime > this.budget.maxExecutionTime) {
            violations.push({
                type: 'execution_time',
                value: metrics.executionTime,
                limit: this.budget.maxExecutionTime,
                severity: 'warning'
            });
        }
        
        this.violations.push(...violations);
        return violations;
    }
    
    getViolations() {
        return this.violations;
    }
    
    generateReport() {
        return {
            budget: this.budget,
            violations: this.violations,
            summary: {
                totalViolations: this.violations.length,
                errors: this.violations.filter(v => v.severity === 'error').length,
                warnings: this.violations.filter(v => v.severity === 'warning').length
            }
        };
    }
}

# 5. CPU-Intensive Task Scheduler
class TaskScheduler {
    constructor() {
        this.tasks = [];
        this.isRunning = false;
        this.maxExecutionTime = 5; // 5ms per task
    }
    
    addTask(task, priority = 0) {
        this.tasks.push({ task, priority, id: Date.now() });
        this.tasks.sort((a, b) => b.priority - a.priority);
        
        if (!this.isRunning) {
            this.startScheduler();
        }
    }
    
    startScheduler() {
        this.isRunning = true;
        this.schedule();
    }
    
    stopScheduler() {
        this.isRunning = false;
    }
    
    schedule() {
        if (!this.isRunning || this.tasks.length === 0) {
            this.isRunning = false;
            return;
        }
        
        const startTime = performance.now();
        
        while (this.tasks.length > 0 && (performance.now() - startTime) < this.maxExecutionTime) {
            const { task } = this.tasks.shift();
            
            try {
                task();
            } catch (error) {
                console.error('Task execution error:', error);
            }
        }
        
        if (this.tasks.length > 0) {
            requestIdleCallback(() => this.schedule());
        } else {
            this.isRunning = false;
        }
    }
}

# 6. CPU Optimization Utilities
class CPUOptimizationUtils {
    static debounce(func, wait) {
        let timeout;
        return function executedFunction(...args) {
            const later = () => {
                clearTimeout(timeout);
                func(...args);
            };
            clearTimeout(timeout);
            timeout = setTimeout(later, wait);
        };
    }
    
    static throttle(func, limit) {
        let inThrottle;
        return function executedFunction(...args) {
            if (!inThrottle) {
                func.apply(this, args);
                inThrottle = true;
                setTimeout(() => inThrottle = false, limit);
            }
        };
    }
    
    static requestAnimationFrameThrottle(func) {
        let rafId;
        return function executedFunction(...args) {
            if (rafId) return;
            
            rafId = requestAnimationFrame(() => {
                func.apply(this, args);
                rafId = null;
            });
        };
    }
    
    static requestIdleCallbackThrottle(func) {
        let icbId;
        return function executedFunction(...args) {
            if (icbId) return;
            
            icbId = requestIdleCallback(() => {
                func.apply(this, args);
                icbId = null;
            });
        };
    }
}