Improving the Speed of PHP Web Scripts

by Bruno Pedro

PHP web scripts lose performance for a lot of reasons. The bottleneck can be in database queries, web page access or even slow algorithms. When performance drops, the user gets frustrated waiting for results. Less users mean less business, and your web site becomes unpopular.

The main reason for performance loss is bad software analysis and engineering. Web sites often are created and launched without thorough performance testing. Databases often are designed to accommodate less data than they actually do. Algorithms often are designed poorly and usually are not optimized for speed.

When you cannot redesign the entire web design so that it runs more quickly, you must improve its performance by serving static pages instead of interpreting PHP whenever there's a hit. Let's look at the ways to achieve this goal.

The Traditional Solution

The first thing that you can do is preprocess those PHP scripts, or script parts, that take more time to execute. You can do it with the help of a PHP shell. Suppose you have a web script called index.php, and you want to preprocess it. Assuming that the PHP shell is called phpsh, the command line is:

phpsh -q /some_dir/index.php > /some_dir/index.html

The file index.html is now plain HTML and doesn't need any PHP processing. You can serve it right away to the web client. But what if the PHP script results change over time? You'd have to preprocess the script every time the results are different. The solution is to preprocess the PHP script periodically.

Periodic Preprocessing

In Linux, the easiest way to execute a given process periodically is called crontab. The following crontab entry illustrates a preprocessing that would execute every 15 minutes:

*/15 * * * * root phpsh -q /some_dir/index.php
> /some_dir/index.html

However, the chosen timing might not be enough to keep the information updated. Furthermore, some scripts are not accessed over long periods of time, while others are constantly accessed, making the use of this technique pointless. In this case, a script-based mechanism is needed.

Just-in-Time Preprocessing

This technique preprocesses scripts periodically, but only if they are accessed. It works much like a web proxy caching system. I will show two ways of implementing this functionality: output buffering and after-time processing.

Output buffering checks the cache file date and time and only processes the script if needed. The processing is done by buffering the output and saving it in the cache file before it is sent to the client.

In PHP you do this with the help of the ob_start() function. This function will turn output buffering on and send it to a callback function. There is another function to send the buffer back to the browser: ob_end_flush(). Let's take a look at an example:

// include header file
// sleep for 10 seconds


// include footer file
Inside header.php, you'll find all the cache processing. It begins by checking whether the script needs caching by calling the needscache() function. This function can check the need for cache based on a time out or based on anything you like. For the purpose of this article, the checking is based on cache time out.

If the script needs caching, the ob cycle is started, and the script output is written into the cache file. If it doesn't need caching, the script output is read from the cache file and sent to the client's browser (see Listing 1).

Listing 1. The script output is read from the cache file and sent to the client's browser.

The footer.php script simply closes the ob processing:


You can test this technique by calling the script many times before the cache times out. You'll notice that in the first call you'll have to wait ten seconds (this is because the script sleeps for ten seconds, for testing purposes), and in the following calls the output is immediate.

However, when the cache times out, you'll have to wait for the script to finish processing. Let's see how you can prevent this and give the user the illusion that the script is always fast.

After-view processing also checks the cache file date and time, but the processing is done after the file is served, solving the cache time out processing burden. This is done by caching the file after the script ends execution.

In PHP, you can do this by associating an arbitrary function with the script termination event through the register_shutdown_function(). The only file you'll have to change is header.php (see Listing 2).

Listing 2. Associating an Arbitrary Function with the Script Termination Event

I simply added the doaftercache() function that is called only after the script finishes. It then calls the script like a normal browser does and caches it. The only time you'll have to wait is when the script has never been cached before. Test it and you'll get the feeling that the script is very fast.


This article shows you how PHP cache mechanisms work and provides a do-it-yourself solution. If you test the examples and like them, please feel free to implement your own solutions. However, there other ways to improve performance like function caching, or PHP script precompilation. Some off-the-shelf solutions can offer you these functionalities. You should always look for the best solution for your own needs and do your own testing.


Bruno Pedro, cofounder and manager of ethernet lda., is a systems engineer with ten years' experience in database-related applications. He was an early adopter of Linux and has been using open-source technology since then. Since 1995 he has been developing applications for the Internet.

Load Disqus comments