Comparison: Memcached 1.6 vs. Redis 8 vs. Dragonfly 1.20 for 2026 Simple Key-Value Cache Speed

#!/usr/bin/env python3
"""
2026 KV Cache Benchmark Runner
Tests Memcached 1.6, Redis 8, Dragonfly 1.20 using memtier_benchmark
Requires: memtier_benchmark 2.2.0+, Python 3.12+, running instances of all three tools on localhost
"""
import subprocess
import csv
import time
import argparse
import logging
from typing import Dict, List, Optional

# Configure logging
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s - %(levelname)s - %(message)s"
)
logger = logging.getLogger(__name__)

# Default benchmark parameters (matches methodology)
DEFAULT_PORTS = {
    "memcached": 11211,
    "redis": 6379,
    "dragonfly": 6379  # Dragonfly defaults to Redis protocol port
}
DEFAULT_TEST_DURATION = 3600  # 60 minutes
DEFAULT_WARMUP = 1800  # 30 minutes
DEFAULT_THREADS = 50
DEFAULT_CONNECTIONS = 1000

def run_memtier(instance: str, port: int) -> Optional[Dict[str, float]]:
    """
    Run memtier_benchmark against a target instance and parse throughput/latency.
    Returns dict with ops_sec, p99_latency or None if failed.
    """
    cmd = [
        "memtier_benchmark",
        "--server=127.0.0.1",
        f"--port={port}",
        "--protocol=memcache" if instance == "memcached" else "--protocol=redis",
        f"--threads={DEFAULT_THREADS}",
        f"--clients={DEFAULT_CONNECTIONS}",
        "--test-time=3600",
        "--warmup-time=1800",
        "--key-pattern=G:G",  # Random key distribution
        "--key-minimum=1",
        "--key-maximum=1000000",
        "--value-size=1024",  # 1KB value
        "--ratio=8:2",  # 80% GET, 20% SET
        "--json-out=/tmp/bench_{instance}.json"
    ]
    try:
        logger.info(f"Running benchmark for {instance} on port {port}")
        result = subprocess.run(
            cmd,
            capture_output=True,
            text=True,
            check=True,
            timeout=DEFAULT_TEST_DURATION + DEFAULT_WARMUP + 300  # Add 5 min buffer
        )
        # Parse memtier output for throughput (ops/sec) and p99 latency
        # memtier outputs "Totals" section with ops/sec and latency percentiles
        lines = result.stdout.split("\n")
        totals_start = None
        for i, line in enumerate(lines):
            if "Totals" in line:
                totals_start = i
                break
        if not totals_start:
            logger.error(f"No Totals section found for {instance}")
            return None
        # Parse ops/sec from Totals line
        ops_sec_line = lines[totals_start + 2]  # Skip header lines
        ops_sec = float(ops_sec_line.split()[1])
        # Parse p99 latency from latency percentile line
        latency_line = lines[totals_start + 6]
        p99_latency = float(latency_line.split()[4])  # p99 is 4th column
        logger.info(f"{instance} results: {ops_sec} ops/sec, {p99_latency}ms p99 latency")
        return {"ops_sec": ops_sec, "p99_latency": p99_latency}
    except subprocess.CalledProcessError as e:
        logger.error(f"Benchmark failed for {instance}: {e.stderr}")
        return None
    except Exception as e:
        logger.error(f"Unexpected error for {instance}: {str(e)}")
        return None

def main():
    parser = argparse.ArgumentParser(description="Run KV cache benchmarks")
    parser.add_argument("--memcached-port", type=int, default=DEFAULT_PORTS["memcached"])
    parser.add_argument("--redis-port", type=int, default=DEFAULT_PORTS["redis"])
    parser.add_argument("--dragonfly-port", type=int, default=DEFAULT_PORTS["dragonfly"])
    parser.add_argument("--output", type=str, default="bench_results.csv")
    args = parser.parse_args()

    results = []
    for instance, port in [
        ("memcached", args.memcached_port),
        ("redis", args.redis_port),
        ("dragonfly", args.dragonfly_port)
    ]:
        result = run_memtier(instance, port)
        if result:
            results.append({
                "instance": instance,
                "ops_sec": result["ops_sec"],
                "p99_latency": result["p99_latency"],
                "version": {
                    "memcached": "1.6.24",
                    "redis": "8.0.2",
                    "dragonfly": "1.20.1"
                }[instance]
            })
        time.sleep(60)  # Cooldown between tests

    # Write results to CSV
    with open(args.output, "w", newline="") as f:
        writer = csv.DictWriter(f, fieldnames=["instance", "version", "ops_sec", "p99_latency"])
        writer.writeheader()
        writer.writerows(results)
    logger.info(f"Results written to {args.output}")

if __name__ == "__main__":
    main()

package main

import (
    "context"
    "fmt"
    "log"
    "sync"
    "time"

    "github.com/bradfitz/gomemcache/memcache" // https://github.com/bradfitz/gomemcache
)

