Improving PHP Performance for Web Applications

As a web developer, you must be always on the lookout for ways to improve the performance of your applications. With the increasing demand for faster and more efficient web applications, optimizing PHP performance has become a critical aspect of web development. In this blog, we will explore some of the best practices and tips for improving PHP performance for web applications. The best tool for improving PHP performance isn't any individual program; it's knowing which problems to look for and how to address them. This guide will cover everything you need to know to ensure that your PHP applications always run smoothly.

A brief history of PHP

PHP is a scripting language invented by Rasmus Lerdorf in 1995. Initially intended for the developer's personal use, "PHP" was originally an acronym for "Personal Home Page." Lerdorf initially developed PHP as a set of Common Gateway Interface (CGI) scripts for tracking visitors to his personal website. Over time, he added more features to the language, such as dynamic generation of HTML pages, and released it as an open-source project in 1995.

In 1997, two developers, Andi Gutmans and Zeev Suraski, rewrote the core of PHP and transformed it into a more robust and efficient language. This new version of PHP, known as PHP 3, gained popularity quickly and became widely used for developing dynamic web pages.

Since then, PHP has continued to evolve and improve, with the addition of new features such as improved object-oriented programming, better security features, and improved performance. Today, PHP is one of the most widely used server-side scripting languages, powering some of the biggest websites on the internet, including Facebook, Wikipedia, and WordPress.

In recent years, PHP has also seen the introduction of new versions. In 2015, PHP 7.0 was released with updates including improvements to the Zend Engine and an overall reduction in memory use. At the time of writing this article, the newest available version is PHP 8.2, which was announced in December of 2022. The PHP Classes website contains extensive details about all of the changes made in PHP 8.2.

What exactly is good PHP performance?

Performance and speed are not necessarily synonymous. Achieving optimal performance is often a balancing act that requires trade-offs between speed, accuracy, and scalability. For example, while building a web application, you may have to decide between prioritizing speed by writing a script that loads everything into memory up front or prioritizing scalability with a script that loads data in chunks.

Based on a representation from phplens, the image below depicts the theoretical trade-off between speed and scalability:

The red line represents a script optimized for speed, and the blue line is a script that prioritizes scalability. When the number of simultaneous connections is low, the red line runs faster; however, as the number of users grows, the red line becomes slower. The blue line also slows down when traffic rises; however, the decline isn't as drastic, so the script tuned for speed actually becomes slower than the script tuned for scalability after a certain threshold.

A real world analogy would be the comparison between a sprinter and a cross-country runner. Sprinters are much faster when running short races, but they tire out in longer competitions. Cross-country runners keep a slower but more consistent pace, which allows them to conserve energy and travel longer distances. The two athletes are better suited for different situations. Likewise, some scripts work better in different scenarios. Choosing the right one for your application will require careful consideration of your users. You may have to adjust scripts over time as your traffic increases.

When to begin optimizing PHP code

Experienced programmers sometimes save the fine-tuning of code for the end of a project cycle. However, this is only advisable if you are certain of your PHP application's performance parameters. A more sensible approach is to conduct tests during the development process; otherwise, you may find yourself rewriting large chunks of code to make your application function properly.

Before you start designing a PHP application, run benchmarks on your hardware and software to determine your performance parameters. This information can guide your coding by helping you weigh the risks and benefits of specific trade-offs. Be sure to use adequate test data, or else you could create code that doesn't scale.

Tips for optimizing PHP scripts

Writing good code is the essential first step to creating PHP applications that are fast and stable. Following these best practices from the beginning will save time on troubleshooting later.

1. Take advantage of native PHP functions

Wherever possible, try to take advantage of PHP's native functions instead of writing your own functions to achieve the same outcome. Taking a little while to learn how to use PHP's native functions will not only help you write code faster, but will also make it more efficient.

2. Use JSON instead of XML

Speaking of which, native PHP functions such as json_encode() and json_decode() are incredibly fast, which is why using JSON is preferable to using XML. If you are committed to XML, be sure to parse it using regular expressions rather than DOM manipulation.

3. Cash in on caching techniques

Memcache is particularly useful for reducing your database load while bytecode caching engines like OPcache are great for saving execution time when scripts get compiled.

4. Cut out unnecessary calculations

When using the same value of a variable multiple times, calculate and assign the value at the beginning rather than performing calculations for every use.

5. Use isset()

Compared to count(), strlen(), and sizeof(), isset() is a faster and simpler way to determine if a value is greater than 0.

6. Cut out unnecessary classes

If you don't intend on using classes or methods multiple times, then you don't really need them. If you must employ classes, be sure to use derived class methods as they are faster than methods in base classes.

7. Turn off debugging notifications

Alerts that draw your attention to errors come in handy during the coding process, but they become just one more process that slows you down after launch. Disable such notifications before going live.

8. Close database connections

Unsetting variables and closing database connections in your code will save precious memory.

9. Limit your database hits

Making queries aggregate can reduce the number of hits to your database, which will make things run faster.

10. Use the strongest str functions

