Measurements

What has been measured for TNet v1, with the conditions of every figure. These results describe the listed devices and configurations only; they are not guarantees for other hardware, drivers or settings. Raw data is kept outside the repositories; the research notes record the source hashes and environments.

GPU attempts (research benchmark)

One attempt of 65,536 rows through the eight layers, measured with the research benchmark tnet_bench.cu using cuBLAS int8 GEMM, requantization as a separate pass and no fused epilogue.

The RTX 3090 is 1.83× faster per ticket than the CMP 50HX. From coarse board-power sampling (1 s), the RTX 3090 used about 52 µJ per ticket.

Sources: tnet-v2, tnet-ampere-v1.

Mining software (CPPminer)

CPPminer replaces cuBLAS with built-in CUTLASS int8 tensor-core kernels, so it needs no extra libraries.

The RTX 3090 figure above comes from the research benchmark, not from CPPminer. CPPminer's kernel for Ampere and newer has not yet been benchmarked against cuBLAS; its correctness is checked against the CPU at every start.

Sources: CPPminer TNet guide, v0.5-fork.10 release notes.

Batching

Rows are independent, so a miner may use any batch size, but small batches waste tensor-core throughput.

• Mining one row at a time costs 42–45× more per ticket on the CMP 50HX and 51× more on the RTX 3090.
• On the RTX 3090, a batch of 256 rows costs 1.6× more per ticket than a full batch.

CPU verification

Verifying a block recomputes one row through the eight layers with the epoch weights already prepared. All figures on an AMD Ryzen 7 8745HS laptop processor, release builds, median of 7.

Once per epoch every node derives the 512 MiB of weights (5.0 s single-threaded, parallelisable) and transposes them (2.1 s). In the running node a whole block, including transactions, verifies in about 0.1 s.

Sources: SPEC.md §9, tnet-v2.

Bit-exact parity

• GPU-found tickets were recomputed byte for byte by the Rust reference on both architectures: on the CMP 50HX (nonce 0, row 255, piece 23) with 15 leading zero bits; on the RTX 3090 (0, 1751, 18) and (1, 6693, 12), also checked with the Requant node's tnet check.
• Both architectures produced identical statistics of the last layer: 0.73% zeros, 2.08% saturated values, mean |x| of 43.45.
• CPPminer's kernels match the Rust reference byte for byte on Turing and Ampere.
• Frozen test vectors cover rows 0, 1, 255 and 65535 at the real parameters, and a small instance checked independently in Python.

Lottery fairness

Tickets are hashes, so the number of winning tickets should follow the expected count.

Robustness: no cheap approximation

Measured with a NumPy probe on uniform int8 weights (8 rows), not the consensus derivation.

One error spreads. A single ±1 error after layer 1 changes this share of values in later layers:

Approximations fail.

• Dropping the 64 smallest terms of the last layer leaves only 25.8% of pieces exact; dropping 512 leaves none.
• Using int7 weights leaves no piece exact.
• Skipping exact zeros (0.7% of terms) is the only free saving, and tensor cores cannot exploit it: structured sparsity needs 50%.

Precomputation is bounded, not measured. Per-value lookup tables would need 64 GiB per layer at n = 8192 for no saving. Bit-plane lookup tables are 9–12× slower than tensor cores at group size 8 and 4–6× at group size 16 on the measured GPU, from arithmetic throughput alone; in silicon they trade an int8 multiplier for at least 128× the weight storage and bandwidth. No lookup-table kernel has been written yet (open questions).

Source: tnet-v2.

Earlier candidates, for comparison