PHP 8 va proposer un compilateur Just In Time

Qui devrait produire une amélioration des performances en vitesse

PHP 8 va proposer un compilateur Just In Time
Qui devrait produire une amélioration des performances en vitesse

La nouvelle est tombée il y a peu par le biais d’un billet de blog d’un membre de la communauté du langage de programmation web côté serveur le plus utilisé au monde d’après les chiffres de la plateforme W3Techs – PHP.

À moins que vous n'ayez vécu sous un rocher ou que vous ne veniez du passé (auquel cas, bienvenue), vous devez savoir que PHP 8 arrive avec un compilateur JIT : le vote s'est terminé aujourd'hui, dans le calme, avec une large majorité en faveur de la fusion avec PHP 8, donc, c'est officiel.

Les détails techniques de ce changement au sein de la proposition par Dmitry Stogov et Zeev Suraski :

« Nous proposons d'inclure un compilateur JIT à PHP 8 et de fournir des efforts supplémentaires pour augmenter ses performances et sa convivialité. En outre, nous proposons d'envisager l'inclusion d'un compilateur JIT dans PHP 7.4 en tant que fonctionnalité expérimentale (désactivée par défaut).

PHP JIT est implémenté comme une partie d'OPcache. Il peut être activé ou désactivé au moment de la compilation et au moment de l'exécution. Lorsqu'il est activé, le code natif des fichiers PHP est stocké dans une région supplémentaire de la mémoire partagée OPcache et op_array→opcodes[].handler(s) conserve des pointeurs vers les points d'entrée du code généré par le compilateur JIT. Cette approche ne nécessite aucune modification du moteur.

Nous utilisons DynAsm (développé pour le projet LuaJIT) pour la génération de code natif. C'est un outil très léger et très avancé, mais il suppose une bonne et très faible connaissance du développement des langages assembleur cibles. Par le passé, nous avons essayé LLVM, mais sa vitesse de génération de code était presque 100 fois plus lente, ce qui le rendait prohibitif à utiliser. Actuellement, nous supportons les processeurs x86 et x86_64 sur les plateformes POSIX et Windows. DynAsm supporte également ARM, ARM64, MIPS, MIPS64 et PPC, donc en théorie, nous devrions être capables de supporter toutes les plateformes qui sont populaires pour les déploiements PHP.

PHP JIT n'introduit pas représentation intermédiaire. Il génère du code natif directement à partir du bytecode PHP et des informations collectées par le framework d'analyses statiques SSA. Grosso modo, le code est généré de façon séparée pour chaque instruction PHP. Seules quelques combinaisons sont prises en compte ensemble (par exemple : les comparaisons et les sauts conditionnels). »

Illustration du passage du PHP au code natif pour un processeur x86 avec les deux portions de code suivantes :

function iterate($x,$y)
{
$cr = $y-0.5;
$ci = $x;
$zr = 0.0;
$zi = 0.0;
$i = 0;
while (true) {
$i++;
$temp = $zr * $zi;
$zr2 = $zr * $zr;
$zi2 = $zi * $zi;
$zr = $zr2 - $zi2 + $cr;
$zi = $temp + $temp + $ci;
if ($zi2 + $zr2 > BAILOUT)
return $i;
if ($i > MAX_ITERATIONS)
return 0;
}

}

