TL;DR
Get business pricing on monitors, keyboards and dev gear
- Business-only prices and quantity discounts
- Tax-exempt purchasing
- Multiple users, one account, clear invoices
PivotLake’s engineering report argues that database CPU readings can obscure a memory bottleneck. In its single-core test of a GROUP BY query over ClickBench’s 99 million-row hits dataset, the second run took 3.6 seconds; performance counters attributed 50.1% of measured CPU slots to memory stalls and 16.1% to retiring operations.
PivotLake has published a database benchmark arguing that high CPU utilization can hide time spent waiting on memory: its single-core GROUP BY test over 99 million ClickBench rows took 3.6 seconds on a repeated run, while the company’s performance-counter readings attributed 50.1% of CPU slots to memory stalls. The test illustrates why database performance investigations may need to examine memory access, not just the CPU utilization percentage.
The test used a deliberately simplified aggregation that counted rows for each UserID with a growing hash table. PivotLake said the dataset contained about 17 million unique IDs, so the aggregation maintained a large number of distinct entries. The report describes this as a way to expose the costs of repeatedly accessing data that may not fit in the processor’s small, fast caches.
On a bare-metal server with an AMD EPYC 9124 Genoa processor, 16 cores and 128 GB of DDR5 memory, the first query took 3.9 seconds and a subsequent run took 3.6 seconds. The company focused on the repeat because, it said, the data was then in the operating system’s page cache and the run did not involve disk reads. The benchmark was restricted to one core because the simplified aggregation could not run across multiple cores.
Using Linux performance counters, PivotLake reported that 50.1% of measured CPU slots were classified as backend-bound on memory, while 16.1% were retiring operations—the report’s measure of the processor completing work. These figures describe the counter results for this particular test, not a general measurement of database workloads or a direct measure of total time spent idle.
Why Database CPU Can Mislead
CPU utilization is often treated as a quick indication of how hard a database is working. PivotLake’s test highlights a limitation: a processor can have work scheduled while making little progress on useful instructions if it is waiting for data. A dashboard showing high CPU use may therefore coexist with a workload constrained by memory latency, particularly when an operation repeatedly looks up entries in a large data structure.
For database teams, the practical point is diagnostic rather than a claim that one optimization will solve every slow query. A high-cardinality aggregation may have very different performance characteristics from one whose working set fits more readily in cache. Examining hardware performance counters alongside query timing can help distinguish those cases, although the report’s benchmark alone does not establish how common this pattern is across production systems.
Popular right now
Vitamix Propel Series 510 Professional-Grade Blender, 3 Programs, Black
Shark PowerPro Reveal Plus Cordless Vacuum Cleaner, Charcoal, IZ376H
Bose QuietComfort Wireless Noise Cancelling Headphones, Sandstone
As an affiliate, we earn on qualifying purchases.
Caches and the Hash-Table Test
Processors use levels of cache to keep frequently needed data closer to their cores than main memory. PivotLake gives approximate access times of about 1 nanosecond for L1 cache and 50–100 nanoseconds for DRAM, while stressing that cache capacity is limited. The report says a modern CPU may execute roughly 4–8 instructions per nanosecond; those figures are approximate illustrations, not measurements from the benchmark itself.
The test’s aggregation uses a hash table keyed by UserID. For each row, it looks up the corresponding count or creates an entry, then increments that count. With millions of distinct keys, the table becomes large, and many lookups may miss the small caches and require slower memory access. The report presents this as a demonstration of a possible bottleneck, not a comparison against a fully optimized PivotLake engine or competing database products.
““The answer is usually memory.””
— PivotLake report
Limits of the Benchmark Results
The supplied report excerpt does not provide the full set of measurements: it ends as the author begins to introduce another statistic. It also does not include enough detail to independently assess the full benchmark setup, the exact counter methodology, run-to-run variation or how results change with different data distributions, processors and database implementations.
The reported 50.1% memory-stall figure should not be read as proof that half of all database CPU time is generally lost to memory latency. It is a counter result for one query, one dataset, one server and a deliberately simplified, single-core aggregation. The report does not quantify how much faster an optimized implementation would be or establish that memory latency is the only factor affecting query time.
Further Measurements Needed
The report’s next step, as indicated in the supplied excerpt, was to examine another performance statistic; that portion of the material is missing. No follow-up test or publication date is specified. Readers seeking to evaluate the result will need the complete report and any additional measurements it contains.
More comparisons—such as tests across different numbers of unique keys, aggregation strategies and processor configurations—would help show when memory stalls dominate and whether changes to data layout or cache use improve performance. Until such results are available, the benchmark is best treated as a focused illustration of one database bottleneck rather than a general performance ranking.
Key Questions
What did PivotLake test?
It ran a single-core GROUP BY UserID aggregation over the 99-million-row ClickBench hits dataset, using a simplified hash-table counter.
How long did the query take?
The report says the first run took 3.9 seconds and a repeat took 3.6 seconds. PivotLake focused on the repeat, saying the data was already in the operating system’s page cache.
What do the 50.1% and 16.1% figures mean?
They are reported performance-counter measurements for this test: 50.1% backend-bound on memory and 16.1% retiring operations. They are not universal rates for databases or all CPU workloads.
Does the report show that every slow database query is memory-bound?
No. It presents one benchmark to illustrate how memory latency can constrain a particular high-cardinality aggregation. The supplied material does not establish how often this occurs in other queries or systems.
Source: pivotlake.io
