PHP OPcache 生产环境高级配置指南 提高你的 PHP 应用运行速度 ​

<?php

// 可视化理解 OPcache 的影响

// 未启用 OPcache（每次请求都会）：
// 1. 解析 PHP 源码
// 2. 编译为字节码
// 3. 执行字节码
// 4. 丢弃字节码

// 启用 OPcache 后（首个请求）：
// 1. 解析 PHP 源码
// 2. 编译为字节码
// 3. 将字节码存入共享内存
// 4. 执行字节码

// 启用 OPcache 后（后续请求）：
// 1. 直接从共享内存取出字节码
// 2. 执行字节码（跳过解析和编译！）

// 在应用中监控 OPcache
class OPcacheMonitor
{
    public static function getStatus(): array
    {
        if (!function_exists('opcache_get_status')) {
            return ['error' => 'OPcache not available'];
        }

        $status = opcache_get_status(false);
        $config = opcache_get_configuration();

        return [
            'enabled' => $status !== false,
            'cache_full' => $status['cache_full'] ?? false,
            'restart_pending' => $status['restart_pending'] ?? false,
            'restart_in_progress' => $status['restart_in_progress'] ?? false,
            'memory_usage' => [
                'used_memory' => $status['memory_usage']['used_memory'] ?? 0,
                'free_memory' => $status['memory_usage']['free_memory'] ?? 0,
                'wasted_memory' => $status['memory_usage']['wasted_memory'] ?? 0,
                'current_wasted_percentage' => $status['memory_usage']['current_wasted_percentage'] ?? 0,
            ],
            'opcache_statistics' => [
                'num_cached_scripts' => $status['opcache_statistics']['num_cached_scripts'] ?? 0,
                'num_cached_keys' => $status['opcache_statistics']['num_cached_keys'] ?? 0,
                'max_cached_keys' => $status['opcache_statistics']['max_cached_keys'] ?? 0,
                'hits' => $status['opcache_statistics']['hits'] ?? 0,
                'misses' => $status['opcache_statistics']['misses'] ?? 0,
                'blacklist_misses' => $status['opcache_statistics']['blacklist_misses'] ?? 0,
                'hit_rate' => $this->calculateHitRate($status['opcache_statistics'] ?? []),
            ],
            'configuration' => [
                'memory_consumption' => $config['directives']['opcache.memory_consumption'] ?? 0,
                'max_accelerated_files' => $config['directives']['opcache.max_accelerated_files'] ?? 0,
                'max_wasted_percentage' => $config['directives']['opcache.max_wasted_percentage'] ?? 0,
                'validate_timestamps' => $config['directives']['opcache.validate_timestamps'] ?? false,
                'revalidate_freq' => $config['directives']['opcache.revalidate_freq'] ?? 0,
            ]
        ];
    }

    private static function calculateHitRate(array $stats): float
    {
        $hits = $stats['hits'] ?? 0;
        $misses = $stats['misses'] ?? 0;
        $total = $hits + $misses;

        return $total > 0 ? ($hits / $total) * 100 : 0;
    }

    public static function getRecommendations(): array
    {
        $status = self::getStatus();
        $recommendations = [];

        if ($status['memory_usage']['current_wasted_percentage'] > 10) {
            $recommendations[] = [
                'type' => 'warning',
                'message' => '检测到较高的内存浪费，请考虑增加内存或降低 max_wasted_percentage。',
                'current_waste' => $status['memory_usage']['current_wasted_percentage'],
                'suggestion' => '增加 opcache.memory_consumption 或降低 opcache.max_wasted_percentage'
            ];
        }

        if ($status['opcache_statistics']['hit_rate'] < 95) {
            $recommendations[] = [
                'type' => 'warning',
                'message' => '缓存命中率偏低，请检查是否频繁失效。',
                'current_hit_rate' => $status['opcache_statistics']['hit_rate'],
                'suggestion' => '检查 opcache.validate_timestamps 与 opcache.revalidate_freq 配置'
            ];
        }

        $keyUsage = ($status['opcache_statistics']['num_cached_keys'] / $status['opcache_statistics']['max_cached_keys']) * 100;
        if ($keyUsage > 80) {
            $recommendations[] = [
                'type' => 'warning',
                'message' => '缓存键使用率过高，请考虑增大 max_accelerated_files。',
                'current_usage' => $keyUsage,
                'suggestion' => '增加 opcache.max_accelerated_files'
            ];
        }

        return $recommendations;
    }
}

// src/OPcache/ConfigurationManager.php
<?php

namespace App\OPcache;

class ConfigurationManager
{
    private array $environments;
    private string $currentEnvironment;

    public function __construct(string $environment = 'production')
    {
        $this->currentEnvironment = $environment;
        $this->loadEnvironmentConfigurations();
    }

    public function generateConfiguration(): array
    {
        $baseConfig = $this->getBaseConfiguration();
        $envConfig = $this->environments[$this->currentEnvironment] ?? [];

        return array_merge($baseConfig, $envConfig);
    }

