function bench($value, $n = 1000000)
{
$benchmark = new Benchmark();
$benchmark->add('serialize', function () use(&$value) {
serialize($value);
});
$benchmark->add('json_encode', function () use(&$value) {
json_encode($value);
});
if (function_exists('bin_encode')) {
$benchmark->add('bin_encode', function () use(&$value) {
bin_encode($value);
});
}
if (function_exists('bson_encode')) {
$benchmark->add('bson_encode', function () use(&$value) {
bson_encode($value);
});
}
if (function_exists('msgpack_pack')) {
$benchmark->add('msgpack_pack', function () use(&$value) {
msgpack_pack($value);
});
}
if (function_exists('igbinary_serialize')) {
$benchmark->add('igbinary_serialize', function () use(&$value) {
igbinary_serialize($value);
});
}
$benchmark->add('var_export', function () use(&$value) {
var_export($value, true);
});
$benchmark->setCount($n);
$benchmark->run();
}
function bench($value, $n = 1000000)
{
$benchmark = new Benchmark();
$serialized = serialize($value);
$benchmark->add('unserialize', function () use(&$serialized) {
unserialize($serialized);
});
$jsonEncoded = json_encode($value);
$benchmark->add('json_decode', function () use(&$jsonEncoded) {
json_decode($jsonEncoded);
});
if (function_exists('bin_decode')) {
$binEncoded = bin_encode($value);
$benchmark->add('bin_decode', function () use(&$binEncoded) {
bin_decode($binEncoded);
});
}
if (function_exists('bson_decode')) {
$bsonEncoded = bson_encode($value);
$benchmark->add('bson_decode', function () use(&$bsonEncoded) {
bson_decode($bsonEncoded);
});
}
if (function_exists('msgpack_pack')) {
$msgPack = msgpack_pack($value);
$benchmark->add('msgpack_unpack', function () use(&$msgPack) {
msgpack_unpack($msgPack);
});
}
if (function_exists('igbinary_unserialize')) {
$igbinarySerialized = igbinary_serialize($value);
$benchmark->add('igbinary_unserialize', function () use(&$igbinarySerialized) {
igbinary_unserialize($igbinarySerialized);
});
}
$benchmark->setCount($n);
$benchmark->run();
}
}
EventLoop::$instance = new EventLoop();
class A
{
protected $ev;
public function __construct(EventLoop $ev)
{
$this->ev = $ev;
}
public function test()
{
return $this->ev;
}
}
class B
{
public function test()
{
return EventLoop::$instance;
}
}
$aInstance = new A(new EventLoop());
$benchmark->add('without-static-normal-injection', function () use($aInstance) {
return $aInstance->test();
});
$bInstance = new B();
$benchmark->add('with-static-global-state', function () use($bInstance) {
return $bInstance->test();
});
$benchmark->setCount(10000000);
$benchmark->run();
$driverMemcache->save(rand(), 'tests');
});
$driverRedis = new Driver\Redis();
$benchmark->add('redis set', function () use(&$driverRedis) {
$driverRedis->save(rand(), 'tests');
});
$driverMemcached = new Driver\Memcached();
$benchmark->add('memcached set', function () use(&$driverMemcached) {
$driverMemcached->save(rand(), 'tests');
});
$driverNative = new Driver\NativeArray();
$benchmark->add('array set', function () use(&$driverNative) {
$driverNative->save(rand(), 'tests');
});
foreach ($cycles as $count) {
$benchmark->setCount($count);
$benchmark->run();
}
/*
$benchmark = new Benchmark;
$benchmark->add('memcache init', function() {
$driver = new Driver\Memcache();
$driver->getInstance();
unset($driver);
});
$benchmark->add('redis init', function() {
$driver = new Driver\Redis();
$driver->getInstance();
unset($driver);
});
$benchmark->add('memcached init', function() {
