On a 48-physical-core server, the answer depends as much on client routing as on the database engine. In an independent September 2026 test, one Dragonfly process delivered 15.5 million operations per second, while Redis Cluster and Valkey Cluster driven by a conventional cluster client reached only about 4.5–4.6 million. The same clusters reached roughly 40 million operations per second when each shard had a dedicated client. Dragonfly therefore led the realistic one-process-versus-normal-client comparison, but Redis and Valkey exposed a much higher ceiling when the client architecture was redesigned to keep every shard busy.
Those are not interchangeable scores. They came from different deployment models on the same 48-core host, with different client behavior, and the fully driven cluster results were single-run observations. The useful question is not simply “Which is fastest?” but “Which throughput and latency profile can your application achieve without unacceptable routing and operational complexity?”
| # | Preview | Product | Price | |
|---|---|---|---|---|
| 1 |
|
Redis in Action | $35.97 | Buy on Amazon |
| 2 |
|
Redis in Action Introduction and Python Integration | $18.00 | Buy on Amazon |
| 3 |
|
Redis with AI: A Complete Beginner's Guide to Redis, Caching, Real-Time Systems, and AI-Powered Data... | $18.00 | Buy on Amazon |
| 4 |
|
Grails in Action | $39.66 | Buy on Amazon |
| 5 |
|
Spring in Action, Fourth Edition: Covers Spring 4 | $19.99 | Buy on Amazon |
As an Amazon Associate I earn from qualifying purchases.
The 48-core result at a glance
The most comparable figures come from Sunny Sahijwani’s Two Techies benchmark, published September 4, 2026. It tested Redis 8.2.8, Valkey 8.1.9 and Dragonfly v1.40.1 on an AWS c7i.metal-24xl with 48 physical Sapphire Rapids cores and 192 GB of RAM. A separate, over-provisioned client ran in the same availability zone and placement group. The server was pre-populated, durability was disabled for every engine, and the workload was deliberately read-heavy.
Quick wins for a faster PC:
Clear out junk files and repair common Windows errorsFree Scan →Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Repair Windows errors before they cause bigger problemsFix Now →| Configuration | Throughput | p50 latency | p99 latency | p99.9 latency | Bytes per key |
|---|---|---|---|---|---|
| Redis Cluster, dedicated client per shard | 40.6M ops/s | 0.56 ms | 1.51 ms | 4.64 ms | 165.3 |
| Valkey Cluster, dedicated clients driving shards | 40.2M ops/s | 0.57 ms | 1.32 ms | 3.50 ms | 168.7 |
| Dragonfly, one process | 15.5M ops/s | 0.88 ms | 2.42 ms | 3.33 ms | 146.1 |
| Redis Cluster, conventional cluster-mode client | 4.6M ops/s | 83.97 ms | 138.24 ms | 150.53 ms | 165.3 |
| Valkey Cluster, conventional cluster-mode client | 4.5M ops/s | 85.76 ms | 140.80 ms | 157.70 ms | 168.7 |
Most values in the table are medians of two repetitions. The 40.6M Redis and 40.2M Valkey readings were each captured once, so their exact values deserve less confidence than the two-run medians. Latency is measured at the client, not only inside the server. The unusually large tails for the conventional-client rows primarily reflect client-side queuing and under-driven shards.
#1 Best Overall
What the independent test actually measured
Hardware and placement
The server was bare metal rather than a virtual machine, reducing uncertainty from hypervisor scheduling and CPU pinning. It used all 48 physical Sapphire Rapids cores in the c7i.metal-24xl host. The load generator ran on a separate over-provisioned c7i.24xlarge in us-east-1, in the same placement group and availability zone. The benchmark author says the runs were verified to be server-bound and that every read hit a pre-populated key.
Workload
The principal comparison used a 1:10 SET-to-GET ratio, 100-byte values and pipeline depth 16. It represents a cache-like, read-heavy workload, not a universal database profile. Changing the write percentage, payload size, command mix, pipeline depth, persistence mode, eviction policy or hit rate can change the ranking. Because durability was disabled, these numbers should not be treated as write-ahead-log or crash-safe production figures.
How to read “fully driven”
In the first cluster runs, one normal cluster-mode client spent enough CPU on request routing and connection management that the server shards were only about 16 percent busy. The benchmark then used dedicated clients for individual shards. That arrangement pushed the clusters to approximately 40 million operations per second. It is a different client architecture, not a hidden server setting that can be applied to the conventional-client rows.
Do these 3 things before closing this tab:
1Scan for outdated or missing drivers - takes under a minute2Repair Windows errors before they cause bigger problems3Fix the driver behind crashes, sound loss and screen glitchesThe benchmark author frames the methodology as: “Same machine. Same cores. Same goal: saturate the node. That’s apples to apples.” That is his description of the experiment, not a formal industry standard. It does, however, make the client bottleneck visible instead of silently presenting the under-driven cluster result as a database limit.
Why a single process can beat a cluster in the practical test
Redis and Valkey clusters spread work over multiple server processes and shards. That design can use many cores, but it also requires the client to discover slot ownership, maintain connections and distribute requests evenly. A single load generator may become CPU-bound before the servers do. Once that happens, measured throughput and client-side latency describe the routing layer as much as the database.
Dragonfly’s one-process result avoids the inter-process sharding step in this test. Requests arrive at one endpoint, and the engine can schedule work across the host’s cores internally. That is why its 15.5M-operations-per-second result is higher than the 4.5–4.6M readings from the normal-client cluster configurations, even though the clusters can process far more when every shard receives a dedicated stream of work.
There is no contradiction between the two observations. The realistic-client rows answer, “What happens when one conventional cluster client drives the deployment?” The fully driven rows answer, “What is the measured ceiling when the client is engineered not to starve shards?” A production architecture must specify which answer it can actually reproduce.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Scaling from four to 48 cores
The benchmark’s scaling curve is more informative than a single maximum. Dragonfly rose from 2.0M operations per second at four cores to its 48-core result. Redis and Valkey with a conventional client flattened near 5M operations per second as additional cores were added, indicating that the client path became the limiting resource. With dedicated per-shard clients, both cluster curves continued upward toward the approximately 40M ceiling.
The author reports that Dragonfly passed the realistic-client cluster result at about 16 cores. That crossover is a deployment observation, not a law of the engines: a faster client, different connection count or another workload could move it. It does show why “scale to 48 cores” is incomplete without a client plan. If your application cannot run multiple shard-aware workers or otherwise keep every shard busy, adding server cores may produce little benefit for Redis or Valkey.
Latency and memory are part of the result
Client-side latency
Dragonfly’s one-process row shows sub-millisecond median latency and a 2.42 ms p99 in this test. The dedicated-client cluster rows have slightly lower medians and p99 values, but their p99.9 tails differ: Redis reaches 4.64 ms, while Valkey reaches 3.50 ms. The conventional-client rows show p99 values above 138 ms and p99.9 values above 150 ms. Those tails should not be interpreted as the intrinsic command execution time of idle Redis or Valkey shards; the report attributes them mainly to requests waiting in the client-side routing and queueing path.
Bytes per key
The table reports 146.1 bytes per key for Dragonfly, compared with 165.3 for Redis and 168.7 for Valkey under this workload. These are benchmark measurements for the specified key and value format, not a general memory-efficiency guarantee. Allocator behavior, key length, data structures, fragmentation, replication and persistence can all change memory consumption.
Dragonfly’s separate 48-vCPU Valkey comparison
Dragonfly published a different experiment on Google Cloud C4 instances with 16, 32 and 48 vCPUs. It used Linux kernel 6.8, Dragonfly v1.26.1, Valkey 8.0.2 and Dragonfly’s internally developed dfly_bench. The load generator ran on a larger machine, and thread and connection counts were adjusted for each server type and instance size.
Rank #4
For its mixed SET/GET test, the run lasted 20 minutes, used 64-byte values and selected parameters intended to keep p99 latency below 0.5 ms. Dragonfly reports 2.4 times Valkey’s throughput at 16 vCPUs and 4.5 times at 48 vCPUs. Those ratios are vendor-reported results from a different cloud host, engine versions, load tool and tuning strategy; they should not be merged numerically with the independent AWS table.
A separate ZADD experiment added 256 score/value pairs to a sorted set per command. Dragonfly reports 29 times Valkey’s throughput at 48 vCPUs. The same publication reports 12.6 KiB per sorted-set entry for Dragonfly versus 23.1 KiB for Valkey, described as a 45 percent reduction. Because the command shape and data structure differ from the mixed cache workload, this is evidence about that sorted-set test rather than a universal memory ratio.
In the mixed test at 32 vCPUs, Dragonfly’s page reports 17 GiB of memory for 198 million items, while Valkey used 24.5 GiB for 177 million items. The item counts were different because write throughput differed, so the figures are not a controlled equal-cardinality memory comparison.
Windows Errors? Fix Them Before They Spread
Repair common Windows errors and clear accumulated junk for a smoother, more stable PC - no reinstall needed.Free scan · no reinstallCrashes, No Sound, or Screen Glitches?
Random freezes, missing sound and display glitches usually trace back to one bad driver. Find and replace yours safely.Free scan · under a minuteWhat Redis’s counter-benchmark changes
Redis has published a separate response arguing that comparing one Redis process with one multithreaded Dragonfly process does not represent Redis’s clustered deployment model. Its experiment used a 40-primary-shard Redis 7.0 cluster on an AWS c6gn.16xlarge with 64 vCPUs. Redis reports 18–40 percent greater throughput than Dragonfly, depending on operation and pipeline depth.
Best Value
The Redis appendix says the 40-shard configuration left 24 vCPUs spare and that adding more shards did not improve the measured result. This is meaningful counter-evidence to any claim that Dragonfly always wins, but it is not a matched 48-core rerun: the host has 64 vCPUs, the engine version and workload differ, and the comparison is vendor-authored. It demonstrates that a carefully provisioned, heavily sharded Redis deployment can outperform Dragonfly under some conditions.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Valkey’s official benchmark context
Valkey’s performance dashboard uses valkey-perf-benchmark on an AWS c8g.metal-48xl. Its published method tests pipeline depths of 1 and 10, I/O thread counts of 1 and 9, and 512-byte values. Interrupt requests are pinned away from server CPUs, and client and server are placed on separate NUMA nodes to reduce last-level-cache contention.
Those controls are useful when tuning Valkey, but the dashboard is not the same experiment as either the Two Techies comparison or Dragonfly’s GCP test. Pipeline depth, value size, NUMA placement and I/O-thread settings materially affect throughput, so numbers from these sources should remain separate.
Choosing an engine for a 48-core deployment
Choose a single-process design when operational simplicity dominates
- You want one endpoint and one process to schedule work across a large machine.
- Your team cannot dedicate CPU and connections to per-shard client workers.
- You value predictable client-side latency more than the highest theoretical aggregate throughput.
- Your workload resembles the read-heavy, pipelined cache test and you can validate Dragonfly with your own persistence and eviction requirements.
Dragonfly’s independent result makes it a strong candidate for this evaluation path, but the 15.5M figure is not a promise for every command or durability mode.
Choose clustered Redis or Valkey when you can engineer the client path
- You already operate shard-aware clients, connection pools or multiple load-generating workers.
- Your workload needs horizontal partitioning, independent shard failure domains or established cluster tooling.
- You can monitor shard balance and reserve CPU for routing, connection management and failover.
- You are prepared to validate cross-key operations and cluster-specific behavior alongside raw throughput.
The fully driven measurements show why this effort can be worthwhile: dedicated per-shard clients exposed a ceiling several times higher than the conventional-client result. Reaching it requires proving that your application, not just a synthetic benchmark, keeps every shard busy.
A fair test plan for your workload
- Fix the hardware description. Record physical and logical core counts, CPU model, NUMA topology, memory size, bare-metal or virtualized status, and cloud instance type. Do not compare a 48-core bare-metal result with a 64-vCPU virtual-machine result as if they were one scale.
- Pin exact software versions. Record the Dragonfly, Redis or Valkey build, operating-system kernel, allocator, persistence settings, eviction policy, shard count, thread count and I/O-thread configuration.
- Define the data set. State key length, value size, command mix, keyspace cardinality, hit rate and whether the data set is pre-populated. Include sorted-set member counts when testing ZADD or other compound commands.
- Specify the client topology. Test a normal cluster-mode client separately from a design with one client or worker per shard. Record client CPU usage, connection count, routing mode and whether requests are pipelined.
- Measure the same duration and warm-up. Keep run length, warm-up period and background activity constant. Report whether each number is a median, average, maximum or one repetition.
- Capture throughput and tail latency together. Record operations per second, p50, p99 and p99.9 at the client. A higher throughput number with an overloaded client or unacceptable tail is not an automatic production win.
- Verify the bottleneck. Watch server CPU by shard, client CPU, network throughput, queue depth and NUMA effects. If shards are idle while the client is saturated, redesign the client before concluding that the engine has plateaued.
- Repeat before drawing a ranking. Run at least two repetitions for each configuration and flag single-run ceilings. Keep independent benchmark sessions separate when hardware, software or workload changes.
Common ways benchmark conclusions go wrong
- Comparing one process with one cluster without naming the client. A cluster can look slow when its shards are simply under-driven.
- Mixing vendor and independent ratios. Dragonfly’s GCP multipliers, Redis’s 64-vCPU counter-test and the 48-core AWS table answer different questions.
- Ignoring pipeline depth. Pipeline 16 in the independent test, pipeline 1 or 10 in Valkey’s dashboard and other depths in Redis’s appendix are not equivalent.
- Treating a cache benchmark as a durability benchmark. Durability was disabled in the 48-core comparison.
- Using throughput without tail latency. The conventional-client cluster rows show how queueing can inflate p99 and p99.9 even when the server itself is capable of more work.
- Generalizing memory numbers. Bytes per key and sorted-set memory depend on data structure, allocator, key size, item count and fragmentation.
- Assuming more shards always help. Redis’s counter-test reported no gain after 40 primary shards and retained spare vCPUs, showing that partitioning has a practical limit for a given workload.
Bottom line for 48 real cores
The strongest defensible conclusion is conditional. In the independent 48-physical-core AWS test, Dragonfly provided the better result for a single process and for a conventional client-driven comparison, while Redis and Valkey delivered the highest measured aggregate throughput only after dedicated per-shard clients removed the routing bottleneck. Dragonfly’s vendor test and Redis’s separate counter-benchmark point in opposite directions because they use different hardware, versions, workloads and tuning.
For a buying or migration decision, reproduce both client arrangements with your commands, payloads, persistence requirements and latency targets. Select Dragonfly when one-process simplicity and practical client latency fit the workload. Select Redis or Valkey when your team can operate a properly driven cluster and needs the scale or ecosystem benefits that justify shard-aware routing. There is no single 48-core winner independent of deployment design.
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.