    public function calculateOptimalSettings(array $appMetrics): array
    {
        $fileCount = $appMetrics['php_file_count'] ?? 2000;
        $memoryUsage = $appMetrics['avg_memory_usage'] ?? 64;
        $requestRate = $appMetrics['requests_per_second'] ?? 100;

        // 计算最优 max_accelerated_files（取不小于目标的 2 的幂，并留 50% 余量）
        $optimalMaxFiles = $this->getNextPowerOfTwo($fileCount * 1.5);

        // 依据文件数量与复杂度估算共享内存
        $baseMemory = 128; // MB
        $memoryPerFile = 0.02; // 平均每个文件 0.02MB
        $optimalMemory = max($baseMemory, $fileCount * $memoryPerFile * 1.3);

        // Interned strings 缓冲区估算
        $optimalStringBuffer = max(8, min(64, $fileCount / 500));

        return [
            'opcache.max_accelerated_files' => $optimalMaxFiles,
            'opcache.memory_consumption' => $optimalMemory . 'M',
            'opcache.interned_strings_buffer' => $optimalStringBuffer,
            'opcache.jit_buffer_size' => max(64, min(256, $optimalMemory / 4)) . 'M',
            'opcache.max_wasted_percentage' => $requestRate > 1000 ? 3 : 5,
            'opcache.revalidate_freq' => $this->currentEnvironment === 'production' ? 0 : 1,
        ];
    }

    public function validateConfiguration(array $config): array
    {
        $issues = [];

        // 检查共享内存
        if (($config['opcache.memory_consumption'] ?? 0) < 64) {
            $issues[] = [
                'severity' => 'error',
                'setting' => 'opcache.memory_consumption',
                'message' => '共享内存过低，可能导致频繁未命中',
                'recommendation' => '至少提升到 128M'
            ];
        }

        // 检查 max_accelerated_files
        $maxFiles = $config['opcache.max_accelerated_files'] ?? 2000;
        if ($maxFiles < 2000) {
            $issues[] = [
                'severity' => 'warning',
                'setting' => 'opcache.max_accelerated_files',
                'message' => '容量偏小，难以覆盖较大应用',
                'recommendation' => '考虑提升到 4000 或更高'
            ];
        }

        if (!$this->isPowerOfTwo($maxFiles)) {
            $issues[] = [
                'severity' => 'info',
                'setting' => 'opcache.max_accelerated_files',
                'message' => '非 2 的幂，可能导致哈希表性能欠佳',
                'recommendation' => '使用 2 的幂，例如：' . $this->getNextPowerOfTwo($maxFiles)
            ];
        }

        // 生产环境特定检查
        if ($this->currentEnvironment === 'production') {
            if ($config['opcache.validate_timestamps'] ?? true) {
                $issues[] = [
                    'severity' => 'warning',
                    'setting' => 'opcache.validate_timestamps',
                    'message' => '生产应禁用以获得最佳性能',
                    'recommendation' => '设为 0'
                ];
            }
        }

        return $issues;
    }

    public function exportConfiguration(array $config, string $format = 'ini'): string
    {
        return match ($format) {
            'ini' => $this->exportAsIni($config),
            'php' => $this->exportAsPhp($config),
            'json' => json_encode($config, JSON_PRETTY_PRINT),
            'yaml' => yaml_emit($config),
            default => throw new \InvalidArgumentException("Unsupported format: {$format}")
        };
    }

    private function loadEnvironmentConfigurations(): void
    {
        $this->environments = [
            'development' => [
                'opcache.enable' => 1,
                'opcache.validate_timestamps' => 1,
                'opcache.revalidate_freq' => 1,
                'opcache.memory_consumption' => '128M',
                'opcache.max_accelerated_files' => 4000,
                'opcache.interned_strings_buffer' => 8,
                'opcache.fast_shutdown' => 0,
                'opcache.error_log' => '/tmp/opcache-dev.log',
                'opcache.log_verbosity_level' => 4,
            ],
            'testing' => [
                'opcache.enable' => 1,
                'opcache.validate_timestamps' => 1,
                'opcache.revalidate_freq' => 0,
                'opcache.memory_consumption' => '256M',
                'opcache.max_accelerated_files' => 8000,
                'opcache.interned_strings_buffer' => 16,
                'opcache.fast_shutdown' => 1,
                'opcache.file_cache' => '/tmp/opcache-test',
            ],
            'staging' => [
                'opcache.enable' => 1,
                'opcache.validate_timestamps' => 0,
                'opcache.revalidate_freq' => 0,
                'opcache.memory_consumption' => '512M',
                'opcache.max_accelerated_files' => 16000,
                'opcache.interned_strings_buffer' => 32,
                'opcache.fast_shutdown' => 1,
                'opcache.file_cache' => '/var/cache/opcache-staging',
                'opcache.jit_buffer_size' => '128M',
                'opcache.jit' => 'tracing',
            ],
            'production' => [
                'opcache.enable' => 1,
                'opcache.validate_timestamps' => 0,
                'opcache.revalidate_freq' => 0,
                'opcache.memory_consumption' => '512M',
                'opcache.max_accelerated_files' => 20000,
                'opcache.interned_strings_buffer' => 64,
                'opcache.max_wasted_percentage' => 5,
                'opcache.fast_shutdown' => 1,
                'opcache.file_cache' => '/var/cache/opcache',
                'opcache.file_cache_consistency_checks' => 1,
                'opcache.protect_memory' => 1,
                'opcache.jit_buffer_size' => '256M',
                'opcache.jit' => 'tracing',
                'opcache.optimization_level' => 0x7FFEBFFF,
            ]
        ];
    }

