Performance e velocidade no PHP7, vale apena migrar?

Muitos programadores tem se perguntado nos últimos anos sobre a migração para as versões mais recentes do PHP, a versão PHP7 já está em suas versão estável e com resultados positivos com relação ao seu antecessor 5.X. Nesse artigo vamos abordar alguns resultados comparativos entre as duas versões e você poderá tirar suas próprias conclusões.

O que você precisa saber antes de pensar em migrar

Você precisa entender a sua necessidade, não vale à pena, por exemplo, migrar um sistema inteiro se você não entende as vantagens e se valerá todo o trabalho. Fizemos um teste comparativo oferecido pelo próprio php e você pode ver quais as vantagens com o processamento das funções que você vai usar. São funções básicas, mas que já mostram comparativos de desempenho entre as versões 5 e 7, você pode inclusive criar suas próprias verificações e tornar o comparativo ainda mais direcionado para o seu projeto.

Usaremos o arquivo bench.php que está disponível no repositório oficial do php no GitHub.

0)) {
        $im=$re*$im*2+$imc;
        $re=$re2-$im2+$rec;
        $re2=$re*$re;
        $im2=$im*$im;
        $color=$color-1;
      }
      if ( $color==0 ) {
        print "_";
      } else {
        print "#";
      }
    }
    print "
";
    flush();
  }
}

/****/

function mandel2() {
  $b = " .:,;!/>)|&IH%*#";
  //float r, i, z, Z, t, c, C;
  for ($y=30; printf("\n"), $C = $y*0.1 - 1.5, $y--;){
    for ($x=0; $c = $x*0.04 - 2, $z=0, $Z=0, $x++ < 75;){
      for ($r=$c, $i=$C, $k=0; $t = $z*$z - $Z*$Z + $r, $Z = 2*$z*$Z + $i, $z=$t, $k<5000; $k++) if ($z*$z + $Z*$Z>500000) break;
      echo $b[$k%16];
    }
  }
}

/****/

function Ack($m, $n){
  if($m == 0) return $n+1;
  if($n == 0) return Ack($m-1, 1);
  return Ack($m - 1, Ack($m, ($n - 1)));
}

function ackermann($n) {
  $r = Ack(3,$n);
  print "Ack(3,$n): $r\n";
}

/****/

function ary($n) {
  for ($i=0; $i<$n; $i++) { $X[$i]=  $i; } for ($i=$n-1; $i>=0; $i--) {
    $Y[$i] = $X[$i];
  }
  $last = $n-1;
  print "$Y[$last]\n";
}

/****/

function ary2($n) {
  for ($i=0; $i<$n;) { $X[$i]=  $i; ++$i; $X[$i]=  $i; ++$i; $X[$i]=  $i; ++$i; $X[$i]=  $i; ++$i; $X[$i]=  $i; ++$i; $X[$i]=  $i; ++$i; $X[$i]=  $i; ++$i; $X[$i]=  $i; ++$i; $X[$i]=  $i; ++$i; $X[$i]=  $i; ++$i; } for ($i=$n-1; $i>=0;) {
    $Y[$i] = $X[$i]; --$i;
    $Y[$i] = $X[$i]; --$i;
    $Y[$i] = $X[$i]; --$i;
    $Y[$i] = $X[$i]; --$i;
    $Y[$i] = $X[$i]; --$i;

    $Y[$i] = $X[$i]; --$i;
    $Y[$i] = $X[$i]; --$i;
    $Y[$i] = $X[$i]; --$i;
    $Y[$i] = $X[$i]; --$i;
    $Y[$i] = $X[$i]; --$i;
  }
  $last = $n-1;
  print "$Y[$last]\n";
}

/****/

function ary3($n) {
  for ($i=0; $i<$n; $i++) {
    $X[$i] = $i + 1;
    $Y[$i] = 0;
  }
  for ($k=0; $k<1000; $k++) { for ($i=$n-1; $i>=0; $i--) {
      $Y[$i] += $X[$i];
    }
  }
  $last = $n-1;
  print "$Y[0] $Y[$last]\n";
}

/****/

function fibo_r($n){
    return(($n < 2) ? 1 : fibo_r($n - 2) + fibo_r($n - 1));
}

function fibo($n) {
  $r = fibo_r($n);
  print "$r\n";
}

/****/

