msgbartop
PHP语言, PHP扩展, Zend引擎相关的研究,技术,新闻分享 – 左手代码 右手诗
msgbarbottom

15 Oct 09 提升PHP性能之改变Zend引擎分发方式

从PHP5.1开始,PHP提供了用户对Zend VM执行分发方式的选择接口.

之前的文章中, 我也提过这方面的内容, Zend虚拟机在执行的时候, 对于编译生成的op_array中的每一条opline的opcode都会分发到相应的处理器(zend_vm_def.h定义)执行, 而按照分发的方式不同, 分发过程可以分为CALL, SWITCH, 和GOTO三种类型.

默认是CALL方式, 也就是所有的opcode处理器都定义为函数, 然后虚拟机调用. 这种方式是传统的方式, 也一般被认为是最稳定的方式.

SWITCH方式和GOTO方式则和其命名的意义相同, 分别通过switch和goto来分发opcode到对应的处理逻辑(段).

官方给出的描述是:


CALL – Uses function handlers for opcodes
SWITCH – Uses switch() statement for opcode dispatch
GOTO – Uses goto for opcode dispatch (threaded opcodes architecture)
GOTO is usually (depends on CPU and compiler) faster than SWITCH, which
tends to be slightly faster than CALL.
CALL is default because it doesn’t take very long to compile as opposed
to the other two and in general the speed is quite close to the others.

那么如果使用GOTO方式, 效率上到底能提高多少呢?

今天我就分别使用各种方式来测试一番, 测试脚本bench.php.

第一点被证明的就是, 官方说的GOTO方式编译耗时显著高于其他俩种方式, 我一开始在虚拟机上编译, 每次都Hangup(囧), 最后只好换了个强劲点的物理机, 大约3分钟后, 编译成功..

测试环境:

PHP 5.3.0   Linux
AMD Opteron(tm) Processor 270(2G) X 4  6G Memory

编译参数:

./configure --with-zend-vm=CALL/GOTO/SWITCH

测试结果如下(都是三次取中值):

CALL方式:

laruence@dev01.tc$ sapi/cli/php bench.php
simple             0.358
simplecall         0.418
simpleucall        0.405
simpleudcall       0.424
mandel             1.011
mandel2            1.238
ackermann(7)       0.375
ary(50000)         0.083
ary2(50000)        0.075
ary3(2000)         0.561
fibo(30)           1.156
hash1(50000)       0.114
hash2(500)         0.091
heapsort(20000)    0.270
matrix(20)         0.276
nestedloop(12)     0.599
sieve(30)          0.350
strcat(200000)     0.039
------------------------
Total              7.844

SWITCH方式:

laruence@dev01.tc$ sapi/cli/php bench.php
simple             0.393
simplecall         0.414
simpleucall        0.424
simpleudcall       0.445
mandel             1.007
mandel2            1.254
ackermann(7)       0.392
ary(50000)         0.084
ary2(50000)        0.073
ary3(2000)         0.593
fibo(30)           1.185
hash1(50000)       0.120
hash2(500)         0.092
heapsort(20000)    0.285
matrix(20)         0.295
nestedloop(12)     0.678
sieve(30)          0.359
strcat(200000)     0.042
------------------------
Total              8.138

GOTO方式 :

laruence@dev01.tc$ sapi/cli/php bench.php
simple             0.306
simplecall         0.373
simpleucall        0.369
simpleudcall       0.385
mandel             0.879
mandel2            1.132
ackermann(7)       0.356
ary(50000)         0.081
ary2(50000)        0.073
ary3(2000)         0.525
fibo(30)           1.043
hash1(50000)       0.111
hash2(500)         0.088
heapsort(20000)    0.247
matrix(20)         0.247
nestedloop(12)     0.519
sieve(30)          0.331
strcat(200000)     0.037
------------------------
Total              7.103

可见, GOTO方式最快, SWITCH方式最慢.和官方的描述稍有不符.

GOTO方式比其默认的CALL方式, 性能提升还是比较明显的.

所以, 如果你希望让PHP发挥到机制, 改变Zend VM的分发方式, 也可以做为一个考虑因素.

