File size: 3,076 Bytes
6ec9472 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 | """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)
|