PHP 8: JIT-компиляция и улучшение производительно­сти

// В простейшем случае этот код
function sumArray($arr) {
    $sum = 0;
    foreach ($arr as $value) {
        $sum += $value;
    }
    return $sum;
}
 
// При многократном вызове будет JIT-компилирован в нечто,
// эквивалентное следующему машинному коду (псевдо-ассемблер):
// mov eax, 0         ; $sum = 0
// mov ecx, [arr_ptr] ; указатель на массив
// mov edx, [ecx+size]; размер массива
// xor esi, esi       ; инициализация счётчика
// loop_start:
// cmp esi, edx       ; проверка счётчика
// jge loop_end       ; если достигли конца, выход
// add eax, [ecx+esi*4]; добавление текущего элемента к сумме
// inc esi            ; увеличение счётчика
// jmp loop_start     ; возврат к началу цикла
// loop_end:
// ret                ; возврат результата (в eax)

// Без JIT: каждая итерация цикла интерпретируется отдельно
// С JIT: цикл компилируется в машинный код и выполняется напрямую
 
$startTime = microtime(true);
$sum = 0;
for ($i = 0; $i < 10000000; $i++) {
    $sum += sqrt($i) * sin($i / 1000);
}
echo "Время выполнения: " . (microtime(true) - $startTime) . " секунд\n";

// Пример функции, идеальной для пофункциональной JIT-компиляции
function factorial($n) {
    $result = 1;
    for ($i = 2; $i <= $n; $i++) {
        $result *= $i;
    }
    return $result;
}

// Трассировочный JIT может оптимизировать только часто используемые пути
function calculateDiscount($price, $customerType) {
    if ($customerType === 'premium') { // Если этот путь используется часто
        return $price * 0.8; // Он будет скомпилирован
    } elseif ($customerType === 'regular') {
        return $price * 0.95;
    } else {
        return $price;
    }
}

// Пример настройки буфера JIT в php.ini
opcache.jit_buffer_size=100M

// Файл test.php
<?php
opcache_jit_debug();
function test($a, $b) {
    return $a * $b + sin($a);
}
for ($i = 0; $i < 1000; $i++) {
    test(1.0, 2.0);
}

; Включение opcache
zend_extension=opcache
 
; Включение JIT компиляции
opcache.enable=1
opcache.jit=1255
opcache.jit_buffer_size=100M

// Пример скрипта для тестирования разных настроек JIT
<?php
$start = microtime(true);
 
// CPU-интенсивная задача
$result = 0;
for ($i = 0; $i < 10000000; $i++) {
    $result += sin($i * 0.01) * cos($i * 0.01);
}
 
$end = microtime(true);
echo "Результат: $result
Время выполнения: " . ($end - $start) . " секунд
";

// test_bench.php
function fibonacci($n) {
    if ($n <= 1) return $n;
    return fibonacci($n - 1) + fibonacci($n - 2);
}
 
$start = microtime(true);
fibonacci(30);
$end = microtime(true);
 
echo "Время выполнения: " . ($end - $start) . " секунд\n";

// Бенчмарк сортировки
$start = microtime(true);
 
$array = [];
for ($i = 0; $i < 100000; $i++) {
    $array[] = rand(1, 1000000);
}
 
// Реализация быстрой сортировки на PHP
function quicksort($arr) {
    if (count($arr) < 2) {
        return $arr;
    }
    
    $pivot = $arr[0];
    $left = $right = [];
    
    for ($i = 1; $i < count($arr); $i++) {
        if ($arr[$i] < $pivot) {
            $left[] = $arr[$i];
        } else {
            $right[] = $arr[$i];
        }
    }
    
    return array_merge(quicksort($left), [$pivot], quicksort($right));
}
 
$sorted = quicksort($array);
$end = microtime(true);
 
echo "Время сортировки: " . ($end - $start) . " секунд\n";

// Типизированная функция
function sumVector(array $vector): float {
    $sum = 0.0;
    foreach ($vector as $value) {
        $sum += $value;
    }
    return $sum;
}
 
// Нетипизированная функция
function sumVectorDynamic($vector) {
    $sum = 0;
    foreach ($vector as $value) {
        $sum += $value;
    }
    return $sum;
}

// I/O-зависимая задача: чтение из файла
function readLargeFile($filename) {
    $handle = fopen($filename, "r");
    $content = '';
    while (!feof($handle)) {
        $content .= fread($handle, 8192);
    }
    fclose($handle);
    return $content;
}
 
