NVIDIA GQE Reference Architecture Runs TPC-H on GB200 in 9 Seconds

NVIDIA published a reference architecture called GQE, or GPU Query Engine, that executes SQL queries on GPUs using cuDF and other CUDA-X libraries including nvCOMP, CCCL, and nvSHMEM. The design separates query, data, and execution layers, accepts Substrait query plans, and transfers columnar row groups from CPU memory to GPU memory on demand. On a single GB200 GPU in a GB200 NVL4 server, GQE completed all 22 TPC-H queries in 9.0 seconds, a 7.5x aggregate speedup over DuckDB running on dual-socket AMD Turin CPUs. Filter pruning reduced data movement by 31% and delivered a 1.43x end-to-end speedup on TPC-H at 1 TB scale.

Three Layers for GPU Execution

The query layer adds a SQL parser and optimizer, and natively accepts Substrait plans, an open-source query plan format. This lets an existing database export its query plan and run it in GQE to evaluate GPU execution benefits. Apache DataFusion can transform a SQL string into a Substrait plan, which GQE consumes as an optimized logical plan, adds its own refinements, and turns into a physical plan.

The data layer abstracts storage into pluggable readers that handle GPU memory, CPU memory, and disk. The high-performance in-memory table format assumes data sits in CPU memory, and GQE transfers chunks to the GPU on demand to keep the GPU saturated without storing the full dataset in device memory. When a chunk arrives, the execution layer takes over.

The execution layer turns the physical plan into a task graph that defines the schedule. Relational operators built on cuDF run as optimized CUDA C++ code. Because data arrives in chunks, GQE decomposes operators and executes tasks on those chunks concurrently as pipelined CUDA streams.

Transfer Pipeline and Compression

The data layer horizontally splits tables into row groups, each containing columns stored as non-contiguous partitions. During transfer, the storage layer converts partitions into cuDF columns, hiding compression and pruning details from the executor.

A pipelined transfer has four stages. A host thread schedules the memory range, allocates a destination buffer, and invokes CUDA methods. The GPU performs the host-to-device transfer, then decompresses the data, and finally CUDA kernels compute the query. These stages overlap so the query runtime ideally equals the longest stage.

GQE compresses datasets with GPU-optimized formats. The nvCOMP library provides standard and GPU-optimized compression formats, and can wrap CPU libraries like lz4hc. The Blackwell Decompression Engine decompresses LZ77-based formats such as LZ4, Snappy, and Deflate without using streaming multiprocessor resources. On a single Blackwell B200 GPU, the DE reaches up to 400 GB/s in database applications. At a 4x compression ratio, it achieves roughly 400 GB/s effective host-to-device throughput while leaving 100 GB/s of C2C bandwidth available for other data.

GQE uses a hybrid compression approach. It attempts both LZ4 and Cascaded, a format that chains delta encoding, run-length encoding, and bit-packing. Cascaded compresses at approximately 500 GB/s on B200, so trying the extra algorithm adds little overhead. Two heuristics decide the choice: each algorithm has a compression ratio threshold, and Cascaded must achieve a higher ratio than LZ4, by a configurable multiple, to be selected. The choice balances C2C bandwidth, the Decompression Engine, and SM resources.

Pruning with Zone Maps

Before transferring data, GQE applies filter pruning to skip partitions that cannot contribute to the query result. Zone maps store minimum and maximum values for every column in each fixed-size partition, with a default of 10 million rows per partition. This metadata lives as cuDF tables in GPU memory so pruning does not become a bottleneck. Computing zone maps adds about 1% to the initial Parquet load time and happens only once, not during query execution.

During task graph construction, GQE transforms query predicates into comparisons against zone maps. Partitions that cannot contribute are skipped before transfer, reducing data movement. The open-source reference architecture is available for data platforms to apply these design and optimization techniques.