Have you ever wondered how PHP echo’s a “Hello World” for you on the browser? Even I didn’t until I read about the PHP internals and extensions. I thought may be a few out there will be interested in exploring the other side of PHP, so here we go.
In my last post I discussed in brief “How your browser reaches to my server when you type http://abhinavsingh.com in address bar?”. Read through if you have missed out on that. Here I will discuss in brief “How does PHP churns out the content requested on the webpage?”
Here is what happens step-wise:
- We never start any PHP daemon or anything by ourself. When we start Apache, it starts the PHP interpreter along itself
- PHP is linked to Apache (In general term SAPI i.e. a Server API) using mod_php5.so module
- PHP as a whole consists of 3 modules (Core PHP, Zend Engine and Extension Layer)
- Core PHP is the module which handles the requests, file streams, error handling and other such operations
- Zend Engine(ZE) is the one which converts human readable code into machine understandable tokens/op-codes. Then it executes this generate code into a Virtual Machine.
- Extensions are a bunch of functions, classes, streams made available to the PHP scripts, which can be used to perform certain tasks. For example, we need mysql extension to connect to MySQL database using PHP.
- While Zend Engine executes the generated code, the script might require access to a few extensions. Then ZE passes the control to the extension module/layer which transfer back the control to ZE after completion of tasks.
- Finally Zend Engine returns back the result to PHP Core, which gives that to SAPI layer, and finally which displays it on your browser.
A Step Deeper
But wait! This is still not over yet. Above was just a high level flow diagram. Lets dig a step deeper and see what more is happening behind the scenes:
- When we start Apache, it also starts PHP interpreter along itself
- PHP startup happens in 2 steps
- 1st step is to perform initial setup of structures and values that persists for the life of SAPI
- 2nd step is for transient settings that only last for a single page request
Step 1 of PHP Startup
Confused over what’s step 1 and 2 ? No worries, next we will discuss the same in a bit more detail. Lets first see step 1, which is basically the main stuff.
Remember step 1 happens even before any page request is being made.
- As we start Apache, it starts PHP interpreter
- PHP calls MINIT method of each extension, which is being enabled. View your php.ini file to see the modules which are being enabled by default
- MINIT refers to Module Initialization. Each Module Initialization method initializes and define a set of functions, classes which will be used by future page requests
A typical MINIT method looks like:
/* Initialize functions, classes etc */
Step 2 of PHP Startup
- When a page request is being made, SAPI layer gives control to PHP layer. PHP then set up an environment to execute the PHP page requested. In turn it also create a symbol table which will store various variables being used while executing this page.
- PHP then calls the RINIT method of each module. RINIT refers to Request Initialization Module. Classic example of RINIT module implementation is the Session’s module. If enabled in php.ini, the RINIT method of Sessions module will pre-populate the $_SESSION variable and save in the symbol table.
- RINIT method can be thought as an auto_prepend_file directive, which is pre-appended to every PHP script before execution.
A typical RINIT method looks like:
/* Initialize session variables, pre-populate variables, redefine global variables etc */
Step 1 of PHP Shutdown
Just like PHP startup, shutdown also happens in 2 steps.
- After the page execution is complete either by reaching the end of the script or by call of any exit() or die() function, PHP starts the cleanup process. In turn it calls RSHUTDOWN method of every extension. RSHUTDOWN can be thought as auto_append_file directive to every PHP script, which no matter what happens, is always executed.
- RSHUTDOWN method, destroys the symbols table (memory management) by calling unset() on all variables in the symbols table
A typical RSHUTDOWN method looks like:
/* Do memory management, unset all variables used in the last PHP call etc */
Step 2 of PHP Shutdown
Finally when all requests has been made and SAPI is ready to shutdown, PHP call its 2nd step of shutdown process.
- PHP calls the MSHUTDOWN method of every extension, which is basically the last chance for every extension to unregister handlers and free any persistent memory allocated during the MINIT cycle.
A typical RSHUTDOWN method looks like:
/* Free handlers and persistent memory etc */
And that brings us to the end of what we can call as PHP Lifecycle. Important point to note is that Step 1 of Startup and Step 2 of Shutdown happens when no request is being made to the web servers.
I hope this post will clear many doubts and un-answered questions which you might have.
Do leave a comment and feedbacks.