Live PHP benchmarks, demystifying “best practices”

    Akash Mehta
    Akash Mehta
    As a new contributor to the SitePoint blogs, I’ll be covering PHP web development, JavaScript and general web tech.
    When it comes to optimizing PHP for performance, there’s no end of resources available, and no end of conflicting opinions either. Everyone seems to have their own approach to writing “fast” PHP code; using single quotes, avoiding require_once() and using isset() before is_array() are some of the most common. But with reliable benchmarks thin on the ground, how do we know if any of these techniques – often touted as “performance best practices” – actually deliver benefits? Chris Vincent’s new PHP benchmark suite at aims to “set the record straight” on PHP performance techniques, with a simple, comprehensive view of how various approaches actually stack up. The benchmark suite covers all the usual bases, taking a simple task — like iterating over an array — and speed testing almost every possible way to achieve it. Most importantly, however, Chris takes raw numbers out of the spotlight and instead focuses on how the options compare with each other. Each test takes the fastest technique as the base value for execution time; all the other options are measured as percentages in relation to this. For example, foreach($aHash as $val) has script execution time of 558% compared to while(list($key) = each($aHash)) $tmp[] = $aHash[$key] with 100%. The test scores are also generated live; refreshing the page will produce a slightly different set of results. Chris uses the header of the relatively uncomplicated results page to recommend refreshing a few times, just to ensure consistency and to avoid a one-off impact on any particular test. Personally, I’d have preferred the tests be carried out in a controlled environment and regenerated every time a new test is added; anomalies don’t help anyone and live benchmarking offers little real benefit besides operational simplicity. The code for each test is supplied for transparency. His current set of tests are very comprehensive; no less than 13 tests compared the performance of various echo and print
    calls, with enough variety to check for any usage scenario. He’s also accepting suggestions for new tests. Most importantly, however, many of his tests help identify the value of best practices. For example, PHP is often criticised for the vague results of == comparisons; the control structures tests show us that not only is === safer, it also takes about 2/3 as long to execute. While most of the tests show trivial performance differences, there are some interesting results. For example, iterating over an array and modifying each element is 100 times as fast using while(list($key) = each($aHash)) than a simple foreach ($aHash as $key=>$val), while array_keys()
    is about 20 times slower than while(list($key,$val) = each($aHash));. The next step, of course, would be to download the test suite to your local machine or server and run the tests yourself, to see how the factors of your production environment affect the results; Chris aims to make this possible in the near future. Many of the techniques listed are clearly going to be either memory-efficient or CPU cycle efficient, and the limits of your infrastructure will determine which way you want to go before scaling out. Nevertheless, managing bottlenecks in your code can really help you get the most out of your servers — after all, if you can achieve something 100 times as fast, why not? — and could become the definitive reference on PHP performance. Update: Many commenters have noted issues with the usefulness and reliability of the tests. It’s important to consider Chris’ intentions while creating the site, as he’s described in the comments. With all the “use this syntax because it’s slightly faster” posts, was built to see if there is any real material benefit to using a particular syntax; most of the tests show that there clearly isn’t. I’ve done a few tests of my own and seen similar results, but if something looks amiss, feel free to point it out to Chris. The site is not trying to identify immaterial performance benefits from e.g. single quotes vs. double quotes. Moving further, PHP Bench could be used to measure algorithm performance and other more intensive procedures; for now, the basic syntax tests simply reflect the potential of the system. Hopefully this clears things up.

    Frequently Asked Questions about PHPBench and Best Practices

    What is PHPBench and why is it important?

    PHPBench is a benchmarking tool specifically designed for PHP. It provides a way to measure the performance of PHP code in a consistent and reliable manner. This is important because it allows developers to identify bottlenecks in their code and make necessary optimizations. By using PHPBench, developers can ensure their code runs as efficiently as possible, which can lead to improved user experience and potentially lower server costs.

    How do I install PHPBench?

    PHPBench can be installed using Composer, a dependency management tool for PHP. You can install Composer globally on your system, and then use it to install PHPBench. The command to install PHPBench using Composer is composer require --dev phpbench/phpbench. After running this command, PHPBench will be installed in your project’s vendor directory.

    How do I use PHPBench to benchmark my code?

    To use PHPBench, you need to write a benchmarking class. This class should contain methods that represent the code you want to benchmark. Each method should be annotated with the @BeforeMethods and @AfterMethods annotations to specify setup and teardown methods. Once your benchmarking class is ready, you can run the benchmarks using the phpbench run command.

    How do I interpret the results from PHPBench?

    PHPBench provides a variety of metrics, including the mean time, the standard deviation, and the best and worst times. The mean time gives you an average of how long your code takes to run, while the standard deviation shows how much variation there is in the run times. The best and worst times show the fastest and slowest run times, respectively. By analyzing these metrics, you can get a good idea of how your code performs under different conditions.

    What are some best practices for using PHPBench?

    Some best practices for using PHPBench include isolating the code you want to benchmark, using a representative dataset, and running your benchmarks multiple times. Isolating your code ensures that you’re only measuring the performance of the code you’re interested in. Using a representative dataset ensures that your benchmarks accurately reflect the conditions your code will be running under. Running your benchmarks multiple times helps to account for variability in run times.

    Can PHPBench be used to benchmark database queries?

    Yes, PHPBench can be used to benchmark database queries. However, keep in mind that the performance of database queries can be influenced by many factors outside of your PHP code, such as the database server’s load and network latency. Therefore, it’s important to interpret the results of database query benchmarks with caution.

    How does PHPBench compare to other benchmarking tools?

    PHPBench is specifically designed for benchmarking PHP code, so it provides features and metrics that are particularly useful for PHP developers. However, there are many other benchmarking tools available that can be used for different purposes. For example, Apache JMeter is a popular tool for load testing web applications, while Google’s PageSpeed Insights can be used to measure the performance of a website from a user’s perspective.

    Can PHPBench be integrated with continuous integration (CI) systems?

    Yes, PHPBench can be integrated with CI systems. This allows you to automatically run your benchmarks whenever you make changes to your code. By integrating PHPBench with your CI system, you can ensure that performance regressions are caught and addressed as early as possible.

    What are some common mistakes to avoid when using PHPBench?

    Some common mistakes to avoid when using PHPBench include not isolating the code you want to benchmark, using an unrepresentative dataset, and not running your benchmarks multiple times. These mistakes can lead to misleading results and make it harder to identify performance bottlenecks in your code.

    Where can I find more information about PHPBench?

    More information about PHPBench can be found in the official documentation, which is available on the PHPBench website. The documentation provides a comprehensive guide to using PHPBench, including detailed explanations of the various metrics and annotations. Additionally, you can find many tutorials and blog posts online that provide practical examples of how to use PHPBench.