Performance

Performance

Symfony is fast, right out of the box. However, you can make it faster if you optimize your servers and your applications as explained in the following performance checklists.

Performance Checklists

Use these checklists to verify that your application and server are configured for maximum performance:

Install APCu Polyfill if your Server Uses APC

If your production server still uses the legacy APC PHP extension instead of OPcache, install the APCu Polyfill component in your application to enable compatibility with APCu PHP functions and unlock support for advanced Symfony features, such as the APCu Cache adapter.

Restrict the Number of Locales Enabled in the Application

Use the framework.translator.enabled_locales option to only generate the translation files actually used in your application.

Dump the Service Container into a Single File

Symfony compiles the service container into multiple small files by default. Set this parameter to true to compile the entire container into a single file, which could improve performance when using “class preloading” in PHP 7.4 or newer versions:

  • YAML

    1. # config/services.yaml
    2. parameters:
    3.     # ...
    4.     container.dumper.inline_factories: true

  • XML

    1. <!-- config/services.xml -->
    2. <?xml version="1.0" encoding="UTF-8" ?>
    3. <container xmlns="http://symfony.com/schema/dic/services"
    4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    5.     xsi:schemaLocation="http://symfony.com/schema/dic/services https://symfony.com/schema/dic/services/services-1.0.xsd">
    7.     <parameters>
    8.         <!-- ... -->
    9.         <parameter key="container.dumper.inline_factories">true</parameter>
    10.     </parameters>
    11. </container>

  • PHP

    1. // config/services.php
    3. // ...
    4. $container->parameters()->set('container.dumper.inline_factories', true);

Use the OPcache Byte Code Cache

OPcache stores the compiled PHP files to avoid having to recompile them for every request. There are some byte code caches available, but as of PHP 5.5, PHP comes with OPcache built-in. For older versions, the most widely used byte code cache is APC.

Use the OPcache class preloading

Starting from PHP 7.4, OPcache can compile and load classes at start-up and make them available to all requests until the server is restarted, improving performance significantly.

During container compilation (e.g. when running the cache:clear command), Symfony generates a file with the list of classes to preload in the var/cache/ directory. Rather than use this file directly, use the config/preload.php file that is created when using Symfony Flex in your project:

  1. ; php.ini
  2. opcache.preload=/path/to/project/config/preload.php
  4. ; required for opcache.preload:
  5. opcache.preload_user=www-data

If this file is missing, run this command to reinstall the Symfony Flex recipe: composer recipes:install symfony/framework-bundle --force -v.

Use the container.preload and container.no_preload service tags to define which classes should or should not be preloaded by PHP.

Configure OPcache for Maximum Performance

The default OPcache configuration is not suited for Symfony applications, so it’s recommended to change these settings as follows:

  1. ; php.ini
  2. ; maximum memory that OPcache can use to store compiled PHP files
  3. opcache.memory_consumption=256
  5. ; maximum number of files that can be stored in the cache
  6. opcache.max_accelerated_files=20000

Don’t Check PHP Files Timestamps

In production servers, PHP files should never change, unless a new application version is deployed. However, by default OPcache checks if cached files have changed their contents since they were cached. This check introduces some overhead that can be avoided as follows:

  1. ; php.ini
  2. opcache.validate_timestamps=0

After each deploy, you must empty and regenerate the cache of OPcache. Otherwise you won’t see the updates made in the application. Given that in PHP, the CLI and the web processes don’t share the same OPcache, you cannot clear the web server OPcache by executing some command in your terminal. These are some of the possible solutions:

  1. Restart the web server;
  2. Call the apc_clear_cache() oropcache_reset() functions via the web server (i.e. by having these in a script that you execute over the web);
  3. Use the cachetool utility to control APC and OPcache from the CLI.

Configure the PHP realpath Cache

When a relative path is transformed into its real and absolute path, PHP caches the result to improve performance. Applications that open many PHP files, such as Symfony projects, should use at least these values:

  1. ; php.ini
  2. ; maximum memory allocated to store the results
  3. realpath_cache_size=4096K
  5. ; save the results for 10 minutes (600 seconds)
  6. realpath_cache_ttl=600

Note

PHP disables the realpath cache when the open_basedir config option is enabled.

