Repository navigation
[Success Report] RTX 3080 12GB (10DE:220A) · B450M + Ryzen 7 5700X · Windows 11 — FP32-accum half-rate removed, FP16 114 TFLOPS, 350 W / 62 °C #227
Replies: 3 comments
On windows cuda load use P2 memory freq which is slightly lower than P0 memory freq (graphic load), and can be overclocked as well. Use GUI release in https://github.com/Skyworks-Neo/nvoc/releases/tag/v0.3.1-alpha.1 by input memory OC value and shift-click its independent 'apply button' you can sync P2 OC freq to P0 |
|
This is the cleanest same-shape A/B we have for the FP32-accumulate rate limiter on GA102 12 GB — recorded in the matrix and community records. What sets it apart: 1. Explicit compute types kill the routing ambiguity. Most reports measure whatever path the framework picks (open question #15 — cuBLAS routing is invisible from outputs). Passing 2. The math checks: 936 flops/clk/SM ≈ 91% of GA102's architectural 1024 at 1.74 GHz — full rate, and the remaining ~9% is normal real-world GEMM efficiency (wave quantization, DRAM feed), not a limiter. 3. 4. Independent cross-check from our side: we run a locally shunt-modded 3080 12 GB bench, and its measured test ceiling matches your figures — so these numbers read as genuine hardware-limit extraction at a 350 W / 1.74 GHz envelope, not a measurement artifact. (Shunt mod removes the delivery-side ceiling; your card reaches the same ceiling on stock delivery, which is exactly what the report claims.) On the two follow-up comments already in the thread: the P2 memory-frequency gap (9251 vs the 9501 table max) can be closed with the nvoc GUI memory OC; and the remaining headroom above your 114 TFLOPS is the 2.1 GHz clock table (~137 TFLOPS absolute ceiling), which is gated by NVVDD OCP — the current-delivery wall documented in #201, reachable only with the shunt-mod/OCP route. Recorded: compatibility matrix |



Uh oh!
There was an error while loading. Please reload this page.
System
10DE:220A, subsystem1616:10B0, VBIOS94.02.85.00.aanvidia-smistill reportspower.limit = power.default_limit = power.max_limit = 350 Wafter the unlock.Unlock applied via this project's UEFI loader. Nothing else changed — no core/memory OC,
no VBIOS power-table mod, stock fan curve.
Result: the half-rate cap is gone
A/B on the same shape at the same time, with the compute type passed explicitly to
cuBLAS (m = n = k = 8192, SM clock averaging 1740 MHz):
CUBLAS_COMPUTE_16F)CUBLAS_COMPUTE_32F)torch.matmulon fp16 tensors (PyTorch default path)Ratio 0.971. If the FP32-accumulate rate limit were still active, row 2 would be
≈ 57 TFLOPS. At 114 TFLOPS with 70 SMs @ 1.74 GHz that is ~936 flops/clk/SM, i.e. ~91 %
of GA102's architectural 1024 flops/clk/SM — full rate, not half rate.
torch.matmullanding in the same band matters: PyTorch's default fp16 GEMM is theFP32-accumulate path, so this is what ComfyUI / SDXL / Flux actually execute, not a
synthetic-only side path.
Precision check (rules out a silent downgrade to 16F)
Platforms sometimes substitute a cheaper compute type, so I verified against a float64
reference at 2048³:
4.7× better accuracy →
COMPUTE_32Fis genuinely honored, so 111 TFLOPS is a realFP32-accumulate number.
Power / thermals (25 s sustained FP16 tensor load)
The card sits exactly on the 350 W table from the first second and never exceeds 351 W,
while temperature stays at ~62 °C with 45 % fan. On this sample the limiter is power,
not heat — and since the board only has 2× 8-pin (spec ceiling 375 W including the slot),
there is essentially no TGP headroom to gain. The unlock's value here is entirely the
issue-rate fix, not a power-table change.
Headroom estimate
Compute ceiling = SM × flops/clk/SM × clock. With 936 flops/clk/SM measured:
so raising TGP alone would only reach ~121 TFLOPS (+6 %)
This sample is therefore at ~84 % of the absolute ceiling any 3080 12 GB can reach, with
the remainder gated by the 2.1 GHz clock table rather than by the unlock.
Two things that will save you time if you replicate this
Both cost me a bogus run each:
cublasGemmExhas anldcparameter. CUDA 12/13 signature is(handle, transa, transb, m, n, k, alpha, A, Atype, lda, B, Btype, ldb, beta, C, Ctype, ldc, computeType, algo).Dropping
ldcshifts every later argument, the call returns status 7 withoutexecuting, and a timing loop will happily report nonsense (I got 6263 TFLOPS out of
an error-returning call). Always check the return code inside the timing loop.
OP_NcomputesB@A. Comparingagainst
A@Bgives a rel error of ≈ 1.414 (√2), which looks like a numerical problembut is a structural mismatch.
Gaming
No effect, as expected: RT cores and CUDA cores are untouched, and DLSS uses the
FP16-accumulate / INT8 path, which was never the capped one.
All reactions