gpu-unlock-ada 能否使 Ada 张量算力翻倍？

同一块待核验的 Ada 显卡，分别安装默认驱动与 gpu-unlock-ada 补丁，运行同一种 FP16 矩阵乘法和同一个实际模型，同时记录相同规格下的理论上限、实测吞吐、单批延迟、功耗及数值误差。若吞吐从 X 增加到 2X，准确表述应是“这条张量路径在该环境下接近翻倍”，而不是“所有 AI 任务都快了一倍”。

关键在于核验默认环境与补丁环境是否采用相同精度、累加方式和执行路径。Turing 已引入面向机器学习的 Tensor Core，Ada 的公开架构更新也包含新的 Tensor Core，但这些架构背景不能直接证明 gpu-unlock-ada 的实际收益。目前热榜材料只将项目概括为“Ada 显卡张量算力翻倍解锁”，没有提供完整 README、源码差异、支持白名单或原始跑分日志。因此，“翻倍”应被视作一个需要代码与同机 A/B 数据共同验证的命题。

补丁究竟修改了哪条张量路径

讨论“翻倍”之前，需要先区分三个容易混用的口径：

尤其是精度口径不能混写。FP16、BF16、FP8、TF32 是不同路径；FP16 使用 FP16 累加和 FP32 累加，也不是同一条路径。整数 TOPS、FP8 吞吐和 FP16 TFLOPS 不能横向比较，稀疏峰值也不能与密集吞吐直接相除。所谓“翻倍”，至少要满足前后使用相同输入形状、相同数据类型、相同累加方式，并且只改变驱动暴露的路径。

项目究竟改了什么，应该按 README、提交记录和源码差异逐层确认：

gh search repos gpu-unlock-ada --limit 10
git clone https://github.com/OWNER/gpu-unlock-ada.git
git -C gpu-unlock-ada log --oneline --decorate -n 20
git -C gpu-unlock-ada show --stat --oneline HEAD
git -C gpu-unlock-ada diff HEAD^..HEAD -- .
git -C gpu-unlock-ada ls-files | grep -Ei '(Kbuild|DKMS|\.ko$|\.patch$|\.bin$|cuda|benchmark|test)'

如果变更涉及 NVIDIA 内核模块、Kbuild 或 DKMS 源码，它属于驱动或内核模块层；如果修改的是 libcuda.so 一类用户态库，则属于运行时层；如果仓库只增加 Python、CUDA 或测试程序，最多证明一种测试方法，不能据此宣称已经解锁硬件能力。

vgpu_unlock 解决的是消费级 GPU 的 vGPU 虚拟化能力；资料中的 tinygrad 补丁示例则涉及 ReBAR 与 BAR1 P2P。它们可以帮助理解社区修改 NVIDIA 驱动的思路，但不能替代 gpu-unlock-ada 自身的代码证据。

Ada 环境的兼容性如何核验

“同属 Ada”只是候选条件，不是正式兼容结论。GeForce RTX 40 系列可以列为待核验候选，RTX 6000 Ada 也应单独列为候选，不能从前者的白名单推断后者可用。

环境信息可以一次采齐：

uname -r
. /etc/os-release && printf '%s\n' "$PRETTY_NAME"
cat /proc/driver/nvidia/version
modinfo -F filename nvidia
sha256sum "$(modinfo -F filename nvidia)"
nvidia-smi --query-gpu=name,uuid,driver_version,power.limit --format=csv
python - <<'PY'
import torch
print("torch", torch.__version__)
print("cuda", torch.version.cuda)
print("gpu", torch.cuda.get_device_name(0))
PY

安装应被视为驱动修改：先备份模块和 DKMS 源码，确认 Secure Boot 与模块签名要求，并保留重启回滚路径；同类项目的补丁不能替代这些检查。

怎样测出而不是假定翻倍

A/B 测试应使用同一块显卡、同一套输入、相同框架与版本。固定批量、精度、累加路径、功耗上限、时钟策略和温度条件，先预热，再重复采样。第一步测可控的矩阵乘法，第二步换成实际模型；后者应使用真实输入或至少固定合成数据，避免磁盘和网络读取污染结果。

除了吞吐，还要同时记录单步或单批延迟、平均及 P95 延迟、功耗、温度和时钟，并用固定输入比较输出的最大绝对误差与相对误差。框架是否真的进入目标 Tensor Core 路径，可以通过项目日志或 Nsight Compute 的指令与张量管线指标确认，不能只看函数名。

下面的脚本同时测试 FP16 GEMM 和 ResNet-50 训练、推理。模型权重随机初始化，因此无需下载数据集；它测的是实际模型计算负载，不代表具体业务模型的最终收益。

cat > /tmp/ada_ab.py <<'PY'
import json
import os
import time

import torch
import torchvision
from torchvision.models import resnet50

run = os.environ.get("ADA_RUN", "run")
torch.manual_seed(0)
torch.backends.cuda.matmul.allow_tf32 = False
torch.backends.cudnn.allow_tf32 = False
torch.backends.cuda.matmul.allow_fp16_reduced_precision_reduction = False

if hasattr(torch.backends.cuda.matmul, "allow_fp16_accumulation"):
    torch.backends.cuda.matmul.allow_fp16_accumulation = False

