PHP Benchmark::run方法代码示例

    // a simple function
    return $x + 1;
}
class clsTest
{
    function method($x)
    {
        // a simple method
        return $x + 1;
    }
    static function static_method($x)
    {
        // a simple method
        return $x + 1;
    }
}
$obj = new clsTest();
$x = 29;
$params = array(&$obj, $x);
$benchmark = new Benchmark('bench function Vs method');
$benchmark->setRunningCount(10000);
$result1 = $benchmark->run('global function', 'f_function_normal', $params);
$result2 = $benchmark->run('object method', 'f_method_normal', $params);
$result3 = $benchmark->run('static object method', 'f_method_static', $params);
$result4 = $benchmark->run('static object method as normal', 'f_method_static_as_normal', $params);
$benchmark->compare($result1, $result2);
$benchmark->compare($result1, $result3);
$benchmark->compare($result1, $result4);
$benchmark->compare($result2, $result3);
$benchmark->compare($result3, $result4);
$benchmark->showResults();

        $m = array();
        for ($i = 2; $i <= 8; $i *= 2) {
            $t = 32 / $i;
            echo "<b>Singular value decomposition: {$t} random {$i}x{$i} matrices</b><br />";
            $s = $benchmark->displayStats($benchmark->runSVD($i, $t));
            $m[$i] = $s['mean'];
            echo "<br />";
        }
        echo '<pre>';
        foreach ($m as $x => $y) {
            echo "{$x}\t" . 1000 * $y . "\n";
        }
        echo '</pre>';
        break;
    case 'all':
        $s = $benchmark->run();
        print "<br /><b>Total<b>: {$s}s<br />";
        break;
    default:
        ?>
	<ul>
	<li><a href="benchmark.php?decomposition=all">Complete Benchmark</a></li>
	<ul>
	<li><a href="benchmark.php?decomposition=cholesky">Cholesky</a></li>
	<li><a href="benchmark.php?decomposition=eigenvalue">Eigenvalue</a></li>
	<li><a href="benchmark.php?decomposition=lu">LU</a></li>
	<li><a href="benchmark.php?decomposition=qr">QR</a></li>
	<li><a href="benchmark.php?decomposition=svd">Singular Value</a></li>
	</ul>
	</ul>
	<?php 

            }
            $profiler->leaveSection($test);
        }
        $profiler->stop();
        $profiler->display();
    }
    protected function configDecodeBinarySimple()
    {
        return array(new Protobuf\Codec\Binary(), file_get_contents(__DIR__ . '/protos/simple.bin'));
    }
    protected function runDecodeBinarySimple($codec, $data)
    {
        $codec->decode(new test\Simple(), $data);
    }
    protected function configDecodeJsonSimple()
    {
        $codecBin = new Protobuf\Codec\Binary();
        $codecJson = new Protobuf\Codec\Json();
        $bin = $this->configDecodeBinarySimple();
        $simple = $codecBin->decode(new test\Simple(), $bin[1]);
        $data = $codecJson->encode($simple);
        return array($codecJson, $data);
    }
    protected function runDecodeJsonSimple($codec, $data)
    {
        $codec->decode(new test\Simple(), $data);
    }
}
$bench = new Benchmark();
$bench->run(1000);

<?php

require __DIR__ . '/../benchmark.php';
$vector = new Icecave\Collections\Vector();
Benchmark::run(1000, function ($i) use($vector) {
    $vector->pushFront($i);
}, function ($i) use($vector) {
    $vector->popFront();
});

<?php

require __DIR__ . '/../benchmark.php';
$vector = new Icecave\Collections\Vector();
Benchmark::run(50000, null, function ($i) use($vector) {
    $vector->pushBack($i);
});

        $container = new Container($framework);
        $container->run();
    }
} else {
    if ($command == ArgParser::CMD_STOP) {
        Container::checkDocker();
        foreach (Framework::getFrameworks() as $framework) {
            $container = new Container($framework);
            $container->stop();
        }
    } else {
        if ($command == ArgParser::CMD_BENCHMARK) {
            out("Doing " . Benchmark::NUMBER_OF_CALLS . " calls per framework. Displaying averages.");
            foreach (Framework::getFrameworks() as $framework) {
                $benchmark = new Benchmark($framework);
                $benchmark->run()->outputTimes();
            }
        } else {
            out("== Available commands: ==");
            out(ArgParser::CMD_BENCHMARK);
            out(ArgParser::CMD_START);
            out(ArgParser::CMD_STOP);
        }
    }
}
class Container
{
    /** @var Framework */
    private $framework;
    /** @var string */
    private $directory;

    }
    protected function classify($index)
    {
        $closest_neighbour_index = null;
        $closest_neighbour_distance = INF;
        $count = count($this->attributes);
        for ($i = 0; $i < $count; $i++) {
            if ($i == $index) {
                continue;
            }
            $total = 0;
            for ($j = 0; $j < 3; $j++) {
                $total += pow($this->attributes[$index][$j] - $this->attributes[$i][$j], 2);
            }
            $distance = sqrt($total);
            if ($distance < $closest_neighbour_distance) {
                $closest_neighbour_index = $i;
                $closest_neighbour_distance = $distance;
            }
        }
        return $this->classes[$closest_neighbour_index];
    }
}
if (defined('HHVM_VERSION')) {
    echo 'HHVM' . PHP_EOL;
} else {
    echo 'PHP ' . PHP_MAJOR_VERSION . '.' . PHP_MINOR_VERSION . PHP_EOL;
}
$benchmark = new Benchmark();
$total = $benchmark->run();
echo number_format($total) . ' instances classified in 30 seconds (' . number_format($total / 30) . ' per second)' . PHP_EOL;

