Running benchmarks against Memcached

benchmarks/Support/Benchmark.php

@@ -1,8 +1,9 @@
 <?php
 
 namespace CacheWerk\Relay\Benchmarks\Support;
 
 use Exception;
+use Memcached;
 use Redis as PhpRedis;
 use Relay\Relay;
 use Predis\Client as Predis;
@@ -50,7 +51,9 @@
 
     protected Predis $predis;
 
-    protected PhpRedis $phpredis;
+    protected ?PhpRedis $phpredis;
+
+    protected ?Memcached $memcached;
 
     /**
      * @param  string  $host
@@ -101,6 +104,9 @@
     protected function flush(): void
     {
         $this->createPredis()->flushall();
+        if (($memcached = $this->createMemcached()) !== null) {
+            $memcached->flush();
+        }
     }
 
     /**
@@ -150,13 +156,17 @@
         $keys = [];
 
         $redis = $this->createPredis();
+        $memcached = $this->createMemcached();
         $items = $this->loadJsonFile('meteorites.json');
 
         foreach ($items as $item) {
             $key = (string) $item['id'];
 
             if ($this->flags() & self::STRING) {
                 $redis->set($key, serialize($item));
+                if ($memcached) {
+                    $memcached->set($key, serialize($item));
+                }
             } elseif ($this->flags() & self::LIST) {
                 $redis->rpush($key, $this->flattenArray($item));
             } elseif ($this->flags() & self::HASH) {
@@ -204,10 +214,8 @@
         $this->predis = $this->createPredis();
         $this->relay = $this->createRelay();
         $this->relayNoCache = $this->createRelayNoCache();
-
-        if (extension_loaded('redis')) {
-            $this->phpredis = $this->createPhpRedis();
-        }
+        $this->phpredis = $this->createPhpRedis();
+        $this->memcached = $this->createMemcached();
     }
 
     /**
@@ -220,10 +228,8 @@
     public function refreshClients(): void
     {
         $this->predis = $this->createPredis();
-
-        if (extension_loaded('redis')) {
-            $this->phpredis = $this->createPhpRedis();
-        }
+        $this->phpredis = $this->createPhpRedis();
+        $this->memcached = $this->createMemcached();
     }
 
     /**
@@ -264,8 +270,12 @@
         return $relay;
     }
 
-    protected function createPhpRedis(): PhpRedis
+    protected function createPhpRedis(): ?PhpRedis
     {
+        if (! extension_loaded('redis')) {
+            return null;
+        }
+
         $phpredis = new PhpRedis;
         $phpredis->connect($this->host, $this->port, 0.5, '', 0, 0.5);
         $phpredis->setOption(PhpRedis::OPT_MAX_RETRIES, 0);
@@ -305,19 +315,42 @@
         ]);
     }
 
+    protected function createMemcached(): ?Memcached
+    {
+        if (! extension_loaded('memcached')) {
+            return null;
+        }
+
+        $memcached = new Memcached();
+        $memcached->setOptions([
+            Memcached::OPT_CONNECT_TIMEOUT => 500,
+            Memcached::OPT_SEND_TIMEOUT => 500,
+            Memcached::OPT_RECV_TIMEOUT => 500,
+        ]);
+        $memcached->addServer($this->host, 11211); // TODO: add CLI options
+
+        return $memcached;
+    }
+
     /**
      * @return array<string>
      */
     public function getBenchmarkMethods(string $filter): array
     {
-        $exclude = null;
+        $exclude = [];
 
-        if (! extension_loaded('redis')) {
-            $exclude = 'PhpRedis';
+        if ($this->phpredis === null) {
+            $exclude[] = 'PhpRedis';
 
             Reporter::printWarning('Skipping PhpRedis runs, extension is not loaded');
         }
 
+        if ($this->memcached === null) {
+            $exclude[] = 'Memcached';
+
+            Reporter::printWarning('Skipping Memcached runs, extension is not loaded');
+        }
+
         return array_filter(
             get_class_methods($this),
             function ($method) use ($exclude, $filter) {
@@ -327,7 +360,7 @@
 
                 $method = substr($method, strlen('benchmark'));
 
-                if ($method === $exclude) {
+                if (in_array($method, $exclude, true)) {
                     return false;
                 }
 
@@ -347,7 +380,7 @@
 
     public function benchmarkPhpRedis(): int
     {
         return $this->runBenchmark($this->phpredis);
     }
 
     public function benchmarkRelayNoCache(): int
@@ -359,4 +392,9 @@
     {
         return $this->runBenchmark($this->relay);
     }
+
+    public function benchmarkMemcached(): int
+    {
+        return $this->runBenchmark($this->memcached);
+    }
 }

benchmarks/Support/BenchmarkKeyCommand.php

@@ -20,7 +20,7 @@ public function setUp(): void
     }
 
     /**
-     * @param  \Relay\Relay|\Redis|\Predis\Client  $client
+     * @param  \Relay\Relay|\Redis|\Predis\Client|\Memcached  $client
      */
     protected function runBenchmark($client): int
     {

benchmarks/Support/ConcurrentRunner.php

@@ -78,7 +78,11 @@ protected function getConcurrentStart(string $nonce): int
     protected function runConcurrentOnce(Benchmark $benchmark, Reporter $reporter, Subject $subject, string $class, string $method): Iteration
     {
         $start = hrtime(true);
-        [$rx1, $tx1] = $this->getNetworkStats();
+        if ($method === 'benchmarkMemcached') {
+            [$rx1, $tx1] = $this->getMemcachedNetworkStats();
+        } else {
+            [$rx1, $tx1] = $this->getRedisNetworkStats();
+        }
         $cmd1 = $this->getRedisCommandCount();
 
         $pids = [];
@@ -116,7 +120,11 @@ protected function runConcurrentOnce(Benchmark $benchmark, Reporter $reporter, S
             pcntl_waitpid($pid, $status, WUNTRACED);
         }
 
-        [$rx2, $tx2] = $this->getNetworkStats();
+        if ($method === 'benchmarkMemcached') {
+            [$rx2, $tx2] = $this->getMemcachedNetworkStats();
+        } else {
+            [$rx2, $tx2] = $this->getRedisNetworkStats();
+        }
         $cmd2 = $this->getRedisCommandCount();
 
         $end = $max_mem = $tot_ops = 0;

benchmarks/Support/Runner.php

@@ -1,7 +1,8 @@
 <?php
 
 namespace CacheWerk\Relay\Benchmarks\Support;
 
+use Memcached;
 use Predis\Client as Predis;
 
 class Runner
@@ -17,6 +18,8 @@
 
     protected Predis $redis;
 
+    protected ?Memcached $memcached;
+
     protected string $run_id;
 
     protected string $filter;
@@ -66,10 +69,24 @@
 
         fprintf(
             STDERR,
-            "Connected to Redis (%s) at %s\n\n",
+            "Connected to Redis (%s) at %s\n",
             $this->redis->info()['Server']['redis_version'],
             $this->port ? "tcp://{$host}:{$port}" : "unix:{$host}",
         );
+
+        $this->setUpMemcached();
+
+        if ($this->memcached) {
+            if (($version = $this->memcached->getVersion()) === false) {
+                throw new \ErrorException("Connection refused [tcp://{$host}:11211]");
+            }
+            fprintf(
+                STDERR,
+                "Connected to Memcached (%s) at %s\n",
+                $version["{$host}:11211"],
+                "tcp://{$host}:11211", // TODO: support unix socket
+            );
+        }
     }
 
     protected function setUpRedis(): void
@@ -100,6 +117,23 @@
         ]);
     }
 
+    protected function setUpMemcached(): void
+    {
+        if (! extension_loaded('memcached')) {
+            return;
+        }
+
+        $memcached = new Memcached();
+        $memcached->setOptions([
+            Memcached::OPT_CONNECT_TIMEOUT => 500,
+            Memcached::OPT_SEND_TIMEOUT => 500,
+            Memcached::OPT_RECV_TIMEOUT => 500,
+        ]);
+        $memcached->addServer($this->host, 11211);
+
+        $this->memcached = $memcached;
+    }
+
     protected function resetStats(): void
     {
         $this->redis->config('RESETSTAT');
@@ -112,13 +146,26 @@
     /**
      * @return array<int, int>
      */
-    protected function getNetworkStats(): array
+    protected function getMemcachedNetworkStats(): array
     {
-        $info = $this->redis->info('STATS')['Stats'];
+        $stats = $this->memcached->getStats()["{$this->host}:11211"];
 
         return [
-            $info['total_net_input_bytes'],
-            $info['total_net_output_bytes'],
+            $stats['bytes_read'],
+            $stats['bytes_written'],
+        ];
+    }
+
+    /**
+     * @return array<int, int>
+     */
+    protected function getRedisNetworkStats(): array
+    {
+        $stats = $this->redis->info('STATS')['Stats'];
+
+        return [
+            $stats['total_net_input_bytes'],
+            $stats['total_net_output_bytes'],
         ];
     }
 
@@ -157,7 +204,11 @@
                 $t2 = microtime(true);
             } while ($t2 - $t1 < $this->duration);
 
-            [$rx, $tx] = $this->getNetworkStats();
+            if ($method === 'benchmarkMemcached') {
+                [$rx, $tx] = $this->getMemcachedNetworkStats();
+            } else {
+                [$rx, $tx] = $this->getRedisNetworkStats();
+            }
             $millis = ($t2 - $t1) * 1000;
             $memory = memory_get_peak_usage();
             $cmds = $this->getRedisCommandCount() - $cmds1;