& Preloading A love story

Agenda •A short history of OPcache •Preloading, the theory •Preloading, the practice •Conclusion

A short history of OPcache

Lambda-style before it was hype • PHP has a run-and-forget execution model • Every request has to reload everything all-the-time • Memory leaks and shared state are hard problems • This is great for developer efficiency • This is great for robustness of apps • This makes hosting great • This makes scalability easy

Shared memory (SHM) to the rescue • The code is immutable • The compilation steps can be cached • APC, eAccelerator, Turck MMCache, Zend OpCache FTW • But which compilation steps?

Opcode caches • The source code is compiled into a list of instructions, the opcodes: • ADD, CONCAT, ASSIGN, …, DECLARE_CLASS, DECLARE_FUNCTION, DECLARE_INHERITED_CLASS, ADD_INTERFACE, etc. • Shared memory holds a hashmap map of (file => opcodes) pairs

Opcode caches++ • PHP 5.4: interned strings • PHP 5.5: OPcache becomes open-source and builtin • PHP 5.6: array declarations stay in shared memory • PHP 7.0: • all static arrays stay in shared memory • post-compilation optimizations • PHP 7.1, 7.2, 7.3 • more post-compilation optimizations

What remains before 7.4? • Check freshness • Transfer opcodes into each request’s memory • Link parent classes, interfaces and traits • Validate signatures, covariance and contravariance

PHP 7.4 • Immutable opcodes stay in shared memory • And…

Preloading The theory, from https://wiki.php.net/rfc/preload

Out of scope • Bootstraping the kernel or equivalent • Loading the services (persistent connections) • Computing the response

Preloading removes • Freshness checks • Everything related to loading and declaring classes and functions • Everything is available out-of-the-box, feels like native • (RIP function autoloading, you’ll never have any purpose)

• BTW, constants are not preloaded Constants were not declared when preloading was used

Preloading 101 • opcache.preload=/some/preloading/script.php in your php.ini opcache.preload_user=www-data if running as root (Docker anyone?) • Any classes or functions included by this script Any classes or functions opcache_compile_file()’ed • php-fpm / php -S will load them before serving any requests

(symbol => opcodes) pairs in SHM • Incompatible with several apps on the same FPM server • Is really immutable: reboot the server to reload the code • opcache_get_status() gives all the info • Declarations nested in « if » statements are not preloaded • Only fully-resolved classes are preloaded (you can ignore the warnings) • (oh, it’s not available on Windows)

Preloading The practice

Which strategy for your preload.php? • opcache_compile_file() or • include() + autoloading?

opcache_compile_file()?

https://github.com/symfony/symfony/pull/32032

https://github.com/composer/composer/issues/7777

opcache_compile_file()? 1. Deploy without preloading 2. Get some HTTP traffic 3. Dump preload.php from opcache_get_status() 4. Restart prod with preloading 5. Automate for every deployment • Still loads too many classes (that’s theory) • Not practical – requires advanced tooling • Not compatible with class_alias()

Composer to the rescue?

include() + autoloading? • Allows for complex loading strategies src/ vendor/ var/cache/

The obvious part: preload all services List all classes used by services (autoloading will cascade to parent classes/traits/interfaces)

Cascade to types used on the public API (skip protect/private, they lead to over-preloading)

List classes used by the implementation

No content

List classes used by the implementation Exclude warmup-time services

List cache warmer artifacts (e.g. compiled Twig templates, annotation classes, etc.)

No content

include() + autoloading! • The configuration drives the useful classes • Inline class_exists() declare local sidekicks • container.preload/.no_preload for fine tuning • Make cache warmers report their artifacts

• opcache.preload=var/cache/prod/App_KernelProdContainer.preload.php • Profit • (optionally, fine tune with opcache_get_status() and commit the result) • (go patch open-source bundles and libs to maximize their preloading potential) include() + autoloading?

Conclusion The practice

Kudos Dmitry and Nikita • include() + autoloading • opcache_compile_file() • Hello World with Twig and without preloading: 360 req/s • with preloading, no cache warmers: 560 req/s (+55%) • with preloading, yes cache warmers: 630 req/s (+75%) • A typical app spends 15% loading code • It’s worth it! (but not worth a complex deployment process) PS: there is no memory to share when running on the CLI PPS: autoloading + Composer FTW and here to stay

Thank you! See you at Disneyland Paris in December or earlier hopefully!