<?php

include dirname(__FILE__) . '/include/Benchmark.php';
function f_test_keyexists($prms)
{
    return array_key_exists('thekey', $prms);
}
function f_test_isset($prms)
{
    return isset($prms['thekey']);
}
$benchmark = new Benchmark('bench isset() Vs array_key_exists()');
$benchmark->setRunningCount(10000);
$params_without = array('param1' => 'value1', 'name' => 'Paul', 'id=' > 23);
$params_with = array('param1' => 'value1', 'name' => 'Paul', 'thekey' => 'here', 'id=' > 23);
$result1 = $benchmark->run('array_key_exists() with existing key', 'f_test_keyexists', array($params_with));
$result2 = $benchmark->run('array_key_exists() with non existing key', 'f_test_keyexists', array($params_without));
$result3 = $benchmark->run('isset() with existing key', 'f_test_isset', array($params_with));
$result4 = $benchmark->run('isset() with non existing key', 'f_test_isset', array($params_without));
$benchmark->compare($result1, $result3);
$benchmark->compare($result2, $result4);
$benchmark->showResults();

<?php

$config = [];
require_once "./config.php";
require_once "./Benchmark.php";
$bc = new Benchmark($config["test_function"]);
$bc->process_num = $config["process_num"];
$bc->request_num = $config["request_num"];
$bc->server_url = $config["server_url"];
$bc->server_config = parse_url($config["server_url"]);
$send_data = $config["send_data"];
$package_eof = $config["package_eof"];
$bc->process_req_num = intval($bc->request_num / $bc->process_num);
$bc->run();
$bc->report();
function long_tcp(Benchmark $bc)
{
    global $send_data, $package_eof;
    static $client = null;
    static $i;
    static $index;
    $start = microtime(true);
    if (empty($client)) {
        $client = new swoole_client(SWOOLE_SOCK_TCP, SWOOLE_SOCK_SYNC);
        $client->set(array('open_eof_check' => true, "package_eof" => $package_eof));
        $end = microtime(true);
        $conn_use = $end - $start;
        $bc->max_conn_time = $conn_use;
        $i = 0;
        $index = 0;
        if (!$client->connect($bc->server_config['host'], $bc->server_config['port'], 2)) {

    if (file_exists($file)) {
        $x = fopen($file, 'r', true);
        fclose($x);
        return true;
    } else {
        return false;
    }
}
function f_test_ofile($file)
{
    $x = @fopen($file, 'r', true);
    if ($x === false) {
        return false;
    } else {
        fclose($x);
        return true;
    }
}
$benchmark = new Benchmark('bench file_exists() Vs fopen()');
$benchmark->setRunningCount(10000);
$params_ok = array(basename(__FILE__));
$params_err = array('this_file_do_not_exists.txt');
$result1 = $benchmark->run('file_exists() with existing file', 'f_test_file_exists', $params_ok);
$result2 = $benchmark->run('file_exists() with non existing file', 'f_test_file_exists', $params_err);
$result3 = $benchmark->run('fopen() with existing file', 'f_test_ofile', $params_ok);
$result4 = $benchmark->run('fopen() with non existing file', 'f_test_ofile', $params_err);
$benchmark->compare($result1, $result2);
$benchmark->compare($result3, $result4);
$benchmark->compare($result1, $result3);
$benchmark->compare($result2, $result4);
$benchmark->showResults();

function f_test_read_object_any(&$x)
{
    $a = $x->name;
    $b = $x->subname;
    $c = $x->id;
    return $a . $b . $c;
}
function f_test_read_array($x)
{
    $a = $x['name'];
    $b = $x['subname'];
    $c = $x['id'];
    return $a . $b . $c;
}
$benchmark = new Benchmark('bench array Vs object');
$benchmark->setRunningCount(10000);
$result1 = $benchmark->run('create object from array', 'f_test_create_object_std');
$result2 = $benchmark->run('instanciate a new object', 'f_test_create_object_spec');
$result3 = $benchmark->run('create array', 'f_test_create_array_declarative');
$result4 = $benchmark->run('fill array', 'f_test_create_array_iterative');
$x = f_test_create_object_std();
$result5 = $benchmark->run('read object created from array', 'f_test_read_object_any', array(&$x));
$x = f_test_create_object_spec();
$result6 = $benchmark->run('read instanciated object', 'f_test_read_object_any', array(&$x));
$x = f_test_create_array_declarative();
$result7 = $benchmark->run('read array', 'f_test_read_array', array(&$x));
$benchmark->compare($result1, $result2);
$benchmark->compare($result3, $result4);
$benchmark->compare($result1, $result3);
$benchmark->compare($result6, $result7);
$benchmark->showResults();

     * Kills a process properly
     *
     * @param handler &$handle The handler
     * @param array   &$pipes  The pipes
     *
     * @return void
     */
    function killProperly(&$handle, &$pipes)
    {
        // proc_terminate kills the shell process, but won't kill a runaway infinite
        // loop. Get the child processes using ps, before killing the parent.
        $pids = $this->getChildren($handle, $pipes);
        // if we dont close pipes, we can create deadlock, leaving zombie processes.
        foreach ($pipes as &$pipe) {
            fclose($pipe);
        }
        proc_terminate($handle);
        proc_close($handle);
        // Not necessarily available.
        if (function_exists("posix_kill")) {
            foreach ($pids as $pid) {
                if (is_numeric($pid)) {
                    posix_kill($pid, 9);
                }
            }
        }
    }
}
$bench = new Benchmark();
$bench->run();