JIT$Mandelbrot::iterate: ; (/home/dmitry/php/bench/b.php)
sub $0x10, %esp
cmp $0x1, 0x1c(%esi)
jb .L14
jmp .L1
.ENTRY1:
sub $0x10, %esp
.L1:
cmp $0x2, 0x1c(%esi)
jb .L15
mov $0xec3800f0, %edi
jmp .L2
.ENTRY2:
sub $0x10, %esp
.L2:
cmp $0x5, 0x48(%esi)
jnz .L16
vmovsd 0x40(%esi), %xmm1
vsubsd 0xec380068, %xmm1, %xmm1
.L3:
mov 0x30(%esi), %eax
mov 0x34(%esi), %edx
mov %eax, 0x60(%esi)
mov %edx, 0x64(%esi)
mov 0x38(%esi), %edx
mov %edx, 0x68(%esi)
test $0x1, %dh
jz .L4
add $0x1, (%eax)
.L4:
vxorps %xmm2, %xmm2, %xmm2
vxorps %xmm3, %xmm3, %xmm3
xor %edx, %edx
.L5:
cmp $0x0, EG(vm_interrupt)
jnz .L18
add $0x1, %edx
vmulsd %xmm3, %xmm2, %xmm4
vmulsd %xmm2, %xmm2, %xmm5
vmulsd %xmm3, %xmm3, %xmm6
vsubsd %xmm6, %xmm5, %xmm7
vaddsd %xmm7, %xmm1, %xmm2
vaddsd %xmm4, %xmm4, %xmm4
cmp $0x5, 0x68(%esi)
jnz .L19
vaddsd 0x60(%esi), %xmm4, %xmm3
.L6:
vaddsd %xmm5, %xmm6, %xmm6
vucomisd 0xec3800a8, %xmm6
jp .L13
jbe .L13
mov 0x8(%esi), %ecx
test %ecx, %ecx
jz .L7
mov %edx, (%ecx)
mov $0x4, 0x8(%ecx)
.L7:
test $0x1, 0x39(%esi)
jnz .L21
.L8:
test $0x1, 0x49(%esi)
jnz .L23
.L9:
test $0x1, 0x69(%esi)
jnz .L25
.L10:
movzx 0x1a(%esi), %ecx
test $0x496, %ecx
jnz JIT$$leave_function
mov 0x20(%esi), %eax
mov %eax, EG(current_execute_data)
test $0x40, %ecx
jz .L12
mov 0x10(%esi), %eax
sub $0x1, (%eax)
jnz .L11
mov %eax, %ecx
call zend_objects_store_del
jmp .L12
.L11:
mov 0x4(%eax), %ecx
and $0xfffffc10, %ecx
cmp $0x10, %ecx
jnz .L12
mov %eax, %ecx
call gc_possible_root
.L12:
mov %esi, EG(vm_stack_top)
mov 0x20(%esi), %esi
cmp $0x0, EG(exception)
mov (%esi), %edi
jnz JIT$$leave_throw
add $0x1c, %edi
add $0x10, %esp
jmp (%edi)
.L13:
cmp $0x3e8, %edx
jle .L5
mov 0x8(%esi), %ecx
test %ecx, %ecx
jz .L7
mov $0x0, (%ecx)
mov $0x4, 0x8(%ecx)
jmp .L7
.L14:
mov %edi, (%esi)
mov %esi, %ecx
call zend_missing_arg_error
jmp JIT$$exception_handler
.L15:
mov %edi, (%esi)
mov %esi, %ecx
call zend_missing_arg_error
jmp JIT$$exception_handler
.L16:
cmp $0x4, 0x48(%esi)
jnz .L17
vcvtsi2sd 0x40(%esi), %xmm1, %xmm1
vsubsd 0xec380068, %xmm1, %xmm1
jmp .L3
.L17:
mov %edi, (%esi)
lea 0x50(%esi), %ecx
lea 0x40(%esi), %edx
sub $0xc, %esp
push $0xec380068
call sub_function
add $0xc, %esp
cmp $0x0, EG(exception)
jnz JIT$$exception_handler
vmovsd 0x50(%esi), %xmm1
jmp .L3
.L18:
mov $0xec38017c, %edi
jmp JIT$$interrupt_handler
.L19:
cmp $0x4, 0x68(%esi)
jnz .L20
vcvtsi2sd 0x60(%esi), %xmm3, %xmm3
vaddsd %xmm4, %xmm3, %xmm3
jmp .L6
.L20:
mov $0xec380240, (%esi)
lea 0x80(%esi), %ecx
vmovsd %xmm4, 0xe0(%esi)
mov $0x5, 0xe8(%esi)
lea 0xe0(%esi), %edx
sub $0xc, %esp
lea 0x60(%esi), %eax
push %eax
call add_function
add $0xc, %esp
cmp $0x0, EG(exception)
jnz JIT$$exception_handler
vmovsd 0x80(%esi), %xmm3
jmp .L6
.L21:
mov 0x30(%esi), %ecx
sub $0x1, (%ecx)
jnz .L22
mov $0x1, 0x38(%esi)
mov $0xec3802b0, (%esi)
call rc_dtor_func
jmp .L8
.L22:
mov 0x4(%ecx), %eax
and $0xfffffc10, %eax
cmp $0x10, %eax
jnz .L8
call gc_possible_root
jmp .L8
.L23:
mov 0x40(%esi), %ecx
sub $0x1, (%ecx)
jnz .L24
mov $0x1, 0x48(%esi)
mov $0xec3802b0, (%esi)
call rc_dtor_func
jmp .L9
.L24:
mov 0x4(%ecx), %eax
and $0xfffffc10, %eax
cmp $0x10, %eax
jnz .L9
call gc_possible_root
jmp .L9
.L25:
mov 0x60(%esi), %ecx
sub $0x1, (%ecx)
jnz .L26
mov $0x1, 0x68(%esi)
mov $0xec3802b0, (%esi)
call rc_dtor_func
jmp .L10
.L26:
mov 0x4(%ecx), %eax
and $0xfffffc10, %eax
cmp $0x10, %eax
jnz .L10
call gc_possible_root
jmp .L10
L’introduction d’un compilateur JIT devrait permettre une accélération significative des tâches ultra gourmandes en ressource processeur. L’équipe de mainteneurs annonce des gains de performance de 2x quant à ce qui est de l’exécution de l’interpréteur PHP ; les utilisateurs devraient également constater une accélération de 1,3x de l’exécution de l’analyseur de texte du langage. L’équipe de mainteneur a également publié les résultats d’un benchmark qui montrent que PHP (avec le compilateur JIT activé) peut mieux faire que des langages comme le C sur le terrain de la génération des fractales de Mandelbrot.

