Qingming-g64-ntt-cuda: RTX4090-24G results for native Goldilocks/G64 STARK-LDE NTT

zk-s[nt]arks
1

I am releasing a CUDA / RTX4090-24G result report for native Goldilocks/G64 STARK-LDE NTT.

Repository:

https://github.com/uulong950/qingming-g64-ntt-cuda

This is the CUDA-side follow-up to my previous qingming-g64-ntt work on AMD HIP / ROCm.

The purpose of this release is to report reproducible RTX4090-24G results with clear interface definitions, validation checks, and supported-size boundaries.

Status

status,RTX4090-24G,implemented_and_validated
status,A100-40G,todo
field,native_Goldilocks_G64
modulus,0xffffffff00000001
generator,7
lde_factor,8

The current RTX4090-24G release reports two interfaces:

qingming_fast:
  input  = device-native tiled input
  output = mapped output

qingming_standard:
  input  = natural-order input
  output = standard materialized output

Both interfaces are validated from domain_logn = 20 to domain_logn = 30.

domain_logn = 31 is capacity-gated on RTX4090-24G.

domain_logn >= 32 is outside the current supported range.

Workload

The workload is native Goldilocks/G64 NTT for STARK-style LDE.

field      = Goldilocks / G64
modulus    = 2^64 - 2^32 + 1
generator  = 7
lde_factor = 8

The reported LDE relation is:

logical_logn = 17..28
domain_logn  = logical_logn + 3

So the common STARK-LDE point is:

logical_logn = 24
lde_factor   = 8
domain_logn  = 27

Independent validation

I performed an independent fresh clone from GitHub, rebuilt the artifact on RTX4090-24G, and reran the validation suite.

The validation confirms:

self_test,pass
gpu_cpu_check,pass
radix512_check,pass
qingming_fast,domain_logn20_to_30,pass
qingming_standard,domain_logn20_to_30,pass
domain_logn31,capacity_gated_on_rtx4090_24g

This release therefore reports domain_logn = 20..30 as validated on RTX4090-24G for both the fast and standard interfaces.

RTX4090-24G interface results

domain_logn qingming_fast median ms qingming_fast GB/s qingming_standard median ms qingming_standard GB/s status
20 0.2427 153.62 0.2806 132.88 pass
21 0.3400 230.30 0.4096 191.15 pass
22 0.5183 316.52 0.6800 241.25 pass
23 0.7720 444.28 1.2534 273.66 pass
24 1.2329 580.61 2.2958 311.80 pass
25 2.3142 644.41 4.6806 318.61 pass
26 4.5804 677.22 16.8243 184.37 pass
27 9.1535 703.82 38.1430 168.90 pass
28 22.7062 588.48 79.8986 167.24 pass
29 48.9042 565.98 164.1800 168.59 pass
30 96.9032 590.96 325.8757 175.73 pass
31 NA NA NA NA capacity gated
domain_logn qingming_standard median ms p95 ms throughput status
20 0.2775 0.2775 134.35 GB/s pass
21 0.4055 0.4055 193.08 GB/s pass
22 0.6697 0.6697 244.95 GB/s pass
23 1.2452 1.2452 275.46 GB/s pass
24 2.2825 2.2835 313.62 GB/s pass
25 4.6070 4.6100 323.71 GB/s pass
26 16.5057 16.5151 187.93 GB/s pass
27 38.0937 38.1102 169.12 GB/s pass
28 79.9314 79.9324 167.17 GB/s pass
29 164.7667 165.5450 167.99 GB/s pass
30 323.5491 325.0944 176.99 GB/s pass
31 NA NA NA capacity gated

Standard-interface direct results

The standard interface includes natural-order input handling and standard materialized output.

domain_logn qingming_standard median ms p95 ms throughput status
20 0.2775 0.2775 134.35 GB/s pass
21 0.4055 0.4055 193.08 GB/s pass
22 0.6697 0.6697 244.95 GB/s pass
23 1.2452 1.2452 275.46 GB/s pass
24 2.2825 2.2835 313.62 GB/s pass
25 4.6070 4.6100 323.71 GB/s pass
26 16.5057 16.5151 187.93 GB/s pass
27 38.0937 38.1102 169.12 GB/s pass
28 79.9314 79.9324 167.17 GB/s pass
29 164.7667 165.5450 167.99 GB/s pass
30 323.5491 325.0944 176.99 GB/s pass
31 NA NA NA capacity gated

Main reported point

For the common LDE-8 point:

logical_logn = 24
domain_logn  = 27

the RTX4090-24G fresh-clone result is:

qingming_fast:
  median_ms  = 9.1535
  throughput = 703.82 GB/s

qingming_standard:
  median_ms  = 38.1430
  throughput = 168.90 GB/s

The direct standard-interface pipeline result at domain_logn = 27 is:

qingming_standard:
  median_ms  = 38.0937
  p95_ms     = 38.1102
  throughput = 169.12 GB/s

Boundary

The reported RTX4090-24G boundary is:

domain_logn20_to_30,validated
domain_logn31,capacity_gated_on_RTX4090_24G
domain_logn32_and_above,outside_current_supported_range

Release note

This release is intended to provide a reliable CUDA / RTX4090-24G result set for native Goldilocks/G64 STARK-LDE NTT.

The repository includes the benchmark outputs and validation files used for this report.

1 Like
2

Cool!

Why did you choose CUDA though? IIUC you’re working in Rust[1], so you could have used the wgpu crate which maintains compatibility with WebAssembly and makes your project usable in web apps, MetaMask snaps, Electron.js clients, etc.

I’m working on my own zkSTARK engine, it only runs on the CPU at the moment but GPU proving via wgpu is planned. I definitely want to target the aforementioned prospective use cases.

  1. GitHub - uulong950/qingming-zkp: qingming-zkp · GitHub ↩︎

3

Thanks, this is a very good point.

For me, language or platform is not the main constraint. I care more about the underlying math. I see this work as mapping the same geometric / algebraic idea onto different hardware platforms.

I also like low-level specs and lint-style discipline, so languages such as C++, Rust, CUDA, etc. are tools for me. I choose the tool that helps break the current performance boundary and makes the capability easier to move downward into real systems.

Your wgpu suggestion is very interesting. I will seriously consider it later, especially as a portability layer for WebAssembly, web apps, Electron, and wallet-side proving. If this direction is explored, I would like to think about it not just as a translation layer, but as another algebraic-geometry optimization problem, with CPU/GPU cooperation where needed.

If you have very concrete performance scenarios or target workloads for wgpu proving, I would be happy to hear them.