function hash1($n) {
  for ($i = 1; $i <= $n; $i++) { $X[dechex($i)]=  $i; } $c=  0; for ($i=  $n; $i>0; $i--) {
    if ($X[dechex($i)]) { $c++; }
  }
  print "$c\n";
}

/****/

function hash2($n) {
  for ($i = 0; $i < $n; $i++) {
    $hash1["foo_$i"] = $i;
    $hash2["foo_$i"] = 0;
  }
  for ($i = $n; $i >0; $i--) {
    foreach($hash1 as $key => $value) $hash2[$key] += $value;
  }
  $first = "foo_0";
  $last  = "foo_".($n-1);
  print "$hash1[$first] $hash1[$last] $hash2[$first] $hash2[$last]\n";
}

/****/

function gen_random ($n) {
    global $LAST;
    return( ($n * ($LAST = ($LAST * IA + IC) % IM)) / IM );
}

function heapsort_r($n, &$ra) {
    $l = ($n >> 1) + 1;
    $ir = $n;

    while (1) {
  if ($l > 1) {
      $rra = $ra[--$l];
  } else {
      $rra = $ra[$ir];
      $ra[$ir] = $ra[1];
      if (--$ir == 1) {
    $ra[1] = $rra;
    return;
      }
  }
  $i = $l;
  $j = $l << 1;
  while ($j <= $ir) {
      if (($j < $ir) && ($ra[$j] < $ra[$j+1])) {
    $j++;
      }
      if ($rra < $ra[$j]) {
    $ra[$i] = $ra[$j];
    $j += ($i = $j);
      } else {
    $j = $ir + 1;
      }
  }
  $ra[$i] = $rra;
    }
}

function heapsort($N) {
  global $LAST;

  define("IM", 139968);
  define("IA", 3877);
  define("IC", 29573);

  $LAST = 42;
  for ($i=1; $i<=$N; $i++) {
    $ary[$i] = gen_random(1);
  }
  heapsort_r($N, $ary);
  printf("%.10f\n", $ary[$N]);
}

/****/

function mkmatrix ($rows, $cols) {
    $count = 1;
    $mx = array();
    for ($i=0; $i<$rows; $i++) {
  for ($j=0; $j<$cols; $j++) {
      $mx[$i][$j] = $count++;
  }
    }
    return($mx);
}

function mmult ($rows, $cols, $m1, $m2) {
    $m3 = array();
    for ($i=0; $i<$rows; $i++) {
  for ($j=0; $j<$cols; $j++) {
      $x = 0;
      for ($k=0; $k<$cols; $k++) {
    $x += $m1[$i][$k] * $m2[$k][$j];
      }
      $m3[$i][$j] = $x;
  }
    }
    return($m3);
}

function matrix($n) {
  $SIZE = 30;
  $m1 = mkmatrix($SIZE, $SIZE);
  $m2 = mkmatrix($SIZE, $SIZE);
  while ($n--) {
    $mm = mmult($SIZE, $SIZE, $m1, $m2);
  }
  print "{$mm[0][0]} {$mm[2][3]} {$mm[3][2]} {$mm[4][4]}\n";
}

/****/

function nestedloop($n) {
  $x = 0;
  for ($a=0; $a<$n; $a++)
    for ($b=0; $b<$n; $b++)
      for ($c=0; $c<$n; $c++)
        for ($d=0; $d<$n; $d++)
          for ($e=0; $e<$n; $e++)
            for ($f=0; $f<$n; $f++) $x++; print "$x\n"; } /****/ function sieve($n) { $count=  0; while ($n--> 0) {
    $count = 0;
    $flags = range (0,8192);
    for ($i=2; $i<8193; $i++) { if ($flags[$i]>0) {
        for ($k=$i+$i; $k <= 8192; $k+=$i) { $flags[$k]=  0; } $count++; } } } print "Count: $count\n"; } /****/ function strcat($n) { $str=  ""; while ($n--> 0) {
    $str .= "hello\n";
  }
  $len = strlen($str);
  print "$len\n";
}

/*****/

function getmicrotime()
{
  $t = gettimeofday();
  return ($t['sec'] + $t['usec'] / 1000000);
}

function start_test()
{
  ob_start();
  return getmicrotime();
}

