Quick Redis speed comparison script

bench.pl

#!/usr/bin/perl

use warnings;
use strict;

use IO::All;
use IO::Socket::UNIX qw( SOCK_STREAM );
use Benchmark ':hireswallclock';
use Redis;
use RedisDB;
use Redis::Fast;
use Cache::Memcached::Fast;

# Lazy copy/paste create independent connections
my $rsocka = IO::Socket::UNIX->new(Type => SOCK_STREAM, Peer => "/tmp/redis.sock");
my $rsockb = IO::Socket::UNIX->new(Type => SOCK_STREAM, Peer => "/tmp/redis.sock");
my $rsockc = IO::Socket::UNIX->new(Type => SOCK_STREAM, Peer => "/tmp/redis.sock");
my $rsockd = IO::Socket::UNIX->new(Type => SOCK_STREAM, Peer => "/tmp/redis.sock");
my $rsocke = IO::Socket::UNIX->new(Type => SOCK_STREAM, Peer => "/tmp/redis.sock");
my $rsockf = IO::Socket::UNIX->new(Type => SOCK_STREAM, Peer => "/tmp/redis.sock");

my $mca = IO::Socket::UNIX->new(Type => SOCK_STREAM, Peer => "/tmp/memcached.sock");
my $mcb = IO::Socket::UNIX->new(Type => SOCK_STREAM, Peer => "/tmp/memcached.sock");
my $mcc = IO::Socket::UNIX->new(Type => SOCK_STREAM, Peer => "/tmp/memcached.sock");
my $mcd = IO::Socket::UNIX->new(Type => SOCK_STREAM, Peer => "/tmp/memcached.sock");

my $redisdb = RedisDB->new(path => "/tmp/redis.sock");
my $redismod = Redis->new(sock => "/tmp/redis.sock");
my $redis = Redis::Fast->new(sock => '/tmp/redis.sock', encoding => undef);
$redis->set('foo', 'bar');

my $words = io("/usr/share/dict/words")->slurp;
$redis->set('larger', $words);

my $memcache = Cache::Memcached::Fast->new({
        servers => [ '/tmp/memcached.sock' ],
        utf8 => 0,
        nowait => 0,
        max_size => 4096 * 4096
        });
$memcache->set('foo', 'bar');
$memcache->set('larger', $words);

my $i = 0;
print "Large Benchmarks\n";
my $result = Benchmark::timethese(4_000, {
    'Redis-Raw-Inline' => sub { print $rsockb "GET larger\r\n"; $rsockb->read($_, substr($rsockb->getline, 1)+2); $rsockb->flush; },
    'Redis-Raw-Bulk' => sub { print $rsockc "*2\r\n\$3\r\nGET\n\n\$6\r\nlarger\r\n"; $rsockc->read($_, substr($rsockc->getline, 1)+2); $rsockc->flush; },
    'Redis' => sub { $redis->get('larger'); },
    'RedisDB' => sub { $redisdb->get('larger'); },
    'RedisMod' => sub { $redismod->get('larger'); },
    'Memcache' => sub { $memcache->get('larger'); },
    'Memcache-Raw' => sub { $mca->flush; print $mca "get larger\r\n"; my @parts = split /\s/, $mca->getline; $mca->read($_, $parts[3]+2); $mca->getline; }
});
print "Results:\n";
Benchmark::cmpthese $result;

print "\n\n";

print "Small Benchmarks\n";
$result = Benchmark::timethese(1_000_000, {
    'Redis-Raw-Bulk' => sub { $rsockf->flush; print $rsocke "*2\r\n\$3\r\nGET\n\n\$3\r\nfoo\r\n"; $rsocke->getline; $rsocke->getline; },
    'Redis-Raw-Inline' => sub { $rsockf->flush; print $rsockf "GET foo\r\n"; $rsockf->getline; $rsockf->getline; },
    'RedisDB' => sub { $redisdb->get('foo'); },
    'RedisMod' => sub { $redismod->get('foo'); },
    'Redis' => sub { $redis->get('foo'); },
    'Redis-DNE' => sub { $redis->get('bar'); },
    'Memcached' => sub { $memcache->get('foo'); },
    'Memcached-DNE' => sub { $memcache->get('bar'); },
    'Memcache-Raw' => sub { print $mcb "get foo\r\n"; $mcb->getline; $mcb->getline; $mcb->getline; },
});
print "Result:\n";
Benchmark::cmpthese $result;

Results on my laptop:

Large Benchmarks
Benchmark: timing 4000 iterations of Memcache, Memcache-Raw, Redis, Redis-Raw-Bulk, Redis-Raw-Inline, RedisDB, RedisMod...
  Memcache: 11.0503 wallclock secs ( 0.45 usr +  7.00 sys =  7.45 CPU) @ 536.91/s (n=4000)
