Performance issues

[dominikhalvonik]

Hi guys,

I am a PHP developer and currently, I am working in a company that has several (around 30) microservices. All are dockerized with a combination of NginX 1.20.1 and PHP-FPM 8.2.2 via FastCGI and run on the Lumen 10 framework. Due to various issues and limitations that this framework provides (small number of packages, limited support from the community, etc.), the management has decided to move away from this platform and replace it. There are 2 options on the table:

1. Leave PHP behind and replace it with the Node.js / Nest.js framework
2. Migrate the code to Laravel

Both options have their pros and cons. The problem with the second option is the performance. When you migrate any application under Lumen 10 with a PHP-FPM/NginX combination to Laravel 10, it will be slower (even when you apply all the standard performance optimizations like config/route cache, commenting out all providers that you do not need, etc.). So, the only remaining option was to use Laravel Octane (https://laravel.com/docs/10.x/octane). Having read about Swoole a few years ago (https://www.zend.com/blog/swoole), I used Swoole as a server. Honestly, I was under the impression that this would fix my issue and we would be ready to migrate. However, I was mistaken and I don't know why. The Lumen app still outperforms the Laravel Octane app with Swoole. The applications are identical, so the problem must be in the config. So the config is following (both have identical Docker Compose structure):

Lumen

NginX config

server {
    listen 80;
    index index.php index.html;
    server_name game.wsm.pps.local;
    error_log  /var/log/nginx/error.log;
    access_log /var/log/nginx/access.log;
    root /var/www/wsm_game_api/public;

    location / {
        try_files $uri $uri/ /index.php?$query_string;
    }

    location ~ \.php$ {
        try_files $uri =404;
        fastcgi_split_path_info ^(.+\.php)(/.+)$;
        fastcgi_pass game-api-php:9000;
        fastcgi_index index.php;
        include fastcgi_params;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        fastcgi_param PATH_INFO $fastcgi_path_info;
    }
}

PHP-FPM Dockerfile

FROM library/php:8.2.2-fpm

RUN docker-php-ext-install pdo pdo_mysql opcache

RUN apt-get update && \
    apt-get install -y git && \
    apt-get install -y libzip-dev && \
    apt-get install -y zip unzip

RUN pecl install redis && \
    docker-php-ext-enable redis

RUN pecl install xdebug && \
    docker-php-ext-enable xdebug

# COMPOSER INSTALL
WORKDIR /var/www/wsm_game_api

COPY ./config/php.ini /usr/local/etc/php/php.ini

RUN curl -sS https://getcomposer.org/installer | php -- --install-dir=/usr/local/bin --filename=composer

ARG env_type

ENV ENV_TYPE $env_type
COPY ./src ./
COPY ./src/.env.$env_type ./.env
RUN composer install --prefer-dist --no-dev -o

RUN chmod 777 -R ./storage
# END COMPOSER INSTALL

EXPOSE 9000

CMD /bin/bash -c " \
          cp -f .env.local .env \
          && composer dump-autoload --optimize \
          && php-fpm"

PHP INI

[XDebug]
xdebug.mode=debug
xdebug.start_with_request=trigger
xdebug.discover_client_host=0


[opcache]
opcache.enable=1
; 0 means it will check on every request
; 0 is irrelevant if opcache.validate_timestamps=0 which is desirable in production
opcache.revalidate_freq=0
opcache.validate_timestamps=1
opcache.max_accelerated_files=10000
opcache.memory_consumption=192
opcache.max_wasted_percentage=10
opcache.interned_strings_buffer=16
opcache.fast_shutdown=1
opcache.jit_buffer_size=100M
opcache.jit=1255

Laravel Octane with Swoole

NginX config

map $http_upgrade $connection_upgrade {
    default upgrade;
    ''      close;
}


server {
    listen 80;
    listen [::]:80;
    index index.php index.html;
    server_name game.wsm.pps.local;
    error_log  /var/log/nginx/error.log;
    access_log /var/log/nginx/access.log;
    root /var/www/wsm_game_api/public;

    server_tokens off;
    charset utf-8;

    location /index.php {
        try_files /not_exists @octane;
    }

    location / {
        try_files $uri $uri/ @octane;
    }

    location = /favicon.ico { access_log off; log_not_found off; }
    location = /robots.txt  { access_log off; log_not_found off; }

    location @octane {
        resolver 127.0.0.11;
        set $suffix "";

        if ($uri = /index.php) {
            set $suffix ?$query_string;
        }

        proxy_http_version 1.1;
        proxy_set_header Host $http_host;
        proxy_set_header Scheme $scheme;
        proxy_set_header SERVER_PORT $server_port;
        proxy_set_header REMOTE_ADDR $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection $connection_upgrade;

        proxy_pass http://game-api-php-test:9000$suffix;
    }
}

PHP-FPM Dockerfile

FROM library/php:8.2.2-fpm

RUN docker-php-ext-install pdo pdo_mysql opcache pcntl

RUN apt-get update && \
    apt-get install -y git && \
    apt-get install -y libzip-dev && \
    apt-get install -y zip unzip

RUN pecl install redis && \
    docker-php-ext-enable redis

RUN pecl install swoole && \
    docker-php-ext-enable swoole

RUN pecl install xdebug && \
    docker-php-ext-enable xdebug

# COMPOSER INSTALL
WORKDIR /var/www/wsm_game_api

COPY ./config/php.ini /usr/local/etc/php/php.ini

RUN curl -sS https://getcomposer.org/installer | php -- --install-dir=/usr/local/bin --filename=composer

ARG env_type

ENV ENV_TYPE $env_type
COPY ./src ./
COPY ./src/.env.$env_type ./.env
RUN composer install --prefer-dist --no-dev -o

RUN chmod 777 -R ./storage
# END COMPOSER INSTALL

EXPOSE 9000

CMD /bin/bash -c " \
          cp -f .env.local .env \
          && composer dump-autoload --optimize \
          && php artisan key:generate \
          && php artisan route:cache \
          && php artisan config:cache \
          && php artisan octane:start --server=swoole --host=0.0.0.0 --port=9000 --workers=4 --task-workers=6"

PHP INI

[XDebug]
xdebug.mode=debug
xdebug.start_with_request=trigger
xdebug.discover_client_host=0

[opcache]
opcache.enable=1
; 0 means it will check on every request
; 0 is irrelevant if opcache.validate_timestamps=0 which is desirable in production
opcache.revalidate_freq=0
opcache.validate_timestamps=1
opcache.max_accelerated_files=10000
opcache.memory_consumption=192
opcache.max_wasted_percentage=10
opcache.interned_strings_buffer=16
opcache.fast_shutdown=1
opcache.jit_buffer_size=100M
opcache.jit=1255

Octane Config

<?php

use Laravel\Octane\Contracts\OperationTerminated;
use Laravel\Octane\Events\RequestHandled;
use Laravel\Octane\Events\RequestReceived;
use Laravel\Octane\Events\RequestTerminated;
use Laravel\Octane\Events\TaskReceived;
use Laravel\Octane\Events\TaskTerminated;
use Laravel\Octane\Events\TickReceived;
use Laravel\Octane\Events\TickTerminated;
use Laravel\Octane\Events\WorkerErrorOccurred;
use Laravel\Octane\Events\WorkerStarting;
use Laravel\Octane\Events\WorkerStopping;
use Laravel\Octane\Listeners\CollectGarbage;
use Laravel\Octane\Listeners\DisconnectFromDatabases;
use Laravel\Octane\Listeners\EnsureUploadedFilesAreValid;
use Laravel\Octane\Listeners\EnsureUploadedFilesCanBeMoved;
use Laravel\Octane\Listeners\FlushTemporaryContainerInstances;
use Laravel\Octane\Listeners\FlushUploadedFiles;
use Laravel\Octane\Listeners\ReportException;
use Laravel\Octane\Listeners\StopWorkerIfNecessary;
use Laravel\Octane\Octane;

return [

    /*
    |--------------------------------------------------------------------------
    | Octane Server
    |--------------------------------------------------------------------------
    |
    | This value determines the default "server" that will be used by Octane
    | when starting, restarting, or stopping your server via the CLI. You
    | are free to change this to the supported server of your choosing.
    |
    | Supported: "roadrunner", "swoole"
    |
    */

    'server' => env('OCTANE_SERVER', 'roadrunner'),

    /*
    |--------------------------------------------------------------------------
    | Force HTTPS
    |--------------------------------------------------------------------------
    |
    | When this configuration value is set to "true", Octane will inform the
    | framework that all absolute links must be generated using the HTTPS
    | protocol. Otherwise your links may be generated using plain HTTP.
    |
    */

    'https' => env('OCTANE_HTTPS', false),

    /*
    |--------------------------------------------------------------------------
    | Octane Listeners
    |--------------------------------------------------------------------------
    |
    | All of the event listeners for Octane's events are defined below. These
    | listeners are responsible for resetting your application's state for
    | the next request. You may even add your own listeners to the list.
    |
    */

    'listeners' => [
        WorkerStarting::class => [
            EnsureUploadedFilesAreValid::class,
            EnsureUploadedFilesCanBeMoved::class,
        ],

        RequestReceived::class => [
            ...Octane::prepareApplicationForNextOperation(),
            ...Octane::prepareApplicationForNextRequest(),
            //
        ],

        RequestHandled::class => [
            //
        ],

        RequestTerminated::class => [
            // FlushUploadedFiles::class,
        ],

        TaskReceived::class => [
            ...Octane::prepareApplicationForNextOperation(),
            //
        ],

        TaskTerminated::class => [
            //
        ],

        TickReceived::class => [
            ...Octane::prepareApplicationForNextOperation(),
            //
        ],

        TickTerminated::class => [
            //
        ],

        OperationTerminated::class => [
            FlushTemporaryContainerInstances::class,
            // DisconnectFromDatabases::class,
            // CollectGarbage::class,
        ],

        WorkerErrorOccurred::class => [
            ReportException::class,
            StopWorkerIfNecessary::class,
        ],

        WorkerStopping::class => [
            //
        ],
    ],

    /*
    |--------------------------------------------------------------------------
    | Warm / Flush Bindings
    |--------------------------------------------------------------------------
    |
    | The bindings listed below will either be pre-warmed when a worker boots
    | or they will be flushed before every new request. Flushing a binding
    | will force the container to resolve that binding again when asked.
    |
    */

    'warm' => [
        ...Octane::defaultServicesToWarm(),
    ],

    'flush' => [
        //
    ],

    /*
    |--------------------------------------------------------------------------
    | Octane Cache Table
    |--------------------------------------------------------------------------
    |
    | While using Swoole, you may leverage the Octane cache, which is powered
    | by a Swoole table. You may set the maximum number of rows as well as
    | the number of bytes per row using the configuration options below.
    |
    */

    'cache' => [
        'rows' => env('OCTANE_SERVER_CACHE_ROWS', 10000),
        'bytes' => env('OCTANE_SERVER_CACHE_ROWS_BYTES', 1000000),
    ],

    /*
    |--------------------------------------------------------------------------
    | Octane Swoole Tables
    |--------------------------------------------------------------------------
    |
    | While using Swoole, you may define additional tables as required by the
    | application. These tables can be used to store data that needs to be
    | quickly accessed by other workers on the particular Swoole server.
    |
    */

    'tables' => [
        'example:1000' => [
            'name' => 'string:1000',
            'votes' => 'int',
        ],
    ],

    /*
    |--------------------------------------------------------------------------
    | File Watching
    |--------------------------------------------------------------------------
    |
    | The following list of files and directories will be watched when using
    | the --watch option offered by Octane. If any of the directories and
    | files are changed, Octane will automatically reload your workers.
    |
    */

    'watch' => [
        'app',
        'bootstrap',
        'config',
        'database',
        'public/**/*.php',
        'resources/**/*.php',
        'routes',
        'composer.lock',
        '.env',
    ],

    /*
    |--------------------------------------------------------------------------
    | Garbage Collection Threshold
    |--------------------------------------------------------------------------
    |
    | When executing long-lived PHP scripts such as Octane, memory can build
    | up before being cleared by PHP. You can force Octane to run garbage
    | collection if your application consumes this amount of megabytes.
    |
    */

    'garbage' => 50,

    /*
    |--------------------------------------------------------------------------
    | Maximum Execution Time
    |--------------------------------------------------------------------------
    |
    | The following setting configures the maximum execution time for requests
    | being handled by Octane. You may set this value to 0 to indicate that
    | there isn't a specific time limit on Octane request execution time.
    |
    */

    'max_execution_time' => 30,

];

Values for OCTANE_SERVER_CACHE_ROWS / OCTANE_SERVER_CACHE_ROWS_BYTES / OCTANE_SERVER - 10000 / 1000000 / swoole .

So when I run these 2 applications side by side and I execute a call to endpoint that does the same in both applications the Lumen is much faster than Laravel. The avg response time for Lumen is 737 ms and for Laravel is 1160 ms. The testing endpoints looks like this:

Lumen

public function test()
    {
        for ($i = 0; $i < 100; $i++) {
            $game1 = Game::all();
            $game2 = Game::all();
            $game3 = Game::all();
            $game4 = Game::all();
            $game5 = Game::all();
            $game6 = Game::all();
            $game7 = Game::all();
            $game8 = Game::all();
            $game9 = Game::all();
            $game10 = Game::all();
            $game11 = Game::all();
            $game12 = Game::all();
            $game13 = Game::all();
            $game14 = Game::all();
            $game15 = Game::all();
            $game16 = Game::all();
            $game17 = Game::all();
            $game18 = Game::all();
            $game19 = Game::all();
            $game20 = Game::all();
            $game21 = Game::all();
            $game22 = Game::all();
        }

        return response()->json([
            $game1,
            $game2,
            $game3,
            $game4,
            $game5,
            $game6,
            $game7,
            $game8,
            $game9,
            $game10,
            $game11,
            $game12,
            $game13,
            $game14,
            $game15,
            $game16,
            $game17,
            $game18,
            $game19,
            $game20,
            $game21,
            $game22,
        ]);
    }

Laravel

public function index()
    {
        for ($i = 0; $i < 100; $i++) {
            [
                $game1,
                $game2,
                $game3,
                $game4,
                $game5,
                $game6,
                $game7,
                $game8,
                $game9,
                $game10,
                $game11,
                $game12,
                $game13,
                $game14,
                $game15,
                $game16,
                $game17,
                $game18,
                $game19,
                $game20,
                $game21,
                $game22,
            ] = Octane::concurrently([
                fn() => Game::all(),
                fn() => Game::all(),
                fn() => Game::all(),
                fn() => Game::all(),
                fn() => Game::all(),
                fn() => Game::all(),
                fn() => Game::all(),
                fn() => Game::all(),
                fn() => Game::all(),
                fn() => Game::all(),
                fn() => Game::all(),
                fn() => Game::all(),
                fn() => Game::all(),
                fn() => Game::all(),
                fn() => Game::all(),
                fn() => Game::all(),
                fn() => Game::all(),
                fn() => Game::all(),
                fn() => Game::all(),
                fn() => Game::all(),
                fn() => Game::all(),
                fn() => Game::all(),
            ]);
        }


        return response()->json([
            $game1,
            $game2,
            $game3,
            $game4,
            $game5,
            $game6,
            $game7,
            $game8,
            $game9,
            $game10,
            $game11,
            $game12,
            $game13,
            $game14,
            $game15,
            $game16,
            $game17,
            $game18,
            $game19,
            $game20,
            $game21,
            $game22,
        ]);
    }

I checked the Postman HTTP response time flow and the problem is definetly on the server side:

Laravel

Lumen

Interesting fact is that when I turn off OPcache ext on both of them, Laravel Octane is much better in performance than Lumen. But why would I turn off OPcache when it is helping me, right? So I have 2 questions:

1. When I am using Swoole does PHP JIT is used?
2. Are there any possible options how I can improve performance of my Laravel Octane app based on Swoole?

Thank you very much for your response.

[Matees]

We have exactly the same problem.

[marcoilic]

We are also looking for a solution to a similar issue

[10peter10]

Hello guys,
thank you Dominik for raising this question, in our company we also deal with this problem without any success, so I am very curious about solution.

[leocavalcante]

Have you tried benchmarking the Octane version without the Nginx? You don't need it anymore.

[dominikhalvonik]

Hi @leocavalcante , thank you for your response and advice but I already done that. The difference between version with and without NginX was around 2-3 ms. So Basically nothing.

[NathanFreeman]

Octane::concurrently is a blocking function, there are two more ipc communications here compare with lumen.