While str_replace is faster than preg_replace, the strtr function is four times faster than str_replace.

11. Stick with single quotes

When possible, use single quotes rather than double quotes. Double quotes check for variables, which can drag down performance.

12. Try three equal signs

Since === only checks for a closed range, it is faster than using == for comparisons.

Types of bottlenecks that affect PHP performance

Tinkering with your scripts can certainly be beneficial. However, there are also issues that have nothing to do with code which can also hinder PHP performance. This is why developers need a thorough understanding of their server's subsystems to identify and address bottlenecks. Below are areas you should check if you're having performance issues.

1. The network

One obvious source of bottlenecks are networks. Depending on your current network's capacity, it may lack the power to handle the amount of data being transmitted.

2. The CPU

Transmitting plain HTML pages across a network doesn't drain your CPU, but PHP applications do. Depending on your requirements, you may at least a server with multiple processors to process your PHP code efficiently.

3. Shared memory

A lack of shared memory can disrupt inter-process communication, which can lead to lagging performance.

4. The filesystem

Your filesystem can become fragmented over time. A file cache that uses RAM can speed up disk access so long as there is enough memory.

5. Process management

Make sure your server isn't overburdened with unnecessary processes. Remove any unused networking protocols, antivirus scanners, mail servers and hardware drivers. Running PHP in multi-threaded mode can also result in better response times.

6. Other servers

If your application depends on outside servers, a bottleneck on the other server can slow you down. There is not much you can do in such scenarios, but you can make alterations on your side to mitigate deficiencies on the other end.

More tips for improving PHP performance

1. Take advantage of OPcache

Since PHP is interpreted into executable code extemporaneously, programmers don't have to pause to compile code every time they make a small change. Unfortunately, recompiling identical code every time it runs on your website slows performance, which is why opcode cache, or OPCache is very useful.

OPcache is an extension that saves compiled code into memory. Therefore, the next time the code executes, PHP will check timestamps and file sizes to determine if the source file has been altered. If it has not, the cached code will run.

The image below shows the difference in execution time and memory usage between a PHP application running with no cache, OPcache, and eAccelerator (another PHP caching tool).

2. Identify database delays

As discussed above, performance problems are not always caused by code. Most bottlenecks occur when your application must access resources. Since the data access layer of a PHP application can account for up to 90 percent of execution time, one of the first steps you should take is to look at all instances of database access in your codebase.

Make sure slow SQL logs are turned on to help you identify and address slow SQL queries, and then query the queries to assess their efficiency. If you discover that too many queries are being made, or if you find that the same queries are being made several times during a single execution, you can make adjustments that boost your application's performance by cutting down on database access time.

3. Clean up your filesystem

Skim your filesystem for inefficiencies, and make sure the filesystem isn't being used for session storage. Most importantly, keep an eye out for code that can trigger a file stat such as file_exists(), filesize(), or filetime(). Leaving any of these functions in a loop can lead to performance issues.

4. Carefully monitor your APIs

Most web applications that depend upon external resources leverage remote APIs. Although remote APIs are out of your control, there are actions you can take to mitigate problems stemming from API performance. For example, you can cache API output or make API calls in the background. Establish reasonable timeouts for API requests and, if possible, be prepared to display output without an API response.

5. Profile your PHP

Using OPcache and managing your external resources should be enough to make most applications run smoothly; however, if you find your needs increasing, it might be time to profile your PHP. A full PHP code profile can be time-consuming, but it can supply you with in-depth information about your application's performance. Thankfully, there are a handful of open source programs for profiling your PHP code such as Xdebug.

The importance of monitoring PHP performance

Your web application may be running fine at one minute, but a sudden barrage of traffic can cause your application to crash if you're unprepared. Of course, making changes always requires time, effort and money, and it can be difficult to tell if the investment is worth it. The best way to make informed decisions is to continually collect data.

PHP performance monitoring software like New Relic, Logtail, or PHP Server Monitor help you immediately measure the effects of any changes you make. Of course, knowing what to measure is equally important. Speed and memory usage are considered the best indicators of performance because they impact page load times, which are critical to web applications.

While data collection is important, you should turn off your monitoring system when you don't need it because an influx of logs can slow things down. Of course, such logs give you valuable information about how to improve performance, so you should periodically monitor during peak traffic periods.

The future of PHP performance

The future of PHP performance looks promising. With each new version of PHP, the language continues to evolve and improve, making it faster, more efficient, and more secure. The PHP development community is constantly working to optimize the language and make it better suited to modern web development needs.

In the future, we can expect to see continued improvements in performance, with a focus on making PHP even faster and more efficient. This could be achieved through the use of new technologies, such as Just-In-Time (JIT) compilation, and the implementation of new features and optimizations. Additionally, the PHP development community is also likely to continue to focus on improving the security of the language, to ensure that PHP-powered applications remain safe and secure.

When building web applications, remember that what works today might not work next year. You may have to make adjustments to maintain consistent PHP performance. Focusing on the big picture during the entire development process is the best strategy for building PHP apps and websites that work for the masses.