Memcache-Raw: 9.768 wallclock secs ( 1.18 usr +  4.48 sys =  5.66 CPU) @ 706.71/s (n=4000)
     Redis: 13.6461 wallclock secs ( 3.95 usr +  8.48 sys = 12.43 CPU) @ 321.80/s (n=4000)
Redis-Raw-Bulk: 10.0401 wallclock secs ( 1.16 usr +  4.84 sys =  6.00 CPU) @ 666.67/s (n=4000)
Redis-Raw-Inline: 10.0243 wallclock secs ( 1.15 usr +  4.85 sys =  6.00 CPU) @ 666.67/s (n=4000)
   RedisDB: 9.76441 wallclock secs ( 4.23 usr +  4.05 sys =  8.28 CPU) @ 483.09/s (n=4000)
  RedisMod: 12.7869 wallclock secs ( 5.49 usr +  4.71 sys = 10.20 CPU) @ 392.16/s (n=4000)
Results:
                  Rate Redis RedisMod RedisDB Memcache Redis-Raw-Inline Redis-Raw-Bulk Memcache-Raw
Redis            322/s    --     -18%    -33%     -40%             -52%           -52%         -54%
RedisMod         392/s   22%       --    -19%     -27%             -41%           -41%         -45%
RedisDB          483/s   50%      23%      --     -10%             -28%           -28%         -32%
Memcache         537/s   67%      37%     11%       --             -19%           -19%         -24%
Redis-Raw-Inline 667/s  107%      70%     38%      24%               --            -0%          -6%
Redis-Raw-Bulk   667/s  107%      70%     38%      24%               0%             --          -6%
Memcache-Raw     707/s  120%      80%     46%      32%               6%             6%           --


Small Benchmarks
Benchmark: timing 1000000 iterations of Memcache-Raw, Memcached, Memcached-DNE, Redis, Redis-DNE, Redis-Raw-Bulk, Redis-Raw-Inline, RedisDB, RedisMod...
Memcache-Raw: 10.4522 wallclock secs ( 2.02 usr +  3.60 sys =  5.62 CPU) @ 177935.94/s (n=1000000)
 Memcached: 12.2543 wallclock secs ( 1.71 usr +  6.09 sys =  7.80 CPU) @ 128205.13/s (n=1000000)
Memcached-DNE: 11.1033 wallclock secs ( 1.03 usr +  5.93 sys =  6.96 CPU) @ 143678.16/s (n=1000000)
     Redis: 17.8883 wallclock secs ( 4.98 usr +  6.31 sys = 11.29 CPU) @ 88573.96/s (n=1000000)
 Redis-DNE: 17.3093 wallclock secs ( 4.56 usr +  6.28 sys = 10.84 CPU) @ 92250.92/s (n=1000000)
Redis-Raw-Bulk: 12.5372 wallclock secs ( 2.18 usr +  3.90 sys =  6.08 CPU) @ 164473.68/s (n=1000000)
Redis-Raw-Inline: 13.4731 wallclock secs ( 2.19 usr +  3.67 sys =  5.86 CPU) @ 170648.46/s (n=1000000)
   RedisDB: 24.237 wallclock secs (13.20 usr +  6.58 sys = 19.78 CPU) @ 50556.12/s (n=1000000)
  RedisMod: 30.9423 wallclock secs (23.02 usr +  5.25 sys = 28.27 CPU) @ 35373.19/s (n=1000000)
Result:
                     Rate RedisMod RedisDB Redis Redis-DNE Memcached Memcached-DNE Redis-Raw-Bulk Redis-Raw-Inline Memcache-Raw
RedisMod          35373/s       --    -30%  -60%      -62%      -72%          -75%           -78%             -79%         -80%
RedisDB           50556/s      43%      --  -43%      -45%      -61%          -65%           -69%             -70%         -72%
Redis             88574/s     150%     75%    --       -4%      -31%          -38%           -46%             -48%         -50%
Redis-DNE         92251/s     161%     82%    4%        --      -28%          -36%           -44%             -46%         -48%
Memcached        128205/s     262%    154%   45%       39%        --          -11%           -22%             -25%         -28%
Memcached-DNE    143678/s     306%    184%   62%       56%       12%            --           -13%             -16%         -19%
Redis-Raw-Bulk   164474/s     365%    225%   86%       78%       28%           14%             --              -4%          -8%
Redis-Raw-Inline 170648/s     382%    238%   93%       85%       33%           19%             4%               --          -4%
Memcache-Raw     177936/s     403%    252%  101%       93%       39%           24%             8%               4%           --