mirror of
https://github.com/php/php-src.git
synced 2024-11-23 01:44:06 +08:00
359 lines
7.1 KiB
PHP
359 lines
7.1 KiB
PHP
<?php
|
|
|
|
function hallo() {
|
|
}
|
|
|
|
function simpleucall($n) {
|
|
for ($i = 0; $i < $n; $i++)
|
|
hallo();
|
|
}
|
|
|
|
function simpleudcall($n) {
|
|
for ($i = 0; $i < $n; $i++)
|
|
hallo2();
|
|
}
|
|
|
|
function hallo2() {
|
|
}
|
|
|
|
function simpleicall($n) {
|
|
for ($i = 0; $i < $n; $i++)
|
|
func_num_args();
|
|
}
|
|
|
|
class Foo {
|
|
static $a = 0;
|
|
public $b = 0;
|
|
const TEST = 0;
|
|
|
|
static function read_static($n) {
|
|
for ($i = 0; $i < $n; ++$i) {
|
|
$x = self::$a;
|
|
}
|
|
}
|
|
|
|
static function write_static($n) {
|
|
for ($i = 0; $i < $n; ++$i) {
|
|
self::$a = 0;
|
|
}
|
|
}
|
|
|
|
static function isset_static($n) {
|
|
for ($i = 0; $i < $n; ++$i) {
|
|
$x = isset(self::$a);
|
|
}
|
|
}
|
|
|
|
static function empty_static($n) {
|
|
for ($i = 0; $i < $n; ++$i) {
|
|
$x = empty(self::$a);
|
|
}
|
|
}
|
|
|
|
static function f() {
|
|
}
|
|
|
|
static function call_static($n) {
|
|
for ($i = 0; $i < $n; ++$i) {
|
|
self::f();
|
|
}
|
|
}
|
|
|
|
function read_prop($n) {
|
|
for ($i = 0; $i < $n; ++$i) {
|
|
$x = $this->b;
|
|
}
|
|
}
|
|
|
|
function write_prop($n) {
|
|
for ($i = 0; $i < $n; ++$i) {
|
|
$this->b = 0;
|
|
}
|
|
}
|
|
|
|
function assign_add_prop($n) {
|
|
for ($i = 0; $i < $n; ++$i) {
|
|
$this->b += 2;
|
|
}
|
|
}
|
|
|
|
function pre_inc_prop($n) {
|
|
for ($i = 0; $i < $n; ++$i) {
|
|
++$this->b;
|
|
}
|
|
}
|
|
|
|
function pre_dec_prop($n) {
|
|
for ($i = 0; $i < $n; ++$i) {
|
|
--$this->b;
|
|
}
|
|
}
|
|
|
|
function post_inc_prop($n) {
|
|
for ($i = 0; $i < $n; ++$i) {
|
|
$this->b++;
|
|
}
|
|
}
|
|
|
|
function post_dec_prop($n) {
|
|
for ($i = 0; $i < $n; ++$i) {
|
|
$this->b--;
|
|
}
|
|
}
|
|
|
|
function isset_prop($n) {
|
|
for ($i = 0; $i < $n; ++$i) {
|
|
$x = isset($this->b);
|
|
}
|
|
}
|
|
|
|
function empty_prop($n) {
|
|
for ($i = 0; $i < $n; ++$i) {
|
|
$x = empty($this->b);
|
|
}
|
|
}
|
|
|
|
function g() {
|
|
}
|
|
|
|
function call($n) {
|
|
for ($i = 0; $i < $n; ++$i) {
|
|
$this->g();
|
|
}
|
|
}
|
|
|
|
function read_const($n) {
|
|
for ($i = 0; $i < $n; ++$i) {
|
|
$x = $this::TEST;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
function read_static($n) {
|
|
for ($i = 0; $i < $n; ++$i) {
|
|
$x = Foo::$a;
|
|
}
|
|
}
|
|
|
|
function write_static($n) {
|
|
for ($i = 0; $i < $n; ++$i) {
|
|
Foo::$a = 0;
|
|
}
|
|
}
|
|
|
|
function isset_static($n) {
|
|
for ($i = 0; $i < $n; ++$i) {
|
|
$x = isset(Foo::$a);
|
|
}
|
|
}
|
|
|
|
function empty_static($n) {
|
|
for ($i = 0; $i < $n; ++$i) {
|
|
$x = empty(Foo::$a);
|
|
}
|
|
}
|
|
|
|
function call_static($n) {
|
|
for ($i = 0; $i < $n; ++$i) {
|
|
Foo::f();
|
|
}
|
|
}
|
|
|
|
function create_object($n) {
|
|
for ($i = 0; $i < $n; ++$i) {
|
|
$x = new Foo();
|
|
}
|
|
}
|
|
|
|
define('TEST', null);
|
|
|
|
function read_const($n) {
|
|
for ($i = 0; $i < $n; ++$i) {
|
|
$x = TEST;
|
|
}
|
|
}
|
|
|
|
function read_auto_global($n) {
|
|
for ($i = 0; $i < $n; ++$i) {
|
|
$x = $_GET;
|
|
}
|
|
}
|
|
|
|
$g_var = 0;
|
|
|
|
function read_global_var($n) {
|
|
for ($i = 0; $i < $n; ++$i) {
|
|
$x = $GLOBALS['g_var'];
|
|
}
|
|
}
|
|
|
|
function read_hash($n) {
|
|
$hash = array('test' => 0);
|
|
for ($i = 0; $i < $n; ++$i) {
|
|
$x = $hash['test'];
|
|
}
|
|
}
|
|
|
|
function read_str_offset($n) {
|
|
$str = "test";
|
|
for ($i = 0; $i < $n; ++$i) {
|
|
$x = $str[1];
|
|
}
|
|
}
|
|
|
|
function issetor($n) {
|
|
$val = array(0,1,2,3,4,5,6,7,8,9);
|
|
for ($i = 0; $i < $n; ++$i) {
|
|
$x = $val ?: null;
|
|
}
|
|
}
|
|
|
|
function issetor2($n) {
|
|
$f = false; $j = 0;
|
|
for ($i = 0; $i < $n; ++$i) {
|
|
$x = $f ?: $j + 1;
|
|
}
|
|
}
|
|
|
|
function ternary($n) {
|
|
$val = array(0,1,2,3,4,5,6,7,8,9);
|
|
$f = false;
|
|
for ($i = 0; $i < $n; ++$i) {
|
|
$x = $f ? null : $val;
|
|
}
|
|
}
|
|
|
|
function ternary2($n) {
|
|
$f = false; $j = 0;
|
|
for ($i = 0; $i < $n; ++$i) {
|
|
$x = $f ? $f : $j + 1;
|
|
}
|
|
}
|
|
|
|
/*****/
|
|
|
|
function empty_loop($n) {
|
|
for ($i = 0; $i < $n; ++$i) {
|
|
}
|
|
}
|
|
|
|
function gethrtime()
|
|
{
|
|
$hrtime = hrtime();
|
|
return (($hrtime[0]*1000000000 + $hrtime[1]) / 1000000000);
|
|
}
|
|
|
|
function start_test()
|
|
{
|
|
ob_start();
|
|
return gethrtime();
|
|
}
|
|
|
|
function end_test($start, $name, $overhead = null)
|
|
{
|
|
global $total;
|
|
global $last_time;
|
|
$end = gethrtime();
|
|
ob_end_clean();
|
|
$last_time = $end-$start;
|
|
$total += $last_time;
|
|
$num = number_format($last_time,3);
|
|
$pad = str_repeat(" ", 24-strlen($name)-strlen($num));
|
|
if (is_null($overhead)) {
|
|
echo $name.$pad.$num."\n";
|
|
} else {
|
|
$num2 = number_format($last_time - $overhead,3);
|
|
echo $name.$pad.$num." ".$num2."\n";
|
|
}
|
|
ob_start();
|
|
return gethrtime();
|
|
}
|
|
|
|
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";
|
|
}
|
|
|
|
const N = 5000000;
|
|
|
|
$t0 = $t = start_test();
|
|
empty_loop(N);
|
|
$t = end_test($t, 'empty_loop');
|
|
$overhead = $last_time;
|
|
simpleucall(N);
|
|
$t = end_test($t, 'func()', $overhead);
|
|
simpleudcall(N);
|
|
$t = end_test($t, 'undef_func()', $overhead);
|
|
simpleicall(N);
|
|
$t = end_test($t, 'int_func()', $overhead);
|
|
Foo::read_static(N);
|
|
$t = end_test($t, '$x = self::$x', $overhead);
|
|
Foo::write_static(N);
|
|
$t = end_test($t, 'self::$x = 0', $overhead);
|
|
Foo::isset_static(N);
|
|
$t = end_test($t, 'isset(self::$x)', $overhead);
|
|
Foo::empty_static(N);
|
|
$t = end_test($t, 'empty(self::$x)', $overhead);
|
|
read_static(N);
|
|
$t = end_test($t, '$x = Foo::$x', $overhead);
|
|
write_static(N);
|
|
$t = end_test($t, 'Foo::$x = 0', $overhead);
|
|
isset_static(N);
|
|
$t = end_test($t, 'isset(Foo::$x)', $overhead);
|
|
empty_static(N);
|
|
$t = end_test($t, 'empty(Foo::$x)', $overhead);
|
|
Foo::call_static(N);
|
|
$t = end_test($t, 'self::f()', $overhead);
|
|
call_static(N);
|
|
$t = end_test($t, 'Foo::f()', $overhead);
|
|
$x = new Foo();
|
|
$x->read_prop(N);
|
|
$t = end_test($t, '$x = $this->x', $overhead);
|
|
$x->write_prop(N);
|
|
$t = end_test($t, '$this->x = 0', $overhead);
|
|
$x->assign_add_prop(N);
|
|
$t = end_test($t, '$this->x += 2', $overhead);
|
|
$x->pre_inc_prop(N);
|
|
$t = end_test($t, '++$this->x', $overhead);
|
|
$x->pre_dec_prop(N);
|
|
$t = end_test($t, '--$this->x', $overhead);
|
|
$x->post_inc_prop(N);
|
|
$t = end_test($t, '$this->x++', $overhead);
|
|
$x->post_dec_prop(N);
|
|
$t = end_test($t, '$this->x--', $overhead);
|
|
$x->isset_prop(N);
|
|
$t = end_test($t, 'isset($this->x)', $overhead);
|
|
$x->empty_prop(N);
|
|
$t = end_test($t, 'empty($this->x)', $overhead);
|
|
$x->call(N);
|
|
$t = end_test($t, '$this->f()', $overhead);
|
|
$x->read_const(N);
|
|
$t = end_test($t, '$x = Foo::TEST', $overhead);
|
|
create_object(N);
|
|
$t = end_test($t, 'new Foo()', $overhead);
|
|
read_const(N);
|
|
$t = end_test($t, '$x = TEST', $overhead);
|
|
read_auto_global(N);
|
|
$t = end_test($t, '$x = $_GET', $overhead);
|
|
read_global_var(N);
|
|
$t = end_test($t, '$x = $GLOBALS[\'v\']', $overhead);
|
|
read_hash(N);
|
|
$t = end_test($t, '$x = $hash[\'v\']', $overhead);
|
|
read_str_offset(N);
|
|
$t = end_test($t, '$x = $str[0]', $overhead);
|
|
issetor(N);
|
|
$t = end_test($t, '$x = $a ?: null', $overhead);
|
|
issetor2(N);
|
|
$t = end_test($t, '$x = $f ?: tmp', $overhead);
|
|
ternary(N);
|
|
$t = end_test($t, '$x = $f ? $f : $a', $overhead);
|
|
ternary2(N);
|
|
$t = end_test($t, '$x = $f ? $f : tmp', $overhead);
|
|
total($t0, "Total");
|