// MemcachedPool is a thread-safe connection pool for Memcached 1.6
type MemcachedPool struct {
    clients []*memcache.Client
    mu      sync.RWMutex
    index   int
    maxConns int
    serverAddrs []string
}

// NewMemcachedPool initializes a new pool with maxConns connections across serverAddrs
func NewMemcachedPool(serverAddrs []string, maxConns int) (*MemcachedPool, error) {
    if len(serverAddrs) == 0 {
        return nil, fmt.Errorf("no Memcached server addresses provided")
    }
    if maxConns <= 0 {
        return nil, fmt.Errorf("maxConns must be positive")
    }
    pool := &MemcachedPool{
        serverAddrs: serverAddrs,
        maxConns:    maxConns,
        clients:     make([]*memcache.Client, 0, maxConns),
    }
    // Initialize connections
    for i := 0; i < maxConns; i++ {
        client := memcache.New(serverAddrs...)
        // Set timeout to match Memcached 1.6 default 5s
        client.Timeout = 5 * time.Second
        pool.clients = append(pool.clients, client)
    }
    log.Printf("Initialized Memcached pool with %d connections to %v", maxConns, serverAddrs)
    return pool, nil
}

// Get retrieves a key from Memcached, returns error if not found or connection fails
func (p *MemcachedPool) Get(ctx context.Context, key string) (string, error) {
    client, err := p.getClient()
    if err != nil {
        return "", fmt.Errorf("failed to get client: %w", err)
    }
    // Use context to enforce timeout
    type result struct {
        item *memcache.Item
        err  error
    }
    ch := make(chan result, 1)
    go func() {
        item, err := client.Get(key)
        ch <- result{item: item, err: err}
    }()
    select {
    case res := <-ch:
        if res.err != nil {
            return "", fmt.Errorf("memcached get error: %w", res.err)
        }
        if res.item == nil {
            return "", fmt.Errorf("key %s not found", key)
        }
        return string(res.item.Value), nil
    case <-ctx.Done():
        return "", fmt.Errorf("get timeout for key %s: %w", key, ctx.Err())
    }
}

// Set stores a key-value pair in Memcached with optional expiration
func (p *MemcachedPool) Set(ctx context.Context, key string, value string, exp time.Duration) error {
    client, err := p.getClient()
    if err != nil {
        return fmt.Errorf("failed to get client: %w", err)
    }
    expSeconds := int32(exp.Seconds())
    if expSeconds < 0 {
        expSeconds = 0 // No expiration
    }
    item := &memcache.Item{
        Key:        key,
        Value:      []byte(value),
        Expiration: expSeconds,
    }
    type result struct {
        err error
    }
    ch := make(chan result, 1)
    go func() {
        err := client.Set(item)
        ch <- result{err: err}
    }()
    select {
    case res := <-ch:
        if res.err != nil {
            return fmt.Errorf("memcached set error: %w", res.err)
        }
        return nil
    case <-ctx.Done():
        return fmt.Errorf("set timeout for key %s: %w", key, ctx.Err())
    }
}

// getClient returns a client using round-robin selection
func (p *MemcachedPool) getClient() (*memcache.Client, error) {
    p.mu.Lock()
    defer p.mu.Unlock()
    if len(p.clients) == 0 {
        return nil, fmt.Errorf("no available clients in pool")
    }
    client := p.clients[p.index]
    p.index = (p.index + 1) % len(p.clients)
    return client, nil
}

// Close closes all connections in the pool
func (p *MemcachedPool) Close() error {
    p.mu.Lock()
    defer p.mu.Unlock()
    var errs []error
    for _, client := range p.clients {
        // gomemcache client has no explicit close, but we can nil the slice
        _ = client
    }
    p.clients = nil
    log.Println("Closed all Memcached pool connections")
    return nil
}

func main() {
    // Example usage: connect to local Memcached 1.6 instance
    pool, err := NewMemcachedPool([]string{"127.0.0.1:11211"}, 10)
    if err != nil {
        log.Fatalf("Failed to create pool: %v", err)
    }
    defer pool.Close()

    ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
    defer cancel()

    // Set a test key
    err = pool.Set(ctx, "test_key", "hello_memcached_1.6", 10*time.Minute)
    if err != nil {
        log.Fatalf("Failed to set key: %v", err)
    }
    log.Println("Set test_key successfully")

    // Get the test key
    val, err := pool.Get(ctx, "test_key")
    if err != nil {
        log.Fatalf("Failed to get key: %v", err)
    }
    log.Printf("Got test_key value: %s", val)
}

const redis = require("ioredis"); // https://github.com/luin/ioredis
const fs = require("fs/promises");
const { program } = require("commander");

/**
 * Redis 8 to Dragonfly 1.20 Migration Script
 * Leverages Dragonfly's Redis protocol compatibility to copy all keys
 * Supports SCAN-based iteration to avoid blocking, TTL preservation
 */

program
  .option("--redis-host ", "Redis 8 host", "127.0.0.1")
  .option("--redis-port ", "Redis 8 port", "6379")
  .option("--redis-password ", "Redis 8 password")
  .option("--dragonfly-host ", "Dragonfly 1.20 host", "127.0.0.1")
  .option("--dragonfly-port ", "Dragonfly 1.20 port", "6379")
  .option("--dragonfly-password ", "Dragonfly 1.20 password")
  .option("--batch-size ", "Number of keys to migrate per batch", "1000")
  .option("--log-file ", "Log file path", "migration.log")
  .parse();

const options = program.opts();

// Initialize Redis and Dragonfly clients
const redisClient = new redis({
  host: options.redisHost,
  port: options.redisPort,
  password: options.redisPassword,
  maxRetriesPerRequest: 3,
  retryStrategy: (times) => Math.min(times * 50, 2000),
});

const dragonflyClient = new redis({
  host: options.dragonflyHost,
  port: options.dragonflyPort,
  password: options.dragonflyPassword,
  maxRetriesPerRequest: 3,
  retryStrategy: (times) => Math.min(times * 50, 2000),
});

// Logger that writes to file and console
const logger = {
  info: (msg) => {
    const log = `[INFO] ${new Date().toISOString()} ${msg}\n`;
    console.log(log.trim());
    return fs.appendFile(options.logFile, log);
  },
  error: (msg) => {
    const log = `[ERROR] ${new Date().toISOString()} ${msg}\n`;
    console.error(log.trim());
    return fs.appendFile(options.logFile, log);
  },
};

// Migrate a single key with TTL
async function migrateKey(key) {
  try {
    // Get key value and TTL in a pipeline to avoid race conditions
    const pipeline = redisClient.pipeline();
    pipeline.get(key); // For string keys; extend with type checking for other types
    pipeline.ttl(key);
    const [getResult, ttlResult] = await pipeline.exec();

    if (getResult[0]) throw getResult[0]; // Get error
    if (ttlResult[0]) throw ttlResult[0]; // TTL error

    const value = getResult[1];
    const ttl = ttlResult[1];

    if (value === null) {
      await logger.info(`Skipping expired/missing key: ${key}`);
      return;
    }

    // Set key in Dragonfly with original TTL
    const setPipeline = dragonflyClient.pipeline();
    setPipeline.set(key, value);
    if (ttl > 0) setPipeline.expire(key, ttl);
    const setResult = await setPipeline.exec();

    if (setResult[0][0]) throw setResult[0][0]; // Set error
    if (setResult[1] && setResult[1][0]) throw setResult[1][0]; // Expire error

    await logger.info(`Migrated key: ${key} (TTL: ${ttl}s)`);
  } catch (err) {
    await logger.error(`Failed to migrate key ${key}: ${err.message}`);
  }
}

// Main migration loop using SCAN to avoid blocking Redis
async function runMigration() {
  let cursor = "0";
  let totalKeys = 0;
  const batchSize = parseInt(options.batchSize, 10);

  await logger.info(`Starting migration from Redis ${options.redisHost}:${options.redisPort} to Dragonfly ${options.dragonflyHost}:${options.dragonflyPort}`);

  do {
    try {
      // Scan for keys with current cursor
      const [newCursor, keys] = await redisClient.scan(cursor, "COUNT", batchSize);
      cursor = newCursor;
      totalKeys += keys.length;

      await logger.info(`Scanned ${keys.length} keys (total: ${totalKeys}), cursor: ${cursor}`);

      // Migrate keys in parallel (limit concurrency to 10 to avoid overload)
      const batches = [];
      for (let i = 0; i < keys.length; i += 10) {
        batches.push(keys.slice(i, i + 10).map(migrateKey));
      }
      await Promise.all(batches.flat());

    } catch (err) {
      await logger.error(`Scan error at cursor ${cursor}: ${err.message}`);
      await new Promise(resolve => setTimeout(resolve, 1000)); // Retry after 1s
    }
  } while (cursor !== "0");

  await logger.info(`Migration complete. Total keys migrated: ${totalKeys}`);
}

// Run migration and handle cleanup
runMigration()
  .then(() => {
    redisClient.disconnect();
    dragonflyClient.disconnect();
    process.exit(0);
  })
  .catch(async (err) => {
    await logger.error(`Migration failed: ${err.message}`);
    redisClient.disconnect();
    dragonflyClient.disconnect();
    process.exit(1);
  });

# Dragonfly 1.20 launch command for 128-core instance
./dragonfly --thread=96 --cache_mode=true --maxmemory=200GB --redis_port=6379

# Memcached 1.6 launch command with binary protocol enabled
memcached -d -p 11211 -u memcache -m 200000 -c 1000 -B binary

# Redis 8 config snippet for simple KV caching
io-threads 8
io-threads-do-reads yes
maxmemory 200GB
maxmemory-policy allkeys-lru
appendonly no
lua-replicate-commands no