    private function getBaseConfiguration(): array
    {
        return [
            'opcache.enable' => 1,
            'opcache.enable_cli' => 0,
            'opcache.memory_consumption' => '256M',
            'opcache.interned_strings_buffer' => 16,
            'opcache.max_accelerated_files' => 10000,
            'opcache.max_wasted_percentage' => 5,
            'opcache.use_cwd' => 1,
            'opcache.validate_timestamps' => 1,
            'opcache.revalidate_freq' => 2,
            'opcache.save_comments' => 1,
            'opcache.error_log' => '/var/log/opcache.log'
        ];
    }

    private function isPowerOfTwo(int $n): bool
    {
        return $n > 0 && ($n & ($n - 1)) === 0;
    }

    private function getNextPowerOfTwo(int $n): int
    {
        if ($n <= 1) return 2;

        $power = 1;
        while ($power < $n) {
            $power <<= 1;
        }
        return $power;
    }

    private function exportAsIni(array $config): string
    {
        $ini = "[opcache]\n";
        foreach ($config as $key => $value) {
            $ini .= "{$key}=" . (is_bool($value) ? ($value ? '1' : '0') : $value) . "\n";
        }
        return $ini;
    }

    private function exportAsPhp(array $config): string
    {
        $php = "<?php\n// OPcache Configuration\n\n";
        foreach ($config as $key => $value) {
            $quotedValue = is_string($value) && !is_numeric($value) ? "'{$value}'" : (is_bool($value) ? ($value ? 'true' : 'false') : $value);
            $php .= "ini_set('{$key}', {$quotedValue});\n";
        }
        return $php;
    }
}

// src/OPcache/ApplicationAnalyzer.php
<?php

namespace App\OPcache;

class ApplicationAnalyzer
{
    private string $appPath;
    private array $metrics = [];

    public function __construct(string $appPath)
    {
        $this->appPath = realpath($appPath);
        if (!$this->appPath) {
            throw new \InvalidArgumentException("Invalid application path: {$appPath}");
        }
    }

    public function analyze(): array
    {
        $this->metrics = [
            'analysis_timestamp' => time(),
            'app_path' => $this->appPath,
            'file_metrics' => $this->analyzeFiles(),
            'dependency_metrics' => $this->analyzeDependencies(),
            'complexity_metrics' => $this->analyzeComplexity(),
            'memory_metrics' => $this->estimateMemoryUsage(),
            'performance_metrics' => $this->analyzePerformanceCharacteristics()
        ];

        return $this->metrics;
    }

    public function getOptimizationRecommendations(): array
    {
        if (empty($this->metrics)) {
            $this->analyze();
        }

        $recommendations = [];
        $fileMetrics = $this->metrics['file_metrics'];
        $memoryMetrics = $this->metrics['memory_metrics'];
        $complexityMetrics = $this->metrics['complexity_metrics'];

        // 共享内存推荐值
        $recommendedMemory = $this->calculateRecommendedMemory();
        $recommendations['memory_consumption'] = [
            'setting' => 'opcache.memory_consumption',
            'value' => $recommendedMemory . 'M',
            'reasoning' => "Based on {$fileMetrics['total_files']} files and estimated {$memoryMetrics['estimated_total_mb']}MB total size"
        ];

        // 最大加速文件数推荐
        $recommendedMaxFiles = $this->calculateRecommendedMaxFiles();
        $recommendations['max_accelerated_files'] = [
            'setting' => 'opcache.max_accelerated_files',
            'value' => $recommendedMaxFiles,
            'reasoning' => "Power of 2 value with 50% buffer for {$fileMetrics['total_files']} PHP files"
        ];

        // Interned strings 缓冲区推荐
        $recommendedStringBuffer = $this->calculateRecommendedStringBuffer();
        $recommendations['interned_strings_buffer'] = [
            'setting' => 'opcache.interned_strings_buffer',
            'value' => $recommendedStringBuffer,
            'reasoning' => "Based on estimated {$complexityMetrics['estimated_strings']} unique strings"
        ];

        // JIT 缓冲区大小（PHP 8.0+）
        if (PHP_VERSION_ID >= 80000) {
            $recommendedJitBuffer = max(64, min(512, $recommendedMemory / 3));
            $recommendations['jit_buffer_size'] = [
                'setting' => 'opcache.jit_buffer_size',
                'value' => $recommendedJitBuffer . 'M',
                'reasoning' => 'Approximately 30% of opcache memory for JIT compilation'
            ];
        }

        // 分环境建议
        $recommendations['environment_specific'] = $this->getEnvironmentSpecificRecommendations();

        return $recommendations;
    }

    private function analyzeFiles(): array
    {
        $phpFiles = $this->findPhpFiles();
        $totalSize = 0;
        $largestFile = 0;
        $fileTypes = [];
        $directoryDistribution = [];

        foreach ($phpFiles as $file) {
            $size = filesize($file);
            $totalSize += $size;
            $largestFile = max($largestFile, $size);

            // 文件类型分析
            $type = $this->classifyFile($file);
            $fileTypes[$type] = ($fileTypes[$type] ?? 0) + 1;

            // 目录分布分析
            $relativeDir = dirname(str_replace($this->appPath, '', $file));
            $directoryDistribution[$relativeDir] = ($directoryDistribution[$relativeDir] ?? 0) + 1;
        }

        return [
            'total_files' => count($phpFiles),
            'total_size_bytes' => $totalSize,
            'total_size_mb' => round($totalSize / 1024 / 1024, 2),
            'average_file_size' => count($phpFiles) > 0 ? round($totalSize / count($phpFiles)) : 0,
            'largest_file_size' => $largestFile,
            'file_types' => $fileTypes,
            'directory_distribution' => array_slice($directoryDistribution, 0, 10)
        ];
    }

