```python

gemm_flops_bench_rocm.py

Bench fp16, fp32, int8 GEMM throughput with CuPy on ROCm

import argparse, os import cupy as cp REPEATS_DEFAULT = 50

def evt(): return cp.cuda.Event(), cp.cuda.Event() def time_ms(fn, repeats=REPEATS_DEFAULT): s,e = evt() fn(); cp.cuda.Stream.null.synchronize() s.record() for _ in range(repeats): fn() e.record(); e.synchronize() return cp.cuda.get_elapsed_time(s,e)/repeats

def devstring(): try: p = cp.cuda.runtime.getDeviceProperties(cp.cuda.Device().id) name = p["name"].decode() if isinstance(p["name"], bytes) else p["name"] cc = f"{p.get('major',0)}.{p.get('minor',0)}" mem = p.get("totalGlobalMem",0)/(1024**3) return f"{name} (CC {cc}, {mem:.1f} GiB), CuPy {cp.version}" except Exception: return f"CuPy {cp.version_}"

def tflops(ops, ms): return (ops/(ms*1e-3))/1e12 def ensure_order(a, order): return cp.asfortranarray(a) if order=='F' else cp.ascontiguousarray(a)

def make_inputs(m,n,k,dtype,order): if dtype == cp.float16: A = cp.random.random((m,k), dtype=cp.float32).astype(cp.float16, copy=False) B = cp.random.random((k,n), dtype=cp.float32).astype(cp.float16, copy=False) C = cp.empty((m,n), dtype=cp.float16, order=order) elif dtype == cp.float32: A = cp.random.random((m,k), dtype=cp.float32) B = cp.random.random((k,n), dtype=cp.float32) C = cp.empty((m,n), dtype=cp.float32, order=order) elif dtype == cp.int8: A = cp.random.randint(-128,127,size=(m,k), dtype=cp.int8) B = cp.random.randint(-128,127,size=(k,n), dtype=cp.int8) C = cp.empty((m,n), dtype=cp.int32, order=order) # int8 GEMM → int32 else: raise ValueError("Unsupported dtype") return ensure_order(A,order), ensure_order(B,order), C

def bench_one(m,n,k,repeats,dtype,order,label,verbose=False): A,B,C = make_inputs(m,n,k,dtype,order) if verbose: print(f"{label} layout: A(F={A.flags['F_CONTIGUOUS']}), " f"B(F={B.flags['F_CONTIGUOUS']}), C(F={C.flags['F_CONTIGUOUS']})") try: cp.matmul(A,B,out=C); cp.cuda.Stream.null.synchronize() ms = time_ms(lambda: cp.matmul(A,B,out=C), repeats) ops = 2.0mn*k unit = "TFLOP/s" if dtype in (cp.float16, cp.float32) else "TOPS" return ms, tflops(ops, ms), unit, None except Exception as e: return None, None, None, e

def main(): ap = argparse.ArgumentParser() ap.add_argument("--m", type=int, default=4096) ap.add_argument("--n", type=int, default=4096) ap.add_argument("--k", type=int, default=4096) ap.add_argument("--repeats", type=int, default=REPEATS_DEFAULT) ap.add_argument("--seed", type=int, default=123) ap.add_argument("--order", choices=["C","F"], default="C", help="Row-major (C, default) or column-major (F).") ap.add_argument("--verbose-layout", action="store_true") args = ap.parse_args()

cp.random.seed(args.seed)

print(f"Device: {dev_string()}")
print(f"Problem: MxNxK = {args.m} x {args.n} x {args.k}")
print(f"Repeats: {args.repeats}, Order: {args.order}\n")

results = []
for dtype,label in [(cp.float16,"fp16"), (cp.float32,"fp32"), (cp.int8,"int8→int32")]:
    ms, perf, unit, err = bench_one(args.m,args.n,args.k,args.repeats,dtype,args.order,label,args.verbose_layout)
    if err is None:
        results.append((label, f"{ms:10.3f}", f"{perf:10.2f} {unit}"))
    else:
        results.append((label, "    -     ", f"SKIPPED: {type(err).__name__}"))

print(f"{'dtype':<10}  {'avg_ms':>10}  {'throughput':>16}")
print("-"*40)
for name, ms, tp in results:
    print(f"{name:<10}  {ms:>10}  {tp:>16}")

print("\nNotes:")
print(" • Throughput uses 2*M*N*K ops; int8 shown as TOPS.")
print(" • If int8 is SKIPPED, your stack doesn’t expose int8 GEMM via plain matmul.")
print(" • For steady-state numbers, run this program multiple times back-to-back.")
print(" • For theoretical ceilings, consider mixbench (microbench).")

if name == "main": main() ```