OPcache and JIT are the core tools for PHP 8.0 performance optimization. Correct configuration can significantly improve execution efficiency; 1. Enable OPcache and set opcache.enable=1, opcache.memory_consumption=192, opcache.max_accelerated_files=20000, opcache.validate_timestamps=0 to implement opcode caching and reduce parsing overhead; 2. Configure JIT to enable trace JIT mode through opcache.jit_buffer_size=256M and opcache.jit=1254 to optimize CPU-intensive tasks; 3. Use opcache.preload to specify preload files, and load common classes to shared memory at PHP startup to eliminate duplicate load overhead; 4. Verify the cache status through opcache_get_status() or monitoring tool and adjust the parameters in combination with the actual pressure measurement; 5. The production environment needs to disable timestamp verification and reset OPcache in conjunction with the deployment process, and at the same time combine database optimization and cache strategies to achieve overall performance improvement.

PHP performance isn't just about writing clean code — it's also about leveraging the right runtime optimizations. Two of the most powerful tools at your disposal in modern PHP (especially PHP 8.0 ) are OPcache and JIT (Just-In-Time) compilation . When properly configured, they can dramatically reduce execution time and server load. Here's how to set them up for peak performance.

What OPcache Does (And Why It Matters)

Every time a PHP script runs, the PHP engine parses the human-readable code into opcodes — low-level instructions it can execute. Without OPcache, this parsing happens on every request, which is wasteful for code that doesn't change.

OPcache stores these compiled opcodes in shared memory , so subsequent requests skip the parsing and compilation steps entirely. This results in faster response times and reduced CPU usage.

Key OPcache Settings to Tune

Make these changes in your php.ini file:

 ; Enable OPcache
opcache.enable=1

; Enable OPcache for the CLI (useful for testing, but disable in production if not needed)
opcache.enable_cli=1

; Memory allocated for opcode storage (64MB–256MB depending on app size)
opcache.memory_consumption=192

; Maximum number of files that can be stored in the cache
opcache.max_accelerated_files=20000

; How often to check for script changes (set to 0 in production for max performance)
opcache.validate_timestamps=0

; Use a fast hash algorithm for faster looksups
opcache.fast_shutdown=1

; Preload PHP files (PHP 8.0) — more on this below
opcache.preload=/path/to/your/preload.php

?? Note: Setting opcache.validate_timestamps=0 means PHP won't check for file changes. You must manually reset OPcache (via opcache_reset() or restarting PHP-FPM) after deploying new code.

Understanding JIT: Beyond Opcode Caching

While OPcache speeds up opcode reuse, JIT goes further by compiling frequently executed PHP code directly into native machine code. This can significantly speed up CPU-intensive tasks (eg, math operations, loops), though it has less impact on typical web apps dominated by I/O (database, API calls).

JIT was introduced in PHP 8.0 and works best with the Tracing JIT mode.

Configuring JIT in PHP

Add these settings to php.ini :

 ; Enable JIT
opcache.jit_buffer_size=256M

; JIT configuration (recommended for most apps)
opcache.jit=1254

; Ensure OPcache is on and large file support is enabled
opcache.file_cache=""

? What does opcache.jit=1254 means?
It's a bitmask:

• 1 = General optimization
• 2 = Context-based optimization
• 5 = Level 5 (tracing JIT, best for loops)
• 4 = Use return type info

So 1254 enables tracing JIT with type inference — ideal for performance.

Use Preloading to Go Even Faster (PHP 8.0)

Preloading allows PHP to load and compile certain classes into shared memory at startup, so they're instantly available for every request.

Create a preload.php file:

 <?php
// preload.php
$files = [
    __DIR__ . &#39;/vendor/autoload.php&#39;,
    __DIR__ . &#39;/app/Services/Calculator.php&#39;,
    // Add commonly used classes
];

foreach ($files as $file) {
    if (file_exists($file)) {
        opcache_compile_file($file);
    }
}

Then reference it in php.ini :

 opcache.preload=/var/www/preload.php

? Tip: Preloading autoload.php can eliminate autoloader overhead entirely.

Monitoring and Validation

After configuration, verify everything works:

1. Check OPcache status with opcache_get_status() :

    <?php print_r(opcache_get_status()); ?>

   Look for non-zero opcache.memory_usage and interned_strings_usage .

2. Use tools like:

   • OPcache GUI – visual dashboard
   • php -i | grep opcache – CLI check
   • Monitoring in New Relic or Datadog (if available)

3. Test performance with real-world benchmarks (eg, using ab or k6 ) before and after.

---

Final Tips for Production

• Never enable validate_timestamps in production — rely on deployment scripts to restart PHP-FPM or call opcache_reset() .
• Size memory_consumption and max_accelerated_files based on your codebase. Monitor cache fullness via opcache_get_status()['cache_full'] .
• JIT shines in compute-heavy scripts — don't expect 10x gains on simple CRUD apps.
• Combine with other optimizations : fast backends (Redis), efficient DB queries, and proper indexing.

---

Basically, OPcache gives you a solid performance foundation, while JIT and preloading add advanced optimizations. The config isn't one-size-fits-all, but starting with the settings above will get you 90% of the way. Tweak, monitor, and iterate.

The above is the detailed content of Unlocking Peak PHP Performance: Configuring OPcache and JIT Compilation. For more information, please follow other related articles on the PHP Chinese website!