// CPU-интенсивная задача: обработка данных
function processData($data) {
    $result = [];
    for ($i = 0; $i < 10000; $i++) {
        $result[] = sin($i) * cos($i) / (tan($i) + 0.0001);
    }
    return $result;
}

// До оптимизации
function processOrders($orders) {
    $total = 0;
    foreach ($orders as $order) {
        if ($order->status === 'completed') {
            $total += calculateOrderValue($order);
        }
    }
    return $total;
}
 
// После оптимизации с учетом JIT
function processOrders(array $orders): float {
    $total = 0.0;
    foreach ($orders as $order) {
        // Вынесение условия за пределы цикла для создания "горячего пути"
        if ($order->status === 'completed') {
            $completedOrders[] = $order;
        }
    }
    
    // Отдельный цикл без условий - идеальный случай для JIT
    foreach ($completedOrders as $order) {
        $total += calculateOrderValue($order);
    }
    return $total;
}

// Пример с полной типизацией
function complexCalculation(array $data, float $multiplier): array {
    $result = [];
    foreach ($data as $value) {
        $result[] = $value * $multiplier + sin($value);
    }
    return $result;
}
 
// Вызов с типизированными параметрами
$data = array_fill(0, 10000, 1.5);
$result = complexCalculation($data, 2.0);

// Простой скрипт для измерения времени старта
// Запускаем в цикле 100 раз и измеряем среднее время
$total_time = 0;
for ($i = 0; $i < 100; $i++) {
    $start = microtime(true);
    // Запуск PHP с новым скриптом через exec
    exec('php -d opcache.enable=1 -d opcache.jit=1255 test_script.php');
    $total_time += (microtime(true) - $start);
}
echo "Среднее время запуска: " . ($total_time / 100) . " секунд";

// Расчет приближения числа π методом Монте-Карло
function calculatePi(int $iterations): float {
    $inside = 0;
    for ($i = 0; $i < $iterations; $i++) {
        $x = random_int(0, 1000000) / 1000000;
        $y = random_int(0, 1000000) / 1000000;
        if (($x*$x + $y*$y) <= 1) {
            $inside++;
        }
    }
    return 4 * $inside / $iterations;
}
 
$start = microtime(true);
$pi = calculatePi(10000000);
echo "π ≈ " . $pi . "\n";
echo "Время: " . (microtime(true) - $start) . " секунд\n";

// Применение размытия по Гауссу к изображению
function gaussianBlur($image, $sigma) {
    $width = imagesx($image);
    $height = imagesy($image);
    $result = imagecreatetruecolor($width, $height);
    
    $kernelSize = ceil(6 * $sigma);
    if ($kernelSize % 2 == 0) $kernelSize++;
    $halfKernel = floor($kernelSize / 2);
    
    // Построение ядра Гаусса
    $kernel = [];
    $sum = 0;
    for ($x = -$halfKernel; $x <= $halfKernel; $x++) {
        for ($y = -$halfKernel; $y <= $halfKernel; $y++) {
            $exp = exp(-($x*$x + $y*$y) / (2 * $sigma * $sigma));
            $kernel[$x + $halfKernel][$y + $halfKernel] = $exp;
            $sum += $exp;
        }
    }
    
    // Нормализация ядра
    for ($x = 0; $x < $kernelSize; $x++) {
        for ($y = 0; $y < $kernelSize; $y++) {
            $kernel[$x][$y] /= $sum;
        }
    }
    
    // Применение фильтра
    for ($x = 0; $x < $width; $x++) {
        for ($y = 0; $y < $height; $y++) {
            $r = $g = $b = 0;
            
            for ($kx = -$halfKernel; $kx <= $halfKernel; $kx++) {
                for ($ky = -$halfKernel; $ky <= $halfKernel; $ky++) {
                    $pixelX = min(max($x + $kx, 0), $width - 1);
                    $pixelY = min(max($y + $ky, 0), $height - 1);
                    
                    $rgb = imagecolorat($image, $pixelX, $pixelY);
                    $r += (($rgb >> 16) & 0xFF) * $kernel[$kx + $halfKernel][$ky + $halfKernel];
                    $g += (($rgb >> 8) & 0xFF) * $kernel[$kx + $halfKernel][$ky + $halfKernel];
                    $b += ($rgb & 0xFF) * $kernel[$kx + $halfKernel][$ky + $halfKernel];
                }
            }
            
            imagesetpixel($result, $x, $y, imagecolorallocate($result, $r, $g, $b));
        }
    }
    
    return $result;
}