    private function analyzeDependencies(): array
    {
        $composerFile = $this->appPath . '/composer.json';
        $dependencies = [];

        if (file_exists($composerFile)) {
            $composer = json_decode(file_get_contents($composerFile), true);
            $dependencies = [
                'require' => count($composer['require'] ?? []),
                'require_dev' => count($composer['require-dev'] ?? []),
                'total_packages' => count($composer['require'] ?? []) + count($composer['require-dev'] ?? [])
            ];

            // 识别重量级框架
            $heavyFrameworks = ['laravel/framework', 'symfony/symfony', 'zendframework/zendframework'];
            $dependencies['heavy_frameworks'] = array_intersect($heavyFrameworks, array_keys($composer['require'] ?? []));
        }

        return $dependencies;
    }

    private function analyzeComplexity(): array
    {
        $phpFiles = $this->findPhpFiles();
        $totalLines = 0;
        $totalClasses = 0;
        $totalFunctions = 0;
        $estimatedStrings = 0;

        foreach (array_slice($phpFiles, 0, 100) as $file) { // 采样前 100 个文件
            $content = file_get_contents($file);
            $lines = substr_count($content, "\n");
            $totalLines += $lines;

            // 统计 class/interface/trait
            $totalClasses += preg_match_all('/\b(?:class|interface|trait)\s+\w+/i', $content);

            // 统计函数与方法
            $totalFunctions += preg_match_all('/\bfunction\s+\w+/i', $content);

            // 估算唯一字符串数量
            preg_match_all('/(["\'])(?:(?!\1)[^\\\\]|\\\\.)*\1/', $content, $matches);
            $estimatedStrings += count(array_unique($matches[0]));
        }

        // 推断到全量
        $sampleSize = min(100, count($phpFiles));
        $extrapolationFactor = count($phpFiles) / $sampleSize;

        return [
            'total_lines' => round($totalLines * $extrapolationFactor),
            'total_classes' => round($totalClasses * $extrapolationFactor),
            'total_functions' => round($totalFunctions * $extrapolationFactor),
            'estimated_strings' => round($estimatedStrings * $extrapolationFactor),
            'average_lines_per_file' => $sampleSize > 0 ? round($totalLines / $sampleSize) : 0,
            'code_density' => $sampleSize > 0 ? round(($totalClasses + $totalFunctions) / $sampleSize, 2) : 0
        ];
    }

    private function estimateMemoryUsage(): array
    {
        $fileMetrics = $this->metrics['file_metrics'] ?? $this->analyzeFiles();
        $complexityMetrics = $this->metrics['complexity_metrics'] ?? $this->analyzeComplexity();

        // 基于经验的粗略估算
        $bytecodeOverhead = 1.5; // 字节码通常为源码大小的 ~1.5x
        $metadataPerClass = 2048; // 每个类/函数的元数据平均占用
        $stringPoolOverhead = 1.2; // 字符串驻留的额外开销

        $estimatedBytecode = $fileMetrics['total_size_bytes'] * $bytecodeOverhead;
        $estimatedMetadata = ($complexityMetrics['total_classes'] + $complexityMetrics['total_functions']) * $metadataPerClass;
        $estimatedStringPool = $complexityMetrics['estimated_strings'] * 50 * $stringPoolOverhead; // 平均每个字符串约 50 bytes

        $totalEstimated = $estimatedBytecode + $estimatedMetadata + $estimatedStringPool;

        return [
            'estimated_bytecode_mb' => round($estimatedBytecode / 1024 / 1024, 2),
            'estimated_metadata_mb' => round($estimatedMetadata / 1024 / 1024, 2),
            'estimated_string_pool_mb' => round($estimatedStringPool / 1024 / 1024, 2),
            'estimated_total_mb' => round($totalEstimated / 1024 / 1024, 2),
            'recommended_buffer_mb' => round($totalEstimated * 1.3 / 1024 / 1024, 2)
        ];
    }

    private function analyzePerformanceCharacteristics(): array
    {
        $fileMetrics = $this->metrics['file_metrics'] ?? $this->analyzeFiles();
        $complexityMetrics = $this->metrics['complexity_metrics'] ?? $this->analyzeComplexity();

        // 估算应用特征
        $isLargeApp = $fileMetrics['total_files'] > 5000;
        $isComplexApp = $complexityMetrics['code_density'] > 5;
        $hasHeavyDependencies = !empty($this->metrics['dependency_metrics']['heavy_frameworks'] ?? []);

        return [
            'is_large_application' => $isLargeApp,
            'is_complex_application' => $isComplexApp,
            'has_heavy_dependencies' => $hasHeavyDependencies,
            'estimated_bootstrap_time' => $this->estimateBootstrapTime(),
            'cache_effectiveness_score' => $this->calculateCacheEffectivenessScore()
        ];
    }

    private function findPhpFiles(): array
    {
        $iterator = new \RecursiveIteratorIterator(
            new \RecursiveDirectoryIterator($this->appPath, \RecursiveDirectoryIterator::SKIP_DOTS)
        );

        $phpFiles = [];
        foreach ($iterator as $file) {
            if ($file->getExtension() === 'php' && $file->isFile()) {
                // 跳过常见的非缓存目录
                $path = $file->getPathname();
                if (!preg_match('#/(tests?|cache|storage|tmp|temp)/#i', $path)) {
                    $phpFiles[] = $path;
                }
            }
        }

        return $phpFiles;
    }