Optimize Composer Autoloader

The class loader used while developing the application is optimized to find new and changed classes. In production servers, PHP files should never change, unless a new application version is deployed. That’s why you can optimize Composer’s autoloader to scan the entire application once and build an optimized “class map”, which is a big array of the locations of all the classes and it’s stored in vendor/composer/autoload_classmap.php.

Execute this command to generate the new class map (and make it part of your deployment process too):

  1. $ composer dump-autoload --no-dev --classmap-authoritative
  • --no-dev excludes the classes that are only needed in the development environment (i.e. require-dev dependencies and autoload-dev rules);
  • --classmap-authoritative creates a class map for PSR-0 and PSR-4 compatible classes used in your application and prevents Composer from scanning the file system for classes that are not found in the class map. (see: Composer’s autoloader optimization).

Profiling Symfony Applications

Profiling with Blackfire

Blackfire is the best tool to profile and optimize performance of Symfony applications during development, test and production. It’s a commercial service, but provides free features that you can use to find bottlenecks in your projects.

Profiling with Symfony Stopwatch

Symfony provides a basic performance profiler in the development config environment. Click on the “time panel” of the web debug toolbar to see how much time Symfony spent on tasks such as making database queries and rendering templates.

You can measure the execution time and memory consumption of your own code and display the result in the Symfony profiler thanks to the Stopwatch component.

When using autowiring, type-hint any controller or service argument with the Symfony\Component\Stopwatch\Stopwatch class and Symfony will inject the debug.stopwatch service:

  1. use Symfony\Component\Stopwatch\Stopwatch;
  3. class DataExporter
  4. {
  5.     private $stopwatch;
  7.     public function __construct(Stopwatch $stopwatch)
  8.     {
  9.         $this->stopwatch = $stopwatch;
  10.     }
  12.     public function export()
  13.     {
  14.         // the argument is the name of the "profiling event"
  15.         $this->stopwatch->start('export-data');
  17.         // ...do things to export data...
  19.         // reset the stopwatch to delete all the data measured so far
  20.         // $this->stopwatch->reset();
  22.         $this->stopwatch->stop('export-data');
  23.     }
  24. }

If the request calls this service during its execution, you’ll see a new event called export-data in the Symfony profiler.

The start(),stop() and getEvent() methods return aSymfony\Component\Stopwatch\StopwatchEvent` object that provides information about the current event, even while it’s still running. This object can be converted to a string for a quick summary:

  1. // ...
  2. dump((string) $this->stopwatch->getEvent()); // dumps e.g. '4.50 MiB - 26 ms'

You can also profile your template code with the stopwatch Twig tag:

  1. {% stopwatch 'render-blog-posts' %}
  2.     {% for post in blog_posts %}
  3.         {# ... #}
  4.     {% endfor %}
  5. {% endstopwatch %}

Profiling Categories

Use the second optional argument of the `start() method to define the category or tag of the event. This helps keep events organized by type:

  1. $this->stopwatch->start('export-data', 'export');

Profiling Periods

A real-world stopwatch not only includes the start/stop button but also a “lap button” to measure each partial lap. This is exactly what the `lap() method does, which stops an event and then restarts it immediately:

  1. $this->stopwatch->start('process-data-records', 'export');
  3. foreach ($records as $record) {
  4.     // ... some code goes here
  5.     $this->stopwatch->lap('process-data-records');
  6. }
  8. $event = $this->stopwatch->stop('process-data-records');
  9. // $event->getDuration(), $event->getMemory(), etc.
  11. // Lap information is stored as "periods" within the event:
  12. // $event->getPeriods();

Profiling Sections

Sections are a way to split the profile timeline into groups. Example:

  1. $this->stopwatch->openSection();
  2. $this->stopwatch->start('validating-file', 'validation');
  3. $this->stopwatch->stopSection('parsing');
  5. $events = $this->stopwatch->getSectionEvents('parsing');
  7. // later you can reopen a section passing its name to the openSection() method
  8. $this->stopwatch->openSection('parsing');
  9. $this->stopwatch->start('processing-file');
  10. $this->stopwatch->stopSection('parsing');

Learn more

This work, including the code samples, is licensed under a Creative Commons BY-SA 3.0 license.