def average_seconds(fn, warmup, iterations):
    for _ in range(warmup):
        fn()
    torch.cuda.synchronize()
    start = time.perf_counter()
    for _ in range(iterations):
        fn()
    torch.cuda.synchronize()
    return (time.perf_counter() - start) / iterations

M = N = K = 8192
a = torch.randn((M, K), device="cuda", dtype=torch.float16)
b = torch.randn((K, N), device="cuda", dtype=torch.float16)

gemm_seconds = average_seconds(lambda: torch.mm(a, b), 20, 200)
gemm_tflops = 2 * M * N * K / gemm_seconds / 1e12
c = torch.mm(a, b)
torch.save(c[:256, :256].float().cpu(), f"/tmp/gemm-{run}.pt")
del a, b, c

batch = 16
model = resnet50(weights=None).cuda().train()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)
x = torch.randn(batch, 3, 224, 224, device="cuda")
target = torch.randint(0, 1000, (batch,), device="cuda")

def train_step():
    optimizer.zero_grad(set_to_none=True)
    with torch.autocast("cuda", dtype=torch.float16):
        loss = torch.nn.functional.cross_entropy(model(x), target)
    loss.backward()
    optimizer.step()
    return loss

train_seconds = average_seconds(train_step, 10, 50)
model.eval()

def infer():
    with torch.inference_mode(), torch.autocast("cuda", dtype=torch.float16):
        return model(x)

infer_seconds = average_seconds(infer, 10, 30)
latencies = []
for _ in range(30):
    start = torch.cuda.Event(enable_timing=True)
    end = torch.cuda.Event(enable_timing=True)
    start.record()
    infer()
    end.record()
    torch.cuda.synchronize()
    latencies.append(start.elapsed_time(end))
latencies.sort()
prediction = infer()
torch.save(prediction[:16].float().cpu(), f"/tmp/pred-{run}.pt")

print(json.dumps({
    "gpu": torch.cuda.get_device_name(0),
    "torch": torch.__version__,
    "cuda": torch.version.cuda,
    "gemm_tflops": gemm_tflops,
    "train_ms_step": train_seconds * 1000,
    "train_images_s": batch / train_seconds,
    "infer_ms_batch": infer_seconds * 1000,
    "infer_p95_ms": latencies[int(0.95 * (len(latencies) - 1))],
    "infer_images_s": batch / infer_seconds,
    "loss": loss.item()
}))
PY

默认环境先运行并记录功耗：

nvidia-smi --query-gpu=timestamp,power.draw,temperature.gpu,clocks.sm --format=csv -lms 200 -f baseline-power.csv

ADA_RUN=baseline python /tmp/ada_ab.py | tee baseline.json

切换到补丁模块并重启后，以相同方式复测：

nvidia-smi --query-gpu=timestamp,power.draw,temperature.gpu,clocks.sm --format=csv -lms 200 -f patched-power.csv

ADA_RUN=patched python /tmp/ada_ab.py | tee patched.json

最终结果应由下面这条命令直接生成，而不是引用厂商理论峰值：

python - <<'PY'
import csv
import json
import torch

baseline = json.load(open("baseline.json", encoding="utf-8"))
patched = json.load(open("patched.json", encoding="utf-8"))

def average_power(path):
    values = []
    with open(path, encoding="utf-8") as stream:
        for row in csv.reader(stream):
            if len(row) > 1:
                try:
                    values.append(float(row[1].strip().split()[0]))
                except ValueError:
                    pass
    return sum(values) / len(values) if values else float("nan")

def compare_tensor(prefix):
    before = torch.load(f"/tmp/{prefix}-baseline.pt", map_location="cpu")
    after = torch.load(f"/tmp/{prefix}-patched.pt", map_location="cpu")
    difference = (before - after).abs()
    relative_l2 = difference.norm() / before.norm().clamp_min(1e-12)
    print(f"{prefix}: max_abs={difference.max().item():.6g}, relative_l2={relative_l2.item():.6g}")

print(f"GPU: {baseline['gpu']}")
print(f"GEMM: {baseline['gemm_tflops']:.2f} -> {patched['gemm_tflops']:.2f} TFLOPS, speedup={patched['gemm_tflops'] / baseline['gemm_tflops']:.3f}x")
print(f"Train: {baseline['train_ms_step']:.3f} -> {patched['train_ms_step']:.3f} ms/step, speedup={baseline['train_images_s'] / patched['train_images_s']:.3f}x")
print(f"Inference P95: {baseline['infer_p95_ms']:.3f} -> {patched['infer_p95_ms']:.3f} ms/batch")
print(f"Average power: {average_power('baseline-power.csv'):.2f} -> {average_power('patched-power.csv'):.2f} W")
compare_tensor("gemm")
compare_tensor("pred")
PY

如果微基准接近翻倍，而训练或推理提升有限，应检查数据搬运、同步等待、非张量算子和批量大小，而不是继续扩大“GPU 算力翻倍”的结论；小型任务还可能主要受 CPU 与 GPU 之间 PCIe 传输开销限制。截至现有材料，能够确认的是 Ada Tensor Core 的架构前提；项目具体解锁路径、正式兼容白名单和真实性能倍数仍应以仓库差异及上述最终输出为准。