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 on NVIDIA Vera: How a 352-Thread CPU Scales Filters, Aggregations and Joins

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


  1. 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 ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎

  2. 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.

Keep reading

ClickHouse Cloud Executable UDFs GA: Native Code, Network Access, and Query-Level Metrics
Data Engineering

ClickHouse Cloud Executable UDFs GA: Native Code, Network Access, and Query-Level Metrics

ClickHouse Cloud now supports compiled-language UDFs, outbound network access for eligible UDF runtimes, and per-query execution metrics. For LLM observability, that means token accounting and sampled quality evaluation can live closer to the data—with important resource, security, and runtime trade-offs.

Oct 14, 2026 · 14 min read
Databricks SQL Serverless Cost Governance: Budgets, Alerts, and Query-Level Attribution
Data Engineering

Databricks SQL Serverless Cost Governance: Budgets, Alerts, and Query-Level Attribution

Databricks adds budgets, billing system tables and usage dashboards to make SQL Serverless spend easier to explain. But budgets are not spending caps, estimates are not invoices, and useful attribution depends on consistent tagging and operational controls.

Oct 10, 2026 · 13 min read
Databricks Runtime Introduces NEAREST BY: Native SQL Vector Search at Scale
Data Engineering

Databricks Runtime Introduces NEAREST BY: Native SQL Vector Search at Scale

Databricks brings batch vector search into SQL with NEAREST BY, a fused Photon GEMM operator and IVF indexes stored in liquid-clustered Delta tables, reducing the need for separate vector-serving infrastructure in large-scale analytical workloads.

Oct 09, 2026 · 12 min read