PHP Academy · Lektion

OPcache und JIT-Kompilierung

PHP mit Bytecode-Caching und JIT beschleunigen

OPcache und JIT-Kompilierung ist eine kostenlose PHP Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des PHP Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der PHP Academy-Kurs umfasst insgesamt 4 Lektionen.

Kompilierung zwischenspeichern

OPcache speichert kompilierte Opcodes im gemeinsamen Speicher, sodass PHP das Lexing, Parsing und Kompilieren bei jeder Anfrage überspringt. Zusätzlich kompiliert JIT (seit PHP 8.0) häufig ausgeführte Opcodes in nativen Maschinencode. Zusammen bilden sie das Rückgrat der PHP-Performance.

In dieser Lektion geht es um die Konfiguration von OPcache, Preloading und die Abstimmung von JIT.

Was OPcache tut

Das kompilierte op_array jeder Datei wird in einem Segment im gemeinsamen Speicher gespeichert, das von allen FPM-Workern verwendet wird. Eine Anfrage, die den Cache trifft, verwendet die Opcodes direkt wieder. Außerdem führt OPcache bei der ersten Kompilierung einer Datei einen Optimierer aus (Constant Folding, Dead-Code-Eliminierung, Opcode-Fusion).

; Core OPcache config (php.ini)
opcache.enable = 1
opcache.memory_consumption = 256      ; MB of shared memory
opcache.interned_strings_buffer = 16  ; MB for interned strings
opcache.max_accelerated_files = 20000 ; cap on cached scripts

Zeitstempelprüfung

validate_timestamps legt fest, ob OPcache die Änderungszeiten von Dateien erneut prüft. In der Entwicklung sollten Sie die Option aktiviert lassen und eine kurze revalidate_freq verwenden. In der Produktion setzen Sie sie auf 0, damit PHP niemals Dateiinformationen abruft, und leeren Sie beim Deployment den Cache (oder erstellen Sie das Image neu).

; Production: never re-stat files
opcache.validate_timestamps = 0

; Development: check every 2 seconds
; opcache.validate_timestamps = 1
; opcache.revalidate_freq = 2

Cache untersuchen

opcache_get_status() meldet Trefferquote, Speichernutzung und gecachte Skripte; opcache_get_configuration() zeigt die Einstellungen. Eine niedrige Trefferquote oder häufige Neustarts deuten auf zu wenig Speicher oder zu viele Dateien hin.

<?php
if (function_exists('opcache_get_status')) {
    $s = opcache_get_status(false);
    if ($s) {
        printf("hits:   %d\n", $s['opcache_statistics']['hits']);
        printf("misses: %d\n", $s['opcache_statistics']['misses']);
        printf("hit %%: %.2f\n", $s['opcache_statistics']['opcache_hit_rate']);
        printf("used:   %.1f MB\n", $s['memory_usage']['used_memory'] / 1048576);
    } else {
        echo "OPcache enabled but no status (likely CLI)\n";
    }
} else {
    echo "OPcache not available\n";
}
?>

Preloading

Preloading (PHP 7.4+) kompiliert beim Serverstart einmalig eine Gruppe von Klassen und Funktionen und hält sie dauerhaft im Speicher. Dadurch stehen sie jeder Anfrage ohne Autoloading oder Verknüpfung pro Anfrage zur Verfügung. Verweisen Sie mit opcache.preload auf ein Skript, das die Dateien zum Aufwärmen einbindet.

; php.ini
opcache.preload = /app/preload.php
opcache.preload_user = www-data

Ein Preload-Skript schreiben

Das Preload-Skript läuft im Masterprozess. Verwenden Sie opcache_compile_file(), um Klassen zu laden, ohne sie auszuführen, oder binden Sie sie einfach mit require ein. Frameworks erzeugen eine Preload-Liste; so sieht eine solche Liste aus.

<?php
// preload.php — runs once at startup
$dir = '/app/src';
$rii = new RecursiveIteratorIterator(
    new RecursiveDirectoryIterator($dir)
);

foreach ($rii as $file) {
    if ($file->getExtension() === 'php') {
        // Compiles + links the class into shared memory
        opcache_compile_file($file->getPathname());
    }
}
?>

JIT kommt ins Spiel

Auch bei gecachten Opcodes interpretiert die VM sie weiterhin. JIT kompiliert häufig ausgeführte Opcode-Sequenzen in native CPU-Anweisungen und entfernt den Dispatch-Overhead der VM. Der Gewinn ist groß bei CPU-gebundenem numerischem Code, aber moderat bei typischen I/O-gebundenen Web-Apps, die Zeit in Datenbanken und Netzwerken statt auf der CPU verbringen.

JIT konfigurieren

JIT ist in OPcache integriert, daher muss OPcache aktiviert sein. opcache.jit_buffer_size reserviert Speicher für den erzeugten Maschinencode (0 deaktiviert JIT). opcache.jit ist ein vierstelliger Modus, der Auslöser und Optimierungsstrategie steuert.

; Enable JIT (requires opcache.enable=1)
opcache.jit_buffer_size = 128M
opcache.jit = tracing        ; alias for 1254, the common default

; The 4 digits CRTO mean:
;   C - CPU optimization flags
;   R - register allocation
;   T - trigger (when to JIT)
;   O - optimization level

Tracing JIT vs. Function JIT

Es gibt zwei Strategien: Function JIT (Modus 1205) kompiliert ganze Funktionen beim ersten Aufruf; Tracing JIT (1254, der Standardalias tracing) profiliert die Ausführung und kompiliert häufig ausgeführte Schleifen und Pfade. Das führt oft zu besseren Ergebnissen, weil die Optimierung auf beobachtete Typen spezialisiert werden kann. Tracing ist die empfohlene Standardeinstellung.

; Tracing JIT (recommended) — compiles hot traces
opcache.jit = tracing

; Function JIT — compiles entire functions when first called
; opcache.jit = function

; Disable JIT but keep opcode cache
; opcache.jit_buffer_size = 0

Auswirkungen von JIT messen

JIT spielt seine Stärken in engen numerischen Schleifen aus. Dieser eigenständige Benchmark mit einer Mandelbrot-ähnlichen inneren Schleife entspricht der Art CPU-gebundener Arbeitslast, bei der JIT die Laufzeit deutlich verkürzen kann. Führen Sie ihn mit und ohne jit_buffer_size aus, um die Ergebnisse zu vergleichen.

<?php
function mandelEscape(float $cr, float $ci, int $max): int {
    $zr = 0.0; $zi = 0.0; $n = 0;
    while ($n < $max && ($zr * $zr + $zi * $zi) <= 4.0) {
        $t  = $zr * $zr - $zi * $zi + $cr;
        $zi = 2.0 * $zr * $zi + $ci;
        $zr = $t;
        $n++;
    }
    return $n;
}

$start = hrtime(true);
$sum = 0;
for ($y = 0; $y < 200; $y++) {
    for ($x = 0; $x < 200; $x++) {
        $sum += mandelEscape($x / 100 - 2, $y / 100 - 1, 256);
    }
}
printf("sum=%d  time=%.2f ms\n", $sum, (hrtime(true) - $start) / 1e6);
?>

Wann Sie KEINE Verbesserungen erwarten sollten

Bei einer typischen Anfrage, die eine Datenbank abfragt, ein Template rendert und JSON zurückgibt, führt die CPU nur wenig reine Arithmetik aus – JIT bringt möglicherweise Verbesserungen im einstelligen Prozentbereich oder gar keine. Priorisieren Sie zunächst OPcache, Preloading und eine gute Nutzung von Datenbanken und Caches. Stimmen Sie JIT nur für Bildverarbeitung, Mathematik, Parser und anderen rechenintensiven Code ab.

Kurztest

Was bietet Preloading, was das gewöhnliche Caching durch OPcache nicht bietet?

Zusammenfassung

OPcache cached kompilierte op_arrays im gemeinsamen Speicher und führt einen Optimierer aus. Setzen Sie in der Produktion validate_timestamps=0 und dimensionieren Sie memory_consumption/max_accelerated_files angemessen. Preloading hält ausgewählte Klassen beim Start dauerhaft im Speicher. JIT (in OPcache integriert und mit jit_buffer_size) kompiliert häufig ausgeführten Code in native Anweisungen – mit großen Vorteilen bei CPU-gebundener Mathematik, aber wenig bei I/O-gebundenen Web-Apps. Verwenden Sie opcache_get_status() zur Überprüfung.

Häufig gestellte Fragen

Ist die Lektion „OPcache und JIT-Kompilierung“ kostenlos?

Ja — der vollständige Text von „OPcache und JIT-Kompilierung“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des PHP Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der PHP Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „OPcache und JIT-Kompilierung“?

PHP mit Bytecode-Caching und JIT beschleunigen Du übst PHP Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um PHP Academy zu starten?

Keine Vorkenntnisse erforderlich. PHP Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „OPcache und JIT-Kompilierung“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser PHP Academy-Lektion Code schreiben und ausführen?

Ja. Jede PHP Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

So funktioniert die Zend Engine
Speicherverwaltung und Garbage Collection
OPcache und JIT-Kompilierung
Eine einfache PHP-Erweiterung in C schreiben

← Zurück zu PHP Academy