    private function classifyFile(string $filepath): string
    {
        $content = file_get_contents($filepath);

        if (preg_match('/\bclass\s+\w+Controller\b/i', $content)) return 'controller';
        if (preg_match('/\bclass\s+\w+Model\b/i', $content)) return 'model';
        if (preg_match('/\bclass\s+\w+Service\b/i', $content)) return 'service';
        if (preg_match('/\bclass\s+\w+Repository\b/i', $content)) return 'repository';
        if (preg_match('/\binterface\s+/i', $content)) return 'interface';
        if (preg_match('/\btrait\s+/i', $content)) return 'trait';
        if (preg_match('/\bclass\s+/i', $content)) return 'class';

        return 'other';
    }

    private function calculateRecommendedMemory(): int
    {
        $memoryMetrics = $this->metrics['memory_metrics'];
        return max(128, (int)ceil($memoryMetrics['recommended_buffer_mb']));
    }

    private function calculateRecommendedMaxFiles(): int
    {
        $totalFiles = $this->metrics['file_metrics']['total_files'];
        $withBuffer = (int)ceil($totalFiles * 1.5); // 预留 50% 空间

        // 向上取 2 的幂
        $power = 1;
        while ($power < $withBuffer) {
            $power <<= 1;
        }

        return max(2048, $power);
    }

    private function calculateRecommendedStringBuffer(): int
    {
        $estimatedStrings = $this->metrics['complexity_metrics']['estimated_strings'];
        return max(8, min(64, (int)ceil($estimatedStrings / 1000)));
    }

    private function estimateBootstrapTime(): float
    {
        $totalFiles = $this->metrics['file_metrics']['total_files'];
        $totalSize = $this->metrics['file_metrics']['total_size_mb'];

        // 基于文件数与体积的粗略估计
        return round(($totalFiles * 0.1 + $totalSize * 0.5) / 1000, 3);
    }

    private function calculateCacheEffectivenessScore(): int
    {
        $fileMetrics = $this->metrics['file_metrics'];
        $complexityMetrics = $this->metrics['complexity_metrics'];

        $score = 0;

        // 文件越多，缓存收益越大
        if ($fileMetrics['total_files'] > 1000) $score += 30;
        else $score += ($fileMetrics['total_files'] / 1000) * 30;

        // 文件越大，缓存收益越大
        if ($fileMetrics['average_file_size'] > 5000) $score += 25;
        else $score += ($fileMetrics['average_file_size'] / 5000) * 25;

        // 复杂度越高，缓存收益越大
        if ($complexityMetrics['code_density'] > 3) $score += 25;
        else $score += ($complexityMetrics['code_density'] / 3) * 25;

        // 重量级框架收益更明显
        if (!empty($this->metrics['dependency_metrics']['heavy_frameworks'])) $score += 20;

        return min(100, (int)round($score));
    }

    private function getEnvironmentSpecificRecommendations(): array
    {
        return [
            'development' => [
                'opcache.validate_timestamps' => 1,
                'opcache.revalidate_freq' => 1,
                'opcache.log_verbosity_level' => 4,
                'reasoning' => '开发环境需要变更检测与更详细的日志'
            ],
            'production' => [
                'opcache.validate_timestamps' => 0,
                'opcache.revalidate_freq' => 0,
                'opcache.file_cache' => '/var/cache/opcache',
                'opcache.protect_memory' => 1,
                'reasoning' => '生产环境禁用校验以获得性能，并启用内存保护'
            ]
        ];
    }
}

// src/OPcache/Dashboard.php
<?php

namespace App\OPcache;

class Dashboard
{
    private $monitor;
    private $analyzer;

    public function __construct()
    {
        $this->monitor = new OPcacheMonitor();
        $this->analyzer = new ApplicationAnalyzer($_SERVER['DOCUMENT_ROOT'] ?? '/var/www/html');
    }

    public function getDashboardData(): array
    {
        $status = OPcacheMonitor::getStatus();
        $recommendations = OPcacheMonitor::getRecommendations();

        if (!$status['enabled']) {
            return [
                'error' => 'OPcache is not enabled',
                'recommendations' => ['Enable OPcache in php.ini']
            ];
        }

        return [
            'overview' => $this->getOverviewData($status),
            'memory' => $this->getMemoryData($status),
            'performance' => $this->getPerformanceData($status),
            'configuration' => $this->getConfigurationData($status),
            'recommendations' => $recommendations,
            'optimization_opportunities' => $this->getOptimizationOpportunities($status),
            'historical_trends' => $this->getHistoricalTrends(),
            'alerts' => $this->getAlerts($status)
        ];
    }