462907

Noter à ce propos que ces changements n’auront pas d’apport important sur les performances d’applications qui, pour l’essentiel de leurs opérations, génèrent des entrées-sorties sur divers ports : Wordpress, etc. Dit autrement, il ne faudra pas s’attendre à une accélération significative des sites web.

PHP 7.3 est disponible depuis la fin d’année dernière. PHP 7.4 pour sa part est attendu à la fin de l’année en cours et il faut souligner à ce propos que les votants ont décidé de la non inclusion du compilateur JIT. Il faudra attendre fin 2020 qui coïncide en principe avec la sortie de PHP 8 pour en faire usage.

Sources : billet de blog, résultats du benchmark

Et vous ?

:fleche: Qu’en pensez-vous ?

:fleche: Quel commentaire faites-vous de ceci que l’équipe de développement de PHP n’a pas choisi sa propre représentation intermédiaire ? Quelles conséquences sur le plan technique ?

Voir aussi :

:fleche: Les benchmarks réalisés sur la dernière préversion de PHP 7.3 sont prometteurs, et la sortie de la version stable se profile à l'horizon
:fleche: W3Techs : plus de 60 % des sites Web tournent sur PHP 5.x, une version qui ne sera plus supportée après le 31 décembre 2018
:fleche: PHP 7.2 est disponible en version stable avec la bibliothèque de cryptographie Sodium, et d'autres améliorations et nouvelles fonctionnalités
:fleche: PHP 7.1.0 disponible avec le support des types nullables et de nombreuses autres fonctionnalités, mais aussi des gains de performance
:fleche: PHP 7.0.0 officiellement disponible, et son code source téléchargeable sur le site officiel du langage de programmation