PHP Runtime & Internals

Every request starts from a clean interpreter state: the app bootstraps, runs, and then every variable, object, static property and global is destroyed. Nothing survives into the next request, so whatever must persist goes to a database or cache.

php-fpm is a FastCGI process manager: it keeps a pool of persistent PHP worker processes. nginx serves static files itself and forwards PHP requests over the FastCGI protocol (a Unix socket or TCP) via fastcgi_pass. A free worker handles the request and returns the response; nginx never executes PHP. Pool sizing (pm.max_children) bounds concurrency.

nginx serves static files and forwards the rest over FastCGI to the php-fpm master, which hands it to a free child; a busy pool waits in the listen backlog. The child runs index.php, OPcache supplies the opcodes, the framework bootstraps and routes, then tears it all down.

A generator is a function that uses yield to produce values lazily, one at a time, without building the whole collection in memory. Calling it returns a Generator object, which implements the Iterator interface — so you can foreach over it. Each yield pauses the function and resumes on the next iteration.

Without it, PHP parses and compiles every source file into opcodes on every request. OPcache keeps those compiled opcodes in shared memory, so the next request skips compilation and executes at once. It caches code, not data: no query results.

PHP 8 adds the JIT compiler, union types (int|string), named arguments, attributes, the match expression, constructor property promotion, and the nullsafe operator ?->. declare(strict_types=1) switches a file from coercive to strict scalar typing — passing a string where an int is declared throws a TypeError instead of silently casting.

Run a CLI script with an infinite loop that does work then sleeps, kept alive by a supervisor (systemd or supervisord) rather than truly daemonizing by hand. Inside the loop call gc_collect_cycles() and watch memory, because a long-lived PHP process accumulates state. Handle signals (pcntl_signal) for graceful shutdown, and let the supervisor restart it on exit.

Nothing is copied at the call. PHP is by-value semantically, but the engine shares the array and bumps a refcount — copy-on-write. Duplication happens only when one side writes while refcount > 1. Appending one element in the callee copies the whole array.

Octane boots the Laravel application once and keeps that instance and its container alive inside a Swoole, FrankenPHP or RoadRunner worker. So anything assuming a fresh process breaks: your singletons, statics, mutated config, a user leaking onward.

opcache.memory_consumption must hold every compiled script or the cache thrashes, and opcache.max_accelerated_files must exceed the real file count. opcache.validate_timestamps=0 stops the per-request file check, but a deploy then needs a reset.

Every value carries a refcount; at zero it is freed at once, which handles almost every object. Refcounting can never free a reference cycle — each object still holds a count from the other. PHP buffers possible cycle roots and runs a separate cycle collector.

The application is bootstrapped once and the worker then serves many requests in a loop, so framework boot, config, the container and database connections are reused. The price: the process outlives the request, so statics and singletons leak into the next one.

yield from delegates: it yields the inner iterable's values preserving its keys, propagates the inner generator's return value outward (readable via getReturn()), and forwards send() into it. A manual foreach re-yield does none of those three.

This is retention, not a leak. fetchAll() materialises all 5M rows before the loop starts, and $processed[] keeps a live reference to every entity, so refcounts never reach zero and nothing can be freed. Stream instead: fetch() or a generator, and stop accumulating.

Stay on FPM. Shared-nothing teardown is a safety property, not just overhead: a fatal or a leak in one request cannot touch the next. Worker mode boots once, but turns statics, singletons and globals into cross-request incidents. Bootstrap is 15 ms of 90 — a ~17% ceiling.

Opcache caches compiled opcodes in shared memory so PHP skips re-parsing and re-compiling source on every request. JIT (PHP 8) goes further, compiling hot opcodes to native machine code at runtime — it helps CPU-bound code more than typical I/O-bound web requests. The GC is reference counting on each ZVAL plus a cycle collector that periodically finds and frees unreachable reference cycles.

Mandate what removes bug classes: strict_types, promotion, enums, readonly, match. Take PHP 8.4 property hooks and asymmetric visibility where they cut boilerplate. Defer the newest 8.5 syntax until reviewers read it fluently. Concurrency: True Async is an unvoted draft.