    public function generateReport(): string
    {
        $data = $this->getDashboardData();

        $report = "OPcache Performance Report\n";
        $report .= "Generated: " . date('Y-m-d H:i:s') . "\n";
        $report .= str_repeat('=', 50) . "\n\n";

        // 概览
        $overview = $data['overview'];
        $report .= "OVERVIEW\n";
        $report .= "Status: " . ($overview['enabled'] ? 'Enabled' : 'Disabled') . "\n";
        $report .= "Hit Rate: " . number_format($overview['hit_rate'], 2) . "%\n";
        $report .= "Memory Usage: " . number_format($overview['memory_usage_percentage'], 1) . "%\n";
        $report .= "Cached Scripts: " . number_format($overview['cached_scripts']) . "\n\n";

        // 性能
        $performance = $data['performance'];
        $report .= "PERFORMANCE METRICS\n";
        $report .= "Cache Hits: " . number_format($performance['hits']) . "\n";
        $report .= "Cache Misses: " . number_format($performance['misses']) . "\n";
        $report .= "Blacklist Misses: " . number_format($performance['blacklist_misses']) . "\n";
        $report .= "Restart Count: " . number_format($performance['restart_count']) . "\n\n";

        // 建议
        if (!empty($data['recommendations'])) {
            $report .= "RECOMMENDATIONS\n";
            foreach ($data['recommendations'] as $rec) {
                $report .= "- {$rec['type']}: {$rec['message']}\n";
                $report .= "  Suggestion: {$rec['suggestion']}\n";
            }
            $report .= "\n";
        }

        // 告警
        if (!empty($data['alerts'])) {
            $report .= "ALERTS\n";
            foreach ($data['alerts'] as $alert) {
                $report .= "- {$alert['severity']}: {$alert['message']}\n";
            }
        }

        return $report;
    }

    private function getOverviewData(array $status): array
    {
        $memUsage = $status['memory_usage'];
        $totalMemory = $memUsage['used_memory'] + $memUsage['free_memory'];

        return [
            'enabled' => $status['enabled'],
            'version' => phpversion(),
            'hit_rate' => $status['opcache_statistics']['hit_rate'],
            'memory_usage_percentage' => $totalMemory > 0 ? ($memUsage['used_memory'] / $totalMemory) * 100 : 0,
            'cached_scripts' => $status['opcache_statistics']['num_cached_scripts'],
            'max_cached_keys' => $status['opcache_statistics']['max_cached_keys'],
            'key_usage_percentage' => $status['opcache_statistics']['max_cached_keys'] > 0 ?
                ($status['opcache_statistics']['num_cached_keys'] / $status['opcache_statistics']['max_cached_keys']) * 100 : 0,
            'uptime' => $this->getUptime(),
            'last_restart' => $this->getLastRestartTime()
        ];
    }

    private function getMemoryData(array $status): array
    {
        $memUsage = $status['memory_usage'];
        $totalMemory = $memUsage['used_memory'] + $memUsage['free_memory'];

        return [
            'total_memory' => $totalMemory,
            'used_memory' => $memUsage['used_memory'],
            'free_memory' => $memUsage['free_memory'],
            'wasted_memory' => $memUsage['wasted_memory'],
            'wasted_percentage' => $memUsage['current_wasted_percentage'],
            'memory_efficiency' => $totalMemory > 0 ? (($memUsage['used_memory'] - $memUsage['wasted_memory']) / $totalMemory) * 100 : 0,
            'formatted' => [
                'total' => $this->formatBytes($totalMemory),
                'used' => $this->formatBytes($memUsage['used_memory']),
                'free' => $this->formatBytes($memUsage['free_memory']),
                'wasted' => $this->formatBytes($memUsage['wasted_memory'])
            ]
        ];
    }

    private function getPerformanceData(array $status): array
    {
        $stats = $status['opcache_statistics'];

        return [
            'hits' => $stats['hits'],
            'misses' => $stats['misses'],
            'blacklist_misses' => $stats['blacklist_misses'],
            'hit_rate' => $stats['hit_rate'],
            'miss_rate' => 100 - $stats['hit_rate'],
            'restart_count' => $stats['oom_restarts'] ?? 0,
            'hash_restarts' => $stats['hash_restarts'] ?? 0,
            'manual_restarts' => $stats['manual_restarts'] ?? 0,
            'requests_per_second' => $this->calculateRequestsPerSecond($stats),
            'cache_efficiency' => $this->calculateCacheEfficiency($stats)
        ];
    }

    private function getConfigurationData(array $status): array
    {
        $config = $status['configuration'];

        return [
            'memory_consumption' => $this->formatBytes($config['memory_consumption']),
            'max_accelerated_files' => number_format($config['max_accelerated_files']),
            'max_wasted_percentage' => $config['max_wasted_percentage'] . '%',
            'validate_timestamps' => $config['validate_timestamps'] ? 'Enabled' : 'Disabled',
            'revalidate_freq' => $config['revalidate_freq'] . ' seconds',
            'jit_enabled' => function_exists('opcache_get_status') &&
                isset(opcache_get_status()['jit']) ? 'Yes' : 'No',
            'file_cache' => ini_get('opcache.file_cache') ?: 'Disabled'
        ];
    }

    private function getOptimizationOpportunities(array $status): array
    {
        $opportunities = [];

        // 命中率检查
        if ($status['opcache_statistics']['hit_rate'] < 95) {
            $opportunities[] = [
                'type' => 'performance',
                'priority' => 'high',
                'title' => 'Low Hit Rate',
                'description' => '命中率低于 95%，可能存在配置问题',
                'impact' => 'High performance impact',
                'action' => 'Review validate_timestamps and revalidate_freq settings'
            ];
        }

        // 内存碎片检查
        if ($status['memory_usage']['current_wasted_percentage'] > 10) {
            $opportunities[] = [
                'type' => 'memory',
                'priority' => 'medium',
                'title' => 'High Memory Waste',
                'description' => 'OPcache 内存浪费超过 10% ',
                'impact' => 'Memory efficiency',
                'action' => 'Consider increasing memory or decreasing max_wasted_percentage'
            ];
        }

        // 键使用率检查
        $keyUsage = ($status['opcache_statistics']['num_cached_keys'] / $status['opcache_statistics']['max_cached_keys']) * 100;
        if ($keyUsage > 80) {
            $opportunities[] = [
                'type' => 'capacity',
                'priority' => 'medium',
                'title' => 'High Key Usage',
                'description' => '缓存键使用超过 80% 的容量',
                'impact' => 'May cause cache evictions',
                'action' => 'Increase max_accelerated_files'
            ];
        }

        return $opportunities;
    }