opcache.jit=1205
opcache.jit_buffer_size=32M

opcache.jit=1255
opcache.jit_buffer_size=64M

opcache.jit=1254
opcache.jit_buffer_size=128M

   ; Плохо - излишне большой буфер
   opcache.jit_buffer_size=512M
   
   ; Лучше - более сбалансированный подход
   opcache.jit_buffer_size=64M

   // Плохо - динамическая типизация
   function calculateTotal($prices, $tax) {
       $total = 0;
       foreach ($prices as $price) {
           $total += $price * (1 + $tax);
       }
       return $total;
   }
   
   // Хорошо - статическая типизация
   function calculateTotal(array $prices, float $tax): float {
       $total = 0.0;
       foreach ($prices as $price) {
           $total += $price * (1 + $tax);
       }
       return $total;
   }

   // Плохо - переменная $value меняет тип
   function processData($data) {
       $value = 0;
       foreach ($data as $item) {
           $value = $item->name; // теперь $value — строка
           $value = strlen($value); // теперь $value — целое число
           // ...
       }
   }
   
   // Хорошо - отдельные переменные для разных типов
   function processData($data) {
       $count = 0;
       foreach ($data as $item) {
           $name = $item->name;
           $length = strlen($name);
           $count += $length;
       }
   }

   // Неправильное тестирование
   $start = microtime(true);
   runMyFunction(); // первый запуск с холодным JIT
   echo (microtime(true) - $start); // неверный результат
   
   // Правильное тестирование
   runMyFunction(); // прогрев
   runMyFunction(); // ещё прогрев
   $start = microtime(true);
   runMyFunction(); // теперь измеряем
   echo (microtime(true) - $start); // более точный результат

   // JIT не ускорит этот код значительно
   function fetchAllUserData() {
       $data = [];
       for ($i = 1; $i <= 1000; $i++) {
           $data[] = DB::query("SELECT * FROM users WHERE id = $i");
       }
       return $data;
   }

   // До оптимизации
   function processData($data) {
       $result = 0;
       foreach ($data as $item) {
           if ($item->type === 'special') {
               // сложные вычисления
           } else {
               // простые вычисления
           }
       }
   }
   
   // После оптимизации
   function processSpecial($item) {
       // сложные вычисления
   }
   
   function processRegular($item) {
       // простые вычисления
   }
   
   function processData($data) {
       $specials = [];
       $regulars = [];
       
       // Разделение данных по типам
       foreach ($data as $item) {
           if ($item->type === 'special') {
               $specials[] = $item;
           } else {
               $regulars[] = $item;
           }
       }
       
       // Обработка однотипных данных
       foreach ($specials as $item) {
           processSpecial($item);
       }
       
       foreach ($regulars as $item) {
           processRegular($item);
       }
   }

   // Менее эффективно для JIT
   function Vector3($x, $y, $z) {
       return ['x' => $x, 'y' => $y, 'z' => $z];
   }
   
   function addVectors($v1, $v2) {
       return Vector3(
           $v1['x'] + $v2['x'],
           $v1['y'] + $v2['y'],
           $v1['z'] + $v2['z']
       );
   }
   
   // Более эффективно для JIT
   function addVectorComponents(float $x1, float $y1, float $z1, float $x2, float $y2, float $z2): array {
       return [
           $x1 + $x2,
           $y1 + $y2,
           $z1 + $z2
       ];
   }

   // Плохо для JIT
   function dynamicCall($object, $methodName, $param) {
       return $object->$methodName($param);
   }
   
   // Лучше для JIT
   function specificCall(UserProcessor $processor, int $userId): User {
       return $processor->process($userId);
   }

   // Сложнее для JIT
   function calculatePrice($product, $user) {
       $price = $product->basePrice;
       
       if ($user->isVip) {
           $price *= 0.9;
       } elseif ($user->loyaltyPoints > 1000) {
           $price *= 0.95;
       } elseif ($product->isOnSale) {
           $price *= 0.8;
       } else {
           $price *= 1.0;
       }
       
       return $price;
   }
   
   // Проще для JIT
   function calculateVipDiscount($price) {
       return $price * 0.9;
   }
   
   function calculateLoyaltyDiscount($price) {
       return $price * 0.95;
   }
   
   function calculateSaleDiscount($price) {
       return $price * 0.8;
   }
   
   function calculatePrice($product, $user) {
       $price = $product->basePrice;
       
       if ($user->isVip) {
           return calculateVipDiscount($price);
       }
       
       if ($user->loyaltyPoints > 1000) {
           return calculateLoyaltyDiscount($price);
       }
       
       if ($product->isOnSale) {
           return calculateSaleDiscount($price);
       }
       
       return $price;
   }

   // Неявные преобразования типов - плохо для JIT
   function sumValues($a, $b) {
       return $a + $b; // $a и $b могут быть разных типов
   }
   
   // Явные преобразования и типы - лучше для JIT
   function sumIntegers(int $a, int $b): int {
       return $a + $b;
   }
   
   function sumFloats(float $a, float $b): float {
       return $a + $b;
   }

