import { config } from '#app/config.server.ts';
import { Batch, GlideClient } from '@valkey/valkey-glide';
import Redis from 'ioredis';
import { createClient, createClientPool } from 'redis';
/**
* Benchmarks Redis vs Valkey client performance.
*
* Run with:
* ```
* node --expose-gc --import tsx app/bin/benchmark-redis.ts
* ```
*/
const maybeGc = () => {
if (global.gc) {
global.gc();
}
};
const parseRedisUrl = (
url: string,
): {
host: string;
port: number;
} => {
const parsed = new URL(url);
return {
host: parsed.hostname,
port: parsed.port ? Number(parsed.port) : 6_379,
};
};
type BenchmarkResult = {
avgMs: number;
maxMs: number;
minMs: number;
name: string;
opsPerSec: number;
totalMs: number;
};
const runBenchmark = async (
name: string,
iterations: number,
fn: () => Promise<void>,
): Promise<BenchmarkResult> => {
const times: number[] = [];
// Warmup
for (let i = 0; i < Math.min(100, iterations / 10); i++) {
await fn();
}
const start = performance.now();
for (let i = 0; i < iterations; i++) {
const iterStart = performance.now();
await fn();
times.push(performance.now() - iterStart);
}
const totalMs = performance.now() - start;
return {
avgMs: times.reduce((a, b) => a + b, 0) / times.length,
maxMs: Math.max(...times),
minMs: Math.min(...times),
name,
opsPerSec: Math.round((iterations / totalMs) * 1_000),
totalMs,
};
};
const formatResult = (result: BenchmarkResult): string => {
return `${result.name}: ${result.opsPerSec.toLocaleString()} ops/sec (avg: ${result.avgMs.toFixed(3)}ms, min: ${result.minMs.toFixed(3)}ms, max: ${result.maxMs.toFixed(3)}ms)`;
};
const main = async () => {
const { host, port } = parseRedisUrl(config.REDIS_DSN);
console.log(`Connecting to Redis at ${host}:${port}\n`);
// Initialize clients
const ioredisClient = new Redis({ host, port });
const ioredisAutoPipelineClient = new Redis({
enableAutoPipelining: true,
host,
port,
});
const redisClient = createClient({ url: `redis://${host}:${port}` });
await redisClient.connect();
const redisResp3Client = createClient({
RESP: 3,
url: `redis://${host}:${port}`,
});
await redisResp3Client.connect();
const redisPoolClient = createClientPool(
{ url: `redis://${host}:${port}` },
{ maximum: 5, minimum: 5 },
);
await redisPoolClient.connect();
const glideClient = await GlideClient.createClient({
addresses: [{ host, port }],
clientName: 'benchmark',
});
const iterations = 10_000;
const testKey = 'benchmark:string';
const hashKey = 'benchmark:hash';
const counterKey = 'benchmark:counter';
const pipelineKeyPrefix = 'benchmark:pipeline';
const concurrentKeyPrefix = 'benchmark:concurrent';
const testValue = 'hello world';
const largeValue = 'x'.repeat(10_000);
console.log(
`Running benchmarks with ${iterations.toLocaleString()} iterations each\n`,
);
// ===================
// SEQUENTIAL BENCHMARKS
// These run one operation at a time - tests raw client overhead
// ===================
maybeGc();
// SET benchmarks
console.log('=== SET (sequential) ===');
console.log(
formatResult(
await runBenchmark('ioredis', iterations, async () => {
await ioredisClient.set(testKey, testValue);
}),
),
);
console.log(
formatResult(
await runBenchmark('redis', iterations, async () => {
await redisClient.set(testKey, testValue);
}),
),
);
console.log(
formatResult(
await runBenchmark('redis (RESP3)', iterations, async () => {
await redisResp3Client.set(testKey, testValue);
}),
),
);
console.log(
formatResult(
await runBenchmark('valkey-glide', iterations, async () => {
await glideClient.set(testKey, testValue);
}),
),
);
maybeGc();
// GET benchmarks
console.log('\n=== GET (sequential) ===');
console.log(
formatResult(
await runBenchmark('ioredis', iterations, async () => {
await ioredisClient.get(testKey);
}),
),
);
console.log(
formatResult(
await runBenchmark('redis', iterations, async () => {
await redisClient.get(testKey);
}),
),
);
console.log(
formatResult(
await runBenchmark('redis (RESP3)', iterations, async () => {
await redisResp3Client.get(testKey);
}),
),
);
console.log(
formatResult(
await runBenchmark('valkey-glide', iterations, async () => {
await glideClient.get(testKey);
}),
),
);
maybeGc();
// Large value SET benchmarks
console.log('\n=== SET 10KB (sequential) ===');
console.log(
formatResult(
await runBenchmark('ioredis', iterations, async () => {
await ioredisClient.set(testKey, largeValue);
}),
),
);
console.log(
formatResult(
await runBenchmark('redis', iterations, async () => {
await redisClient.set(testKey, largeValue);
}),
),
);
console.log(
formatResult(
await runBenchmark('redis (RESP3)', iterations, async () => {
await redisResp3Client.set(testKey, largeValue);
}),
),
);
console.log(
formatResult(
await runBenchmark('valkey-glide', iterations, async () => {
await glideClient.set(testKey, largeValue);
}),
),
);
maybeGc();
// Large value GET benchmarks
console.log('\n=== GET 10KB (sequential) ===');
console.log(
formatResult(
await runBenchmark('ioredis', iterations, async () => {
await ioredisClient.get(testKey);
}),
),
);
console.log(
formatResult(
await runBenchmark('redis', iterations, async () => {
await redisClient.get(testKey);
}),
),
);
console.log(
formatResult(
await runBenchmark('redis (RESP3)', iterations, async () => {
await redisResp3Client.get(testKey);
}),
),
);
console.log(
formatResult(
await runBenchmark('valkey-glide', iterations, async () => {
await glideClient.get(testKey);
}),
),
);
maybeGc();
// HSET benchmarks
console.log('\n=== HSET (sequential) ===');
console.log(
formatResult(
await runBenchmark('ioredis', iterations, async () => {
await ioredisClient.hset(hashKey, 'field', testValue);
}),
),
);
console.log(
formatResult(
await runBenchmark('redis', iterations, async () => {
await redisClient.hSet(hashKey, 'field', testValue);
}),
),
);
console.log(
formatResult(
await runBenchmark('redis (RESP3)', iterations, async () => {
await redisResp3Client.hSet(hashKey, 'field', testValue);
}),
),
);
console.log(
formatResult(
await runBenchmark('valkey-glide', iterations, async () => {
await glideClient.hset(hashKey, { field: testValue });
}),
),
);
maybeGc();
// HGET benchmarks
console.log('\n=== HGET (sequential) ===');
console.log(
formatResult(
await runBenchmark('ioredis', iterations, async () => {
await ioredisClient.hget(hashKey, 'field');
}),
),
);
console.log(
formatResult(
await runBenchmark('redis', iterations, async () => {
await redisClient.hGet(hashKey, 'field');
}),
),
);
console.log(
formatResult(
await runBenchmark('redis (RESP3)', iterations, async () => {
await redisResp3Client.hGet(hashKey, 'field');
}),
),
);
console.log(
formatResult(
await runBenchmark('valkey-glide', iterations, async () => {
await glideClient.hget(hashKey, 'field');
}),
),
);
maybeGc();
// INCR benchmarks
console.log('\n=== INCR (sequential) ===');
await ioredisClient.set(counterKey, '0');
console.log(
formatResult(
await runBenchmark('ioredis', iterations, async () => {
await ioredisClient.incr(counterKey);
}),
),
);
console.log(
formatResult(
await runBenchmark('redis', iterations, async () => {
await redisClient.incr(counterKey);
}),
),
);
console.log(
formatResult(
await runBenchmark('redis (RESP3)', iterations, async () => {
await redisResp3Client.incr(counterKey);
}),
),
);
console.log(
formatResult(
await runBenchmark('valkey-glide', iterations, async () => {
await glideClient.incr(counterKey);
}),
),
);
// ===================
// PIPELINE/TRANSACTION BENCHMARKS
// Valkey GLIDE 2.0 uses Batch class:
// - Batch(true) = atomic (Transaction with MULTI/EXEC)
// - Batch(false) = non-atomic (Pipeline)
// ===================
maybeGc();
const pipelineSize = 100;
const pipelineIterations = iterations / pipelineSize;
console.log(
`\n=== Pipeline/Transaction (${pipelineSize} SETs per batch) ===`,
);
// ioredis pipeline - batches without atomicity
console.log(
formatResult(
await runBenchmark(
'ioredis pipeline (no atomicity)',
pipelineIterations,
async () => {
const pipeline = ioredisClient.pipeline();
for (let i = 0; i < pipelineSize; i++) {
pipeline.set(`${pipelineKeyPrefix}:${i}`, testValue);
}
await pipeline.exec();
},
),
),
);
// ioredis multi - transaction with atomicity (for fair comparison with redis)
console.log(
formatResult(
await runBenchmark(
'ioredis multi (atomic)',
pipelineIterations,
async () => {
const multi = ioredisClient.multi();
for (let i = 0; i < pipelineSize; i++) {
multi.set(`${pipelineKeyPrefix}:${i}`, testValue);
}
await multi.exec();
},
),
),
);
// redis multi - transaction with atomicity
console.log(
formatResult(
await runBenchmark(
'redis multi (atomic)',
pipelineIterations,
async () => {
const multi = redisClient.multi();
for (let i = 0; i < pipelineSize; i++) {
multi.set(`${pipelineKeyPrefix}:${i}`, testValue);
}
await multi.exec();
},
),
),
);
// redis RESP3 multi - transaction with atomicity
console.log(
formatResult(
await runBenchmark(
'redis (RESP3) multi (atomic)',
pipelineIterations,
async () => {
const multi = redisResp3Client.multi();
for (let i = 0; i < pipelineSize; i++) {
multi.set(`${pipelineKeyPrefix}:${i}`, testValue);
}
await multi.exec();
},
),
),
);
// valkey-glide Batch (non-atomic / pipeline mode)
console.log(
formatResult(
await runBenchmark(
'valkey-glide batch (pipeline, no atomicity)',
pipelineIterations,
async () => {
const batch = new Batch(false); // false = non-atomic (pipeline)
for (let i = 0; i < pipelineSize; i++) {
batch.set(`${pipelineKeyPrefix}:${i}`, testValue);
}
await glideClient.exec(batch, false);
},
),
),
);
// valkey-glide Batch (atomic / transaction mode)
console.log(
formatResult(
await runBenchmark(
'valkey-glide batch (atomic)',
pipelineIterations,
async () => {
const batch = new Batch(true); // true = atomic (transaction)
for (let i = 0; i < pipelineSize; i++) {
batch.set(`${pipelineKeyPrefix}:${i}`, testValue);
}
await glideClient.exec(batch, false);
},
),
),
);
// ===================
// CONCURRENT BENCHMARKS
// Multiple operations in flight simultaneously - this is where
// auto-pipelining and connection pools provide benefits
// ===================
maybeGc();
const concurrentSize = 100;
const concurrentIterations = iterations / concurrentSize;
console.log(`\n=== Concurrent (${concurrentSize} parallel SETs) ===`);
// Single client - commands queue behind each other
console.log(
formatResult(
await runBenchmark('ioredis', concurrentIterations, async () => {
await Promise.all(
Array.from(
{ length: concurrentSize },
async (_, i) =>
await ioredisClient.set(`${concurrentKeyPrefix}:${i}`, testValue),
),
);
}),
),
);
// Auto-pipeline batches concurrent commands automatically
console.log(
formatResult(
await runBenchmark(
'ioredis (auto-pipeline)',
concurrentIterations,
async () => {
await Promise.all(
Array.from(
{ length: concurrentSize },
async (_, i) =>
await ioredisAutoPipelineClient.set(
`${concurrentKeyPrefix}:${i}`,
testValue,
),
),
);
},
),
),
);
// Single client
console.log(
formatResult(
await runBenchmark('redis', concurrentIterations, async () => {
await Promise.all(
Array.from(
{ length: concurrentSize },
async (_, i) =>
await redisClient.set(`${concurrentKeyPrefix}:${i}`, testValue),
),
);
}),
),
);
// Single client with RESP3
console.log(
formatResult(
await runBenchmark('redis (RESP3)', concurrentIterations, async () => {
await Promise.all(
Array.from(
{ length: concurrentSize },
async (_, i) =>
await redisResp3Client.set(
`${concurrentKeyPrefix}:${i}`,
testValue,
),
),
);
}),
),
);
// Pool distributes across 5 connections
console.log(
formatResult(
await runBenchmark('redis (pool)', concurrentIterations, async () => {
await Promise.all(
Array.from(
{ length: concurrentSize },
async (_, i) =>
await redisPoolClient.set(
`${concurrentKeyPrefix}:${i}`,
testValue,
),
),
);
}),
),
);
console.log(
formatResult(
await runBenchmark('valkey-glide', concurrentIterations, async () => {
await Promise.all(
Array.from({ length: concurrentSize }, (_, i) =>
glideClient.set(`${concurrentKeyPrefix}:${i}`, testValue),
),
);
}),
),
);
// Cleanup
console.log('\nCleaning up...');
await ioredisClient.del(testKey);
await ioredisClient.del(hashKey);
await ioredisClient.del(counterKey);
for (let i = 0; i < pipelineSize; i++) {
await ioredisClient.del(`${pipelineKeyPrefix}:${i}`);
}
for (let i = 0; i < concurrentSize; i++) {
await ioredisClient.del(`${concurrentKeyPrefix}:${i}`);
}
// Close connections
await ioredisClient.quit();
await ioredisAutoPipelineClient.quit();
await redisClient.quit();
await redisResp3Client.quit();
await redisPoolClient.quit();
glideClient.close();
console.log('Done!');
};
main().catch(console.error);