    private function getHistoricalTrends(): array
    {
        // 真实实现通常读取日志或数据库；此处为演示
        return [
            'hit_rate_trend' => [
                ['timestamp' => time() - 3600, 'value' => 94.2],
                ['timestamp' => time() - 1800, 'value' => 95.1],
                ['timestamp' => time(), 'value' => 96.3]
            ],
            'memory_usage_trend' => [
                ['timestamp' => time() - 3600, 'value' => 75.2],
                ['timestamp' => time() - 1800, 'value' => 78.1],
                ['timestamp' => time(), 'value' => 82.3]
            ]
        ];
    }

    private function getAlerts(array $status): array
    {
        $alerts = [];

        if ($status['cache_full']) {
            $alerts[] = [
                'severity' => 'critical',
                'message' => 'OPcache 空间已满，可能发生淘汰',
                'timestamp' => time()
            ];
        }

        if ($status['restart_pending']) {
            $alerts[] = [
                'severity' => 'warning',
                'message' => 'OPcache 等待重启',
                'timestamp' => time()
            ];
        }

        if ($status['memory_usage']['current_wasted_percentage'] > 15) {
            $alerts[] = [
                'severity' => 'warning',
                'message' => '内存浪费偏高：' . $status['memory_usage']['current_wasted_percentage'] . '%',
                'timestamp' => time()
            ];
        }

        return $alerts;
    }

    private function formatBytes(int $bytes): string
    {
        $units = ['B', 'KB', 'MB', 'GB'];
        $factor = floor((strlen($bytes) - 1) / 3);
        return sprintf("%.2f %s", $bytes / pow(1024, $factor), $units[$factor]);
    }

    private function calculateRequestsPerSecond(array $stats): float
    {
        // 粗略估计；实际应长期采样
        $totalRequests = $stats['hits'] + $stats['misses'];
        $uptime = $this->getUptime();
        return $uptime > 0 ? $totalRequests / $uptime : 0;
    }

    private function calculateCacheEfficiency(array $stats): float
    {
        $totalRequests = $stats['hits'] + $stats['misses'];
        return $totalRequests > 0 ? ($stats['hits'] / $totalRequests) * 100 : 0;
    }

    private function getUptime(): int
    {
        // 实际应读取进程存活或日志
        return time() - filemtime('/tmp/opcache_start'); // 示例实现
    }

    private function getLastRestartTime(): ?int
    {
        // 实际应读取日志
        return null; // 示例实现
    }
}

// src/OPcache/JitOptimizer.php
<?php

namespace App\OPcache;

class JitOptimizer
{
    private array $jitModes = [
        'disable' => 0,
        'on' => 1255,
        'tracing' => 1254,
        'function' => 1205,
        'off' => 0
    ];

    public function getOptimalJitConfiguration(array $appCharacteristics): array
    {
        $config = [
            'opcache.jit_buffer_size' => $this->calculateJitBufferSize($appCharacteristics),
            'opcache.jit' => $this->selectJitMode($appCharacteristics),
            'opcache.jit_hot_loop' => $this->calculateHotLoop($appCharacteristics),
            'opcache.jit_hot_func' => $this->calculateHotFunc($appCharacteristics),
            'opcache.jit_hot_return' => $this->calculateHotReturn($appCharacteristics),
            'opcache.jit_hot_side_exit' => $this->calculateHotSideExit($appCharacteristics),
            'opcache.jit_debug' => 0,
            'opcache.jit_prof_threshold' => $this->calculateProfThreshold($appCharacteristics)
        ];

        return $config;
    }

    public function analyzeJitPerformance(): array
    {
        if (PHP_VERSION_ID < 80000) {
            return ['error' => 'JIT requires PHP 8.0 or higher'];
        }

        if (!function_exists('opcache_get_status')) {
            return ['error' => 'OPcache not available'];
        }

        $status = opcache_get_status();
        $jitInfo = $status['jit'] ?? null;

        if (!$jitInfo) {
            return ['error' => 'JIT not enabled or not available'];
        }

        return [
            'enabled' => $jitInfo['enabled'] ?? false,
            'kind' => $jitInfo['kind'] ?? 'unknown',
            'opt_level' => $jitInfo['opt_level'] ?? 0,
            'opt_flags' => $jitInfo['opt_flags'] ?? 0,
            'buffer_size' => $jitInfo['buffer_size'] ?? 0,
            'buffer_free' => $jitInfo['buffer_free'] ?? 0,
            'buffer_used' => ($jitInfo['buffer_size'] ?? 0) - ($jitInfo['buffer_free'] ?? 0),
            'buffer_usage_percentage' => $this->calculateBufferUsage($jitInfo),
            'compilation_statistics' => [
                'compiled_functions' => $jitInfo['compiled_functions'] ?? 0,
                'exits' => $jitInfo['exits'] ?? 0,
                'traces' => $jitInfo['traces'] ?? 0,
                'side_traces' => $jitInfo['side_traces'] ?? 0
            ],
            'performance_impact' => $this->estimateJitPerformanceImpact($jitInfo)
        ];
    }

