TL;DR
Get the latest gadgets delivered free with Prime
- Fast, free delivery on millions of items
- Prime Video, Amazon Music and more included
- Member-only deals all year
PivotLake reports that a simple single-core GROUP BY query over ClickBench’s 99-million-row hits dataset took 3.6 seconds on a repeat run. Its performance-counter measurements attributed 50.1% of measured CPU slots to memory stalls and 16.1% to retiring operations, illustrating how memory latency can limit database work even when CPU use appears high.
PivotLake has published a database benchmark in which a single-core GROUP BY query over a 99-million-row dataset took 3.6 seconds on a repeat run, while performance counters attributed 50.1% of measured CPU slots to memory stalls. The result supports the company’s argument that a database can appear CPU-bound while its processor spends much of its time waiting for data from memory.
The test used ClickBench’s hits dataset, containing 99 million rows, to count records grouped by UserID. The author says the data contained about 17 million unique UserIDs. A deliberately simple implementation used a growing hash table, creating an entry for each distinct key. The query took 3.9 seconds initially and 3.6 seconds on the next run; the author focused on the repeat because the data was already in the operating system’s page cache, avoiding disk reads for that run.
The benchmark ran on a bare-metal server with an AMD EPYC 9124 Genoa processor, 16 cores and 128 GB of DDR5 memory. The query was restricted to one core because the test implementation was not parallelized. PivotLake says it chose bare metal to access hardware performance counters unavailable on the cloud machines it considered. Those choices describe this specific test, not a general comparison of database systems or hardware.
Using Linux’s perf stat with AMD-specific metrics, the author reported 50.1% for backend memory stalls and 16.1% for retiring operations during the measured run. In the report’s interpretation, the first figure indicates time when the processor could not make progress because data was unavailable, while the second represents slots in which operations were completed. These counters and their interpretation come from the company’s report; the article does not provide an independently reproduced measurement.
Why Memory Stalls Matter
The benchmark highlights a limitation of treating CPU utilization as a direct measure of useful computation. Operating-system CPU accounting can show that a processor is busy with a task, but that alone does not reveal how often the processor is stalled while waiting for memory. A query may therefore consume a core without using its execution capacity efficiently.
For database operators, that distinction can change where performance work should focus. If a workload repeatedly accesses data scattered across a large hash table, improvements to query logic, data layout, or access locality may matter more than adding processor speed. The report’s test is a concrete illustration, not proof that memory is the dominant bottleneck in every database workload: the observed effect depends on the query, data, implementation and hardware.
The figures may also help explain why two systems reporting similar CPU utilization can deliver different throughput. Understanding whether time is spent retiring operations, waiting on memory, or doing other work gives engineers more detail than a single utilization percentage. The reported 50.1% and 16.1% values should be read as measurements from this test’s selected counters, rather than universal measures of database efficiency.
Products Worth Considering
Samsung Galaxy Tab S10 FE 128GB Wi-Fi Android Tablet, Blue
Apple Watch Series 12 GPS 46mm
DJI Osmo Mobile 8 Gimbal with Mic Mini Transmitter, Infinity Black
As an affiliate, we earn on qualifying purchases.
The Test Behind the Claim
Modern processors use multiple levels of cache to keep frequently needed data close to the execution cores. PivotLake’s report gives approximate access times of about 1 nanosecond for L1 cache, 3–4 nanoseconds for L2, 10–15 nanoseconds for L3 and 50–100 nanoseconds for DRAM. These are broad estimates in the source, not measurements taken from the benchmark machine. The central point is that a miss in cache can leave a processor waiting much longer than an operation performed on data already nearby.
The example focuses on a GROUP BY aggregation, a common database operation that combines rows sharing a key. A hash table is a straightforward way to track each group, but with millions of distinct keys its entries may occupy a large working set. Accessing those entries can be less cache-friendly than repeatedly working on a small set of nearby values. The report strips down PivotLake’s query engine to a simple count-per-key loop to make that pattern easier to examine.
PivotLake frames the exercise as an investigation of its own engine rather than a head-to-head product test. It does not compare the result with other databases, alternative aggregation algorithms, or the same query on multiple processors. The benchmark is consequently useful as a demonstration of one possible bottleneck, but it cannot establish how much faster a redesigned implementation would be or how typical the measured result is.
““50.1%” backend_bound_memory”
— PivotLake blog report
Limits of the Benchmark Evidence
The report does not include an independent reproduction, a comparison with other database engines, or a test of alternative GROUP BY designs. It also does not show results across multiple runs beyond the initial 3.9-second and repeat 3.6-second timings. The source excerpt ends while introducing another statistic, so no further counter results are available here.
It is not clear how representative this query is of PivotLake customers’ workloads, how the reported counters vary with different data distributions, or how much of the measured time reflects the particular hash-table implementation. The source also does not provide a publication date. The figures should be understood as the company’s reported observations from one machine and one single-core test, not as independently verified or broadly generalizable performance claims.
What Further Tests Could Show
The report presents the measurements as a way to identify where processor time goes, but it does not specify a follow-up experiment or publish a revised implementation’s results. A clearer assessment would require comparable tests of alternative aggregation strategies, repeated runs, and results across different data sizes and key distributions. Publishing the full counter data and measurement procedure would also help other engineers reproduce the findings.
For readers evaluating database performance, the immediate practical takeaway is to look beyond a CPU utilization percentage. Hardware counters can help distinguish memory stalls from completed operations, but their readings need to be interpreted alongside the query plan, workload and system configuration. Whether reducing memory stalls would improve a particular production query remains to be tested on that workload.
Key Questions
What did the benchmark measure?
It measured a single-core GROUP BY query counting rows by UserID across ClickBench’s 99-million-row hits dataset. PivotLake reports a 3.9-second first run and a 3.6-second repeat run.
What does the 50.1% memory-stall figure mean?
PivotLake says its selected performance counter classified 50.1% of measured CPU slots as backend-bound on memory. The report interprets this as time when the processor could not make progress while waiting for data; it is a counter result from this test, not a figure for all database queries.
Why might a GROUP BY query stall on memory?
The tested implementation used a growing hash table with entries for roughly 17 million distinct UserIDs. Accessing a large set of entries can involve frequent cache misses, which may require fetching data from slower main memory.
Does the report show that PivotLake is faster than other databases?
No. The report describes a test of a simplified PivotLake implementation and does not compare its timings with other database products or alternative aggregation methods.
What remains unverified?
The source does not provide an independent reproduction or enough comparisons to establish how typical the result is. It also does not show whether another query design, data distribution, or hardware setup would produce the same stall measurements.
Source: pivotlake.io