// Включаем профилирование в php.ini или через ini_set
ini_set('xdebug.profiler_enable', 1);
ini_set('xdebug.profiler_output_dir', '/tmp');
 
// Запускаем код, который хотим проанализировать
yourFunction();
 
// Анализируем результаты с помощью KCacheGrind или другой программы

// Классический пример: быстрое возведение в степень
function powerOptimized(float $base, int $exponent): float {
    if ($exponent === 0) return 1.0;
    if ($exponent < 0) return 1.0 / powerOptimized($base, -$exponent);
    
    if ($exponent % 2 === 0) {
        $half = powerOptimized($base, $exponent / 2);
        return $half * $half;
    } else {
        return $base * powerOptimized($base, $exponent - 1);
    }
}

function benchmarkFunction(callable $func, array $params, int $iterations) {
    // Прогрев для JIT
    for ($i = 0; $i < 5; $i++) {
        call_user_func_array($func, $params);
    }
    
    $start = microtime(true);
    for ($i = 0; $i < $iterations; $i++) {
        call_user_func_array($func, $params);
    }
    $end = microtime(true);
    
    return [
        'time' => $end - $start,
        'avg' => ($end - $start) / $iterations
    ];
}
 
// Пример использования
$result = benchmarkFunction('powerOptimized', [2.0, 10], 1000000);
echo "Среднее время выполнения: {$result['avg']} мс
";

// Использование union types
function process(int|float $value): int|float {
    if (is_int($value)) {
        return $value * 2;
    } else {
        return $value * 2.5;
    }
}

// Пример атрибута для оптимизации JIT (гипотетический пример)
#[JITOptimize(level: 'aggressive')]
function criticalFunction(array $data): array {
    // Код, требующий максимальной производительности
}

// Пример использования Fiber с интенсивными вычислениями
$fiber = new Fiber(function() {
    // CPU-интенсивные вычисления, оптимизируемые JIT
    $result = 0;
    for ($i = 0; $i < 10000000; $i++) {
        $result += sin($i * 0.01);
        if ($i % 1000000 === 0) {
            Fiber::suspend($i / 10000000 * 100 . '% completed');
        }
    }
    return $result;
});
 
// Запуск Fiber
echo $fiber->start() . "
";
 
// Продолжение выполнения
while (!$fiber->isTerminated()) {
    echo $fiber->resume() . "
";
}
 
echo "Результат: " . $fiber->getReturn() . "
";

// Использование расширения вместо PHP-кода
$result = custom_extension_function($data);
 
// Эквивалентный PHP-код
function phpImplementation($data) {
    // Медленная версия на PHP
}

// Используем кэш для избежания повторных вычислений
function expensiveCalculation($param) {
    static $cache = [];
    $key = md5(serialize($param));
    
    if (!isset($cache[$key])) {
        // Вычисляем и кэшируем результат
        $cache[$key] = actualCalculation($param);
    }
    
    return $cache[$key];
}

// Вместо выполнения тяжёлой задачи в запросе
function handleRequest() {
    // Добавляем задачу в очередь
    Queue::add([
        'task' => 'heavyComputation',
        'params' => $params
    ]);
    
    return "Задача поставлена в очередь";
}
 
// Отдельный воркер обрабатывает задачи из очереди
function workerProcess() {
    while ($task = Queue::getNext()) {
        // Выполняем задачу с преимуществами JIT
        processTask($task);
    }
}