附:

使用GOTO方式的configure选项:

--with-zend-vm=GOTO

也可以在Zend目录下使用:

php zend_vm_gen.php --with-vm-kind=[CALL|GOTO|SWITH]

测试脚本bench.php

<?php
/**
 * PHP Perf Bench Test Script
 */
function simple() {
  $a = 0;
  for ($i = 0; $i < 1000000; $i++)
    $a++;

  $thisisanotherlongname = 0;
  for ($thisisalongname = 0; $thisisalongname < 1000000; $thisisalongname++)
    $thisisanotherlongname++;
}

/****/

function simplecall() {
  for ($i = 0; $i < 1000000; $i++)
    strlen("hallo");
}

/****/

function hallo($a) {
}

function simpleucall() {
  for ($i = 0; $i < 1000000; $i++)
    hallo("hallo");
}

/****/

function simpleudcall() {
  for ($i = 0; $i < 1000000; $i++)
    hallo2("hallo");
}

function hallo2($a) {
}

/****/

function mandel() {
  $w1=50;
  $h1=150;
  $recen=-.45;
  $imcen=0.0;
  $r=0.7;
  $s=0;  $rec=0;  $imc=0;  $re=0;  $im=0;  $re2=0;  $im2=0;
  $x=0;  $y=0;  $w2=0;  $h2=0;  $color=0;
  $s=2*$r/$w1;
  $w2=40;
  $h2=12;
  for ($y=0 ; $y<=$w1; $y=$y+1) {
    $imc=$s*($y-$h2)+$imcen;
    for ($x=0 ; $x<=$h1; $x=$x+1) {
      $rec=$s*($x-$w2)+$recen;
      $re=$rec;
      $im=$imc;
      $color=1000;
      $re2=$re*$re;
      $im2=$im*$im;
      while( ((($re2+$im2)<1000000) && $color>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 "<br>";
    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");
?>


分享到:



Related Posts:

Tags: , , , , ,

11 Responses to “提升PHP性能之改变Zend引擎分发方式”

  1. 郭新华1989 |

    我知道汇编级别,如果用goto编译的时候需要在每个函数加标号,来实现call方式的返回函数,goto方式编译慢应该就是因为这个吧,call的话来回调得入栈出栈,所以就不如goto快了,这事我对汇编的理解,不知道php是不是同理的

  2. 提升PHP性能之改变Zend引擎分发方式 | 万维网黑客联盟 |

    [...] 本文地址: http://www.laruence.com/2009/10/15/1131.html [...]

  3. liruqi |

    建议做bench的时候,把计算代码和输出代码分离测试。因为io部分所费的时间不好预测。

  4. zhangyufeng |

    http://twiki.laruence.com/ 打不开啦……

  5. CrossYou |

    我也使用了你同样的主题,呵呵

    你的文章写的很深,我才刚刚接触php,学习中,楼主加油。

  6. 雪候鸟 |

    @fybird vim

  7. fybird |

    请问你是用那个ide编程,平常。

  8. cody |

    thanks

  9. cody |

    补充一下,”opcode->compile->执行“ 我这里的compile指的其实是由opcode到c 这个过程。

  10. 雪候鸟 |

    @cody 应该是对于每条opline中的opcode. 都会通过分发对应到相应的处理器执行(zend_vm_def.h定义).
    include也是一条opcode,ZEND_INCLUDE_OR_EVAL, 相应的出错检查也就是在它的处理器中.

  11. cody |

    好文,不过有些疑问
    1.“对于每个Opcode都会分发执行”,这里的“个”指的是?是一条opcode语句还是一个php文件中所有的opcode语句?
    2.有个问题,php的错误检查阶段是哪个?不是语法检查。如include一个不存在的问题,php会报错,这个报错是在opcode->compile->执行中的哪个环节报错的?是compile环节还是执行环节呢?
    3.其实问题二是基于对php运行机制还不太清楚,我测试过一个文件 include 20个php文件和直接写成一个php文件性能上的差异很大(20文件并不执行),想知道是在哪个环境造成了这种差异。

    如果能回答我,感激不尽! :)

Leave a Reply

*