    public function benchmarkJitModes(): array
    {
        $results = [];

        foreach ($this->jitModes as $modeName => $modeValue) {
            $results[$modeName] = $this->benchmarkJitMode($modeValue);
        }

        return $results;
    }

    private function calculateJitBufferSize(array $appCharacteristics): string
    {
        $baseSize = 64; // MB

        // 按应用规模调整
        if ($appCharacteristics['total_files'] > 5000) {
            $baseSize = 256;
        } elseif ($appCharacteristics['total_files'] > 2000) {
            $baseSize = 128;
        }

        // 按复杂度调整
        if ($appCharacteristics['code_density'] > 5) {
            $baseSize *= 1.5;
        }

        // 限制为可用内存的 20% 以内
        $availableMemory = $this->getAvailableMemory();
        $maxJitSize = $availableMemory * 0.2;

        $finalSize = min($baseSize, $maxJitSize);

        return (int)$finalSize . 'M';
    }

    private function selectJitMode(array $appCharacteristics): int
    {
        // 根据应用特征选择最优 JIT 模式
        $hasLoops = $appCharacteristics['estimated_loops'] ?? 0 > 100;
        $hasHotPaths = $appCharacteristics['hot_functions'] ?? 0 > 50;
        $isComputeIntensive = $appCharacteristics['compute_intensive'] ?? false;

        if ($isComputeIntensive && $hasLoops) {
            return $this->jitModes['tracing'];
        } elseif ($hasHotPaths) {
            return $this->jitModes['function'];
        } else {
            return $this->jitModes['on'];
        }
    }

    private function calculateHotLoop(array $appCharacteristics): int
    {
        // 判定循环为“hot”的阈值
        return $appCharacteristics['avg_loop_iterations'] ?? 64;
    }

    private function calculateHotFunc(array $appCharacteristics): int
    {
        // 判定函数为“hot”的阈值
        return $appCharacteristics['avg_function_calls'] ?? 127;
    }

    private function calculateHotReturn(array $appCharacteristics): int
    {
        return 8;
    }

    private function calculateHotSideExit(array $appCharacteristics): int
    {
        return 8;
    }

    private function calculateProfThreshold(array $appCharacteristics): float
    {
        // 生产提高采样阈值以降低开销
        return 0.005; // 0.5%
    }

    private function calculateBufferUsage(array $jitInfo): float
    {
        $bufferSize = $jitInfo['buffer_size'] ?? 0;
        $bufferFree = $jitInfo['buffer_free'] ?? 0;

        if ($bufferSize > 0) {
            return (($bufferSize - $bufferFree) / $bufferSize) * 100;
        }

        return 0;
    }

    private function estimateJitPerformanceImpact(array $jitInfo): array
    {
        $compiledFunctions = $jitInfo['compiled_functions'] ?? 0;
        $exits = $jitInfo['exits'] ?? 0;
        $traces = $jitInfo['traces'] ?? 0;

        $successRate = $compiledFunctions > 0 ?
            (($compiledFunctions - $exits) / $compiledFunctions) * 100 : 0;

        return [
            'compilation_success_rate' => $successRate,
            'estimated_speedup' => $this->estimateSpeedup($successRate, $compiledFunctions),
            'jit_effectiveness' => $this->calculateJitEffectiveness($jitInfo),
            'recommendation' => $this->getJitRecommendation($successRate, $compiledFunctions)
        ];
    }

    private function benchmarkJitMode(int $modeValue): array
    {
        // 实际应运行基准测试；此处为示例
        return [
            'mode_value' => $modeValue,
            'compilation_time' => rand(10, 100) / 1000,
            'execution_speedup' => rand(110, 300) / 100,
            'memory_overhead' => rand(5, 20),
            'stability_score' => rand(85, 100)
        ];
    }

    private function getAvailableMemory(): int
    {
        $memLimit = ini_get('memory_limit');
        if ($memLimit === '-1') {
            return 1024; // 视为 1GB
        }

        return (int) $memLimit;
    }

    private function estimateSpeedup(float $successRate, int $compiledFunctions): float
    {
        if ($compiledFunctions === 0) return 1.0;

        // 基于成功率的粗略推估
        $baseSpeedup = 1.2; // 20% 基础改善
        $successFactor = $successRate / 100;

        return 1.0 + ($baseSpeedup - 1.0) * $successFactor;
    }

    private function calculateJitEffectiveness(array $jitInfo): string
    {
        $compiledFunctions = $jitInfo['compiled_functions'] ?? 0;
        $bufferUsage = $this->calculateBufferUsage($jitInfo);

        if ($compiledFunctions > 100 && $bufferUsage < 80) {
            return 'High';
        } elseif ($compiledFunctions > 50 && $bufferUsage < 90) {
            return 'Medium';
        } else {
            return 'Low';
        }
    }

    private function getJitRecommendation(float $successRate, int $compiledFunctions): string
    {
        if ($successRate > 80 && $compiledFunctions > 100) {
            return 'JIT is working well, consider increasing buffer size if usage is high';
        } elseif ($successRate < 60) {
            return 'Consider switching to function mode or disabling JIT';
        } elseif ($compiledFunctions < 50) {
            return 'Application may not benefit significantly from JIT';
        } else {
            return 'JIT configuration appears optimal';
        }
    }
}