function end_test($start, $name)
{
  global $total;
  $end = getmicrotime();
  ob_end_clean();
  $total += $end-$start;
  $num = number_format($end-$start,3);
  $pad = str_repeat(" ", 24-strlen($name)-strlen($num));

  echo $name.$pad.$num."\n";
  ob_start();
  return getmicrotime();
}

function total()
{
  global $total;
  $pad = str_repeat("-", 24);
  echo $pad."\n";
  $num = number_format($total,3);
  $pad = str_repeat(" ", 24-strlen("Total")-strlen($num));
  echo "Total".$pad.$num."\n";
}

$t0 = $t = start_test();
simple();
$t = end_test($t, "simple");
simplecall();
$t = end_test($t, "simplecall");
simpleucall();
$t = end_test($t, "simpleucall");
simpleudcall();
$t = end_test($t, "simpleudcall");
mandel();
$t = end_test($t, "mandel");
mandel2();
$t = end_test($t, "mandel2");
ackermann(7);
$t = end_test($t, "ackermann(7)");
ary(50000);
$t = end_test($t, "ary(50000)");
ary2(50000);
$t = end_test($t, "ary2(50000)");
ary3(2000);
$t = end_test($t, "ary3(2000)");
fibo(30);
$t = end_test($t, "fibo(30)");
hash1(50000);
$t = end_test($t, "hash1(50000)");
hash2(500);
$t = end_test($t, "hash2(500)");
heapsort(20000);
$t = end_test($t, "heapsort(20000)");
matrix(20);
$t = end_test($t, "matrix(20)");
nestedloop(12);
$t = end_test($t, "nestedloop(12)");
sieve(30);
$t = end_test($t, "sieve(30)");
strcat(200000);
$t = end_test($t, "strcat(200000)");
total($t0, "Total");
?>

Lembre-se de que os resultados vão variar conforme a máquina que você está usando, preferencialmente use configurações semelhantes ao seu servidor, nossos servidores Cloud Gerenciado tem um excelente desempenho.

Para que os testes sejam mais precisos é interessante executar o script algumas vezes e criar uma media dos resultados, isso vale para as duas versões, então teremos algo como o resultado abaixo:

php Zend/bench.php (php7)

simple             0.124

simplecall         0.024

simpleucall        0.148

simpleudcall       0.156

mandel             0.413

mandel2            0.414

ackermann(7)       0.104

ary(50000)         0.011

ary2(50000)        0.009

ary3(2000)         0.158

fibo(30)           0.388

hash1(50000)       0.029

hash2(500)         0.026

heapsort(20000)    0.081

matrix(20)         0.088

nestedloop(12)     0.214

sieve(30)          0.050

strcat(200000)     0.016

------------------------

Total              2.453s

Como podemos ver a nova versão do PHP executa todas as ações em pouco mais de 2 segundos, o que é um ótimo tempo se comparado a versão 5.6 que em média levou 11 segundos para as mesmas tarefas.

Como os frameworks se comportam com a nova versão?

Com os scripts simples já vimos que podem ter um ganho muito superior, mas a versão 7 não se limita a isso, podemos ter grandes ganhos também com frameworks como o Zend, Laravel, Symphony, entre outros. Os gerenciadores de conteúdo não ficam de fora, Wordpress, Drupal, plataformas como Magento e Opencart também se mostraram com um ganho de requisições muito superior, consumindo muito menos recursos de processamento e memória.

Ganho de performance e velocidade no desenvolvimento

Ao passar do tempo os programadores precisam entregar cada vez mais features no menor tempo possível, além de tudo ter que funcionar rápido economizar tempo de desenvolvimento é essencial para priorizar os testes e correções durante o processo de implementação, as novas funções e características da versão 7 traz melhorias no tratamento de erros, novos operadores, retirada de funções e inclusão de outras, tudo isso priorizando o código limpo e funcional, evitando ao máximo o desperdício de código e de tempo.

Conclusão

Depois de alguns testes você pode concluir que a versão 7 do PHP trouxe muitas melhorias, ganhos de performance, velocidade no desenvolvimento e outras funções. É claro que para migrar um projeto inteiro você precisa analisar a real necessidade, o impacto que esse processo pode causar os benefícios, os custos, etc. Para quem vai começar um novo trabalho é claro que já iniciar com a versão mais recente vai ser menos trabalhos e a adaptação as novas features será bem rápida.

Gostou de nosso post? Compartilhe:

• Facebook
• Twitter
• Linkedin
• WhatsApp