ClickHouse on NVIDIA Vera: How a 352-Thread CPU Scales Filters, Aggregations and Joins
An unmodified ClickHouse binary scales almost linearly to Vera's 176 physical cores on CPU-heavy queries. Past that, SMT adds little, and a simple LIKE filter runs out of memory bandwidth at 64 threads.

ClickHouse ran its standard binary, with no Vera-specific changes, on an early-access server built on NVIDIA’s upcoming Vera CPU, and it went straight to the top of the ClickBench hardware leaderboard by a wide margin [1]. The more useful part of the write-up is what came next: three micro-benchmarks that show where a 352-thread machine stops scaling. A simple substring filter runs out of memory bandwidth at 64 threads. CPU-heavy filters, aggregations and joins scale almost perfectly up to the 176 physical cores, and then gain little from the second hardware thread on each core.
Why it matters
More cores only help if the database can keep them busy. For data and AI engineers sizing analytics on many-core Arm servers, the benchmarks give a clear rule of thumb: cheap, scan-heavy queries are limited by memory bandwidth, and compute-heavy queries are limited by physical cores, not hardware threads. That shapes procurement (memory channels and DRAM capacity matter as much as core count) and capacity planning (count physical cores, not threads).
It also matters for agent workloads. ClickHouse notes that agent-generated queries are more ad hoc, arrive in bursts and often run in parallel as agents spawn sub-agents [1:1]. That is exactly the kind of load that needs a database to spread work across every core.
The hardware
Each Vera CPU has 88 NVIDIA Olympus cores, fully compatible with Arm v9.2. A two-socket system has 176 cores and 352 hardware threads through NVIDIA Spatial Multithreading. Each core has 96 kB/64 kB of L1 data/instruction cache and 2 MB of L2, with 164 MB of shared L3. Maximum memory bandwidth is 1.0 to 1.2 TB/s, depending on how much DRAM is installed [1:2].
How the test was set up
To keep disk out of the picture, the test table lived entirely in ClickHouse’s Memory engine: one column of 62.5 billion random strings of 5 to 10 ASCII characters, exactly 1 TB, stored uncompressed [1:3]. Because ClickHouse’s query layer is decoupled from storage, the author argues the results carry over to a regular MergeTree table, assuming enough storage bandwidth [1:4]. Each query was run with max_threads from 1 up to 352.
What happened
A simple LIKE filter hits the memory wall. WHERE s LIKE '%ab%' sped up 41x at 64 threads, reading 813 GB/s. At 256 threads it reached only 45x, at about 900 GB/s, close to the machine’s physical memory bandwidth. The cores were processing data faster than DRAM could deliver it [1:5].
A regular-expression filter scales almost linearly. Swapping in a costly regex made the query CPU-bound. It reached 163x at 176 threads (93% efficiency), 216x at 256 and 228x at 352, where efficiency fell to 65% [1:6]. Past 176 threads, extra work lands on logical rather than physical cores, and SMT typically adds only 10 to 30% on compute-bound work [1:7].
Low-cardinality aggregation stops at the physical cores. A GROUP BY on the first character (255 groups) with a SipHash sum reached 164x at 176 threads and 180x at both 256 and 352 [1:8]. ClickHouse calls low-cardinality grouping, such as grouping by hour, far more common in practice than million-group aggregations [1:9].
Joins follow the same curve. Joining the 1 TB table to a 625,000-row dimension table reached 155x at 176 threads and 186x at both 256 and 352. The join used ClickHouse’s parallel_hash algorithm, which builds the hash table with all threads, plus a runtime filter to speed up probing [1:10].
How it works
EXPLAIN PIPELINE shows the approach: ClickHouse splits the table into 352 equal virtual chunks and runs the filter and aggregation steps on all of them at once, then merges the partial results [1:11]. For aggregation, each stream builds its own hash table and the tables are merged at the end [1:12].
SIMD adds a second, independent layer of speed. With multithreading turned off, a single-thread integer filter over 2.5 billion rows took 0.42 seconds. With compiler auto-vectorization disabled in the comparison loop, it took 1.48 seconds, 3.5x slower. Vectorized, ClickHouse uses Vera’s 128-bit NEON instructions to compare four 32-bit integers at once. Support for Vera’s SVE2 instructions is being added with the open-source community [1:13].
What data and AI engineers should do
- Find out which wall your queries hit. Divide the data scanned by query time. If throughput is near the platform’s memory bandwidth, more threads will not help; better compression, smaller columns or less data scanned will.
- Plan on physical cores. For CPU-heavy filters, aggregations and joins, expect near-linear scaling up to the physical core count and only modest gains from SMT beyond it.
- Remember the storage assumption. These numbers come from an in-memory table. On MergeTree, ClickHouse reads data in granules of 8,192 rows by default [2], and storage bandwidth may become the limit before the CPU does.
- Watch for the follow-up. ClickHouse has promised a post on how it analyzes, optimizes and tests query performance at scale [1:14].
Limitations and open questions
These are vendor-run micro-benchmarks on one early-access machine, using synthetic strings in memory. They do not show behavior with many concurrent queries, high-cardinality aggregations, compressed MergeTree data on object storage, or mixed workloads. The post also does not compare Vera with other servers on these three tests; the cross-platform comparison is ClickBench [1:15]. Treat the curves as a guide to where bottlenecks sit, not as a forecast for your workload.
Key takeaways
- An unmodified ClickHouse binary topped the ClickBench hardware leaderboard on NVIDIA Vera. [1:16]
- A simple LIKE filter stops scaling at about 64 threads because it saturates memory bandwidth (813 to 900 GB/s). [1:17]
- CPU-heavy filters, aggregations and joins scale almost linearly to 176 physical cores; SMT adds little beyond that. [1:18]
- SIMD alone made a single-thread filter 3.5x faster, and SVE2 support is on the way. [1:19]
Sources
ClickHouse Blog, “Running ClickHouse on NVIDIA Vera CPU: Is your favorite database up to the challenge?”, 2026-10-21. https://clickhouse.com/blog/clickhouse-performance-on-nvidia-vera ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎
ClickHouse Documentation, “MergeTree table engine”. https://clickhouse.com/docs/reference/engines/table-engines/mergetree-family/mergetree ↩︎
Discussion
Join the discussion: create a free account or sign in to comment.
No comments yet.