Download code/bench_decode.py from mkvn/quantization-cache-amplification: direct link, hf CLI and curl.
- Browser
- Download file 3.08 kB
-
https://huggingface.co/datasets/mkvn/quantization-cache-amplification/resolve/main/code/bench_decode.py
- Command line
-
hf download hf://datasets/mkvn/quantization-cache-amplification/code/bench_decode.py
-
curl -L -o bench_decode.py https://huggingface.co/datasets/mkvn/quantization-cache-amplification/resolve/main/code/bench_decode.py
3.08 kB
| """Throughput of on-GPU weight reconstruction (codebook gather) and of the | |
| online activation-side Hadamard transforms, which is what an inference engine | |
| must sustain to keep the storage stream busy. | |
| """ | |
| import json, os, sys, time | |
| import torch | |
| sys.path.insert(0, os.path.dirname(__file__)) | |
| import codec | |
| DEV = "cuda" | |
| RES = os.path.join(os.path.dirname(__file__), "..", "results") | |
| def bench_decode(stages, nweights=1 << 24, reps=20): | |
| C = torch.randn(stages, 256, codec.D_SUB, device=DEV, dtype=torch.float16) | |
| n = nweights // codec.D_SUB | |
| idx = torch.randint(0, 256, (stages, n), device=DEV, dtype=torch.uint8) | |
| scale = torch.randn(nweights // 2048, 1, device=DEV, dtype=torch.float16) | |
| def run(): | |
| acc = C[0][idx[0].long()] | |
| for s in range(1, stages): | |
| acc = acc + C[s][idx[s].long()] | |
| return (acc.view(-1, 2048) * scale).view(-1) | |
| for _ in range(3): | |
| run() | |
| torch.cuda.synchronize() | |
| t0 = time.perf_counter() | |
| for _ in range(reps): | |
| run() | |
| torch.cuda.synchronize() | |
| dt = (time.perf_counter() - t0) / reps | |
| packed = nweights * stages * codec.CB_BITS / codec.D_SUB / 8 | |
| return dict(stages=stages, bits=stages * codec.BITS_PER_STAGE, | |
| weights_per_s=nweights / dt, | |
| fp16_equiv_GBs=nweights * 2 / dt / 1e9, | |
| packed_GBs=packed / dt / 1e9) | |
| def bench_hadamard(dim=8192, batch=1, reps=200): | |
| x = torch.randn(batch, dim, device=DEV) | |
| for _ in range(3): | |
| codec._fwht(x) | |
| torch.cuda.synchronize() | |
| t0 = time.perf_counter() | |
| for _ in range(reps): | |
| codec._fwht(x) | |
| torch.cuda.synchronize() | |
| return (time.perf_counter() - t0) / reps * 1e6 # microseconds | |
| def bench_matmul(): | |
| out = {} | |
| for m, k, n in [(1, 8192, 2048), (32, 8192, 2048), (2048, 8192, 2048)]: | |
| a = torch.randn(m, k, device=DEV, dtype=torch.float16) | |
| b = torch.randn(k, n, device=DEV, dtype=torch.float16) | |
| for _ in range(3): | |
| a @ b | |
| torch.cuda.synchronize() | |
| reps = 50 | |
| t0 = time.perf_counter() | |
| for _ in range(reps): | |
| a @ b | |
| torch.cuda.synchronize() | |
| dt = (time.perf_counter() - t0) / reps | |
| out[f"{m}x{k}x{n}"] = dict(tflops=2 * m * k * n / dt / 1e12, ms=dt * 1e3) | |
| return out | |
| if __name__ == "__main__": | |
| res = {"decode": [bench_decode(s) for s in [2, 3, 4]], | |
| "hadamard_us": {str(d): bench_hadamard(d) for d in [2048, 4096, 8192]}, | |
| "matmul": bench_matmul(), | |
| "gpu": torch.cuda.get_device_name(0)} | |
| for d in res["decode"]: | |
| print(f"decode {d['bits']:.1f} bit: {d['weights_per_s']/1e9:.2f} Gweight/s " | |
| f"= {d['fp16_equiv_GBs']:.1f} GB/s fp16-equivalent, " | |
| f"{d['packed_GBs']:.2f} GB/s of packed bytes consumed") | |
| print("hadamard (us):", {k: round(v, 1) for k, v in res["hadamard_us"].items()}) | |
| for k, v in res["matmul"].items(): | |
| print(f"matmul {k}: {v['tflops']:.2f} TFLOP/s") | |
| json.dump(res, open(os.path.join(RES, "decode_bench.json"), "w"), indent=2) | |