Unveiling PHP’s Core: Architecture, Engine, and Memory Mechanics

Design Philosophy and Characteristics

PHP is a dynamic language for web development, implemented as a C‑based framework with a powerful UI‑like component model. Its design emphasizes a multi‑process model, weak typing, a modular Zend engine plus extensions, a SAPI layer separating the web server, and simple yet flexible syntax.

Four‑Layer Architecture

Zend Engine : Core written in pure C, responsible for lexical and syntax analysis, compilation to opcodes, memory management, and providing APIs for extensions.

Extensions : Component‑based modules offering built‑in functions (e.g., array utilities) and allowing custom extensions for added functionality and performance.

SAPI (Server Application Programming Interface): Bridges PHP with the web server or CLI, enabling different execution environments without coupling PHP to a specific server.

Application Layer : User‑written PHP scripts running via various SAPI modes (web, CLI, etc.).

Analogously, PHP is the vehicle, Zend the engine, extensions the wheels, and SAPI the road.

SAPI Implementations

apache2handler – Apache module using mod_php.

cgi – FastCGI interface, increasingly popular for asynchronous servers.

cli – Command‑line interface for scripts.

Execution Process and Opcodes

PHP code undergoes lexical and syntax parsing, then is compiled into a series of opcodes executed sequentially by the Zend virtual machine. The core of execution is the opcode, each consisting of two operands, a return value, and a handler function.

ZEND_ASSIGN_SPEC_CV_CV_HANDLER: variable assignment ($a=$b) ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER: function call ZEND_CONCAT_SPEC_CV_CV_HANDLER: string concatenation ($a.$b) ZEND_ADD_SPEC_CV_CONST_HANDLER: addition ($a+2) ZEND_IS_EQUAL_SPEC_CV_CONST: equality check ($a==1) ZEND_IS_IDENTICAL_SPEC_CV_CONST: strict equality ($a===1)

HashTable – Core Data Structure

The Zend HashTable implements associative arrays and underlies many internal structures such as symbol tables and global variables. It supports key‑value lookups, array usage, O(1) insert/delete, mixed key types, and linear traversal via a doubly‑linked list.

Typical hash table operations are illustrated below:

getKeyHashValue h;
index = n & nTableMask;
Bucket *p = arBucket[index];
while (p) {
    if ((p->h == h) & (p->nKeyLength == nKeyLength)) {
        RETURN p->data;
    }
    p = p->next;
}

Variables and Zval

PHP variables are weakly typed and stored in a unified structure called zval, which contains a type identifier, reference count flags, and the actual value (often a union to support multiple types).

Reference counting enables copy‑on‑write semantics: when a variable is assigned, the refcount increments; on modification, the engine separates the value, ensuring efficient memory use.

Scalar types (int, float) are stored directly in the value field, while strings are represented by a pointer and length, allowing binary data and O(1) length retrieval. When strings are concatenated, Zend may realloc the existing buffer for efficiency, but using sprintf incurs additional parsing overhead.

Resources

Resources are opaque handles to external structures (e.g., MySQL connections). They are registered with a unique identifier, fetched via a hash table, and require explicit destructor functions. Persistent resources survive across requests, improving performance for long‑lived connections.

Symbol Tables and Scope

PHP maintains a global symbol table and an active symbol table for the current execution context. Functions receive their own symbol table, enabling distinction between local and global variables. Global variables can be accessed inside functions using the global keyword.

Source: PHP developers community.