What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
A Redis Cluster can have far more capacity than one client can use. In a September 2026 benchmark of a 48-shard cluster, a normal cluster-mode memtier client delivered 4.6 million operations per second; dedicated, fully pipelined clients—one per shard—reached 39.8 million ops/s at 91% server CPU. Those are results from one workload, not general Redis performance guarantees. The gap came down to how effectively the client routed commands and kept each shard supplied with work.
What the 4.6M-versus-40M comparison actually measures
Sunny Sahijwani reported the comparison in a 4 September 2026 article about a 48-shard Redis Cluster. The detailed high-throughput run reached 39.8M ops/s; the article also uses 40.6M in its introduction and image caption. “About 40M” is the fairest shorthand. In the detailed run, server CPU was 91%.
As an Amazon Associate I earn from qualifying purchases.
The comparison is not a claim that Redis always delivers 40M ops/s, or that any application should expect a ninefold gain from changing clients. It describes the same cluster and hardware under a particular heavily pipelined benchmark, driven first by a cluster-mode client and then by dedicated per-shard clients. The author says the benchmark harness and raw data are public, but the figures have not been independently reproduced here.
Recommended Free Tools
How a client can bottleneck an underused cluster
Redis Cluster clients map keys to hash slots and send commands directly to the node that owns each slot; ordinary commands are not forwarded by one Redis node to another. That means the client has real work to do: maintain routing information, decide where each command belongs, and keep connections to the relevant nodes productive. See the Redis Cluster specification.
#1 Best Overall
In Sahijwani’s initial read-heavy test, a pipeline depth of 16 produced 2.65M ops/s on 24 shards and 2.66M on 48. The article reports server CPU at about 16% while load-generator threads were pinned near 100%. Adding client threads reduced observed throughput from 4.3M to 3.0M ops/s. The author interpreted this pattern as client-side saturation and lock contention: more shards did not help when the load generator could not feed them efficiently.
This is a useful diagnostic pattern, not proof by itself. If client CPU is saturated while Redis nodes are mostly idle and throughput plateaus as shards are added, investigate client routing, contention, connection use, and workload generation before assuming the Redis servers need more capacity.
Rank #2
Why a configured pipeline depth may not reach each shard
Pipelining sends several commands without waiting for each reply, reducing repeated network round trips and socket I/O overhead. Redis describes the technique in its benchmark guidance, while warning that the server queues replies and consumes memory; use bounded batches rather than letting pending responses grow without limit.
The key distinction is between a batch’s configured depth and the effective batch depth sent to each destination. In the reported example, 16 random-key commands were distributed across multiple shard connections. Each connection therefore received only part of the batch, leaving shallow pipelines despite the nominal depth of 16. A workload with many destination nodes can fragment batches this way.
What changed in the faster benchmark run
The author changed how the workload fed the cluster: he used hash-tagged keys directed to slot ranges and ran one dedicated client process per shard. This allowed deeper pipelines for each shard rather than making a single cluster-mode process route a mixed stream of random keys. The reported 48-client run reached 39.8M ops/s at 91% server CPU.
For context, the same article reports 474,000 ops/s for one standalone shard pinned to one core at 100% CPU. That single-shard figure does not predict total cluster throughput: the benchmark’s multi-shard result depended on driving each shard effectively, and the author’s rough per-core extrapolation is not a cluster-capacity guarantee.
This setup demonstrates a way to expose available capacity in that benchmark; it is not automatically a production recommendation. Hash tags co-locate keys in a slot, which can enable multi-key operations that require keys to share a slot, but concentrating too much application traffic or data on a limited set of slots can undermine distribution. Choose key placement based on the application’s access patterns and correctness requirements, not just a benchmark target. Redis explains hash slots and hash tags in its cluster scaling documentation.
Free tools Windows power users keep installed
One-click scans. No signup required.
How to diagnose a client-side throughput ceiling
- Measure client and server CPU together. A plateau with hot load-generator threads and lightly used Redis nodes points toward client capacity or contention as a possibility; compare CPU use per client and per shard.
- Check where commands are routed. Confirm that the client’s slot map and node connections behave as expected, and inspect how requests are distributed across shards.
- Measure effective pipeline depth per node. Do not infer it from a global pipeline setting. Determine how many commands each destination connection actually receives before replies are awaited.
- Test the real key distribution. Random keys, skewed keys, and deliberately co-located hash-tagged keys create different routing and shard-load patterns. A benchmark should reflect the production pattern relevant to the decision.
- Increase concurrency carefully. More threads or processes can help feed nodes in some designs, but the reported test also saw throughput fall when client threads were added. Watch for contention rather than assuming concurrency always helps.
- Track latency and queued replies as well as ops/s. Larger batches can improve throughput while increasing response buffering and latency. Use bounded pipelines and assess the tail latency the application can tolerate.
Client libraries can coordinate pipelines, but behavior matters
Some libraries provide cluster-pipeline support that groups commands by destination node. The redis-py advanced features documentation says cluster-pipeline commands are grouped by node and executed in parallel. The ioredis documentation describes automatic per-node pipelining and reports a 35%–50% improvement in its own benchmarks; that is a project-reported result for its benchmarks, not an independent or universal estimate.
Best Value
When evaluating a client, look at its slot routing and map refresh behavior, whether it builds pipelines per node, whether requests to different nodes run concurrently, and how it behaves under your key distribution. Measure client CPU, per-shard utilization, effective batch depth, throughput, and latency in the workload you actually need. The cited results do not establish one client as universally fastest.
Throughput tuning does not change Redis Cluster’s consistency model
Redis Cluster replication is asynchronous by default. Under specified failover or partition conditions, writes that were acknowledged can be lost. The cluster specification and scaling documentation describe these constraints. The WAIT command can reduce the likelihood of write loss, but it does not provide strong consistency. Faster routing and pipelining improve how the benchmark drives Redis; they do not strengthen its replication guarantees.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
