code/bench_io.py

"""Unbuffered (page-cache-bypassing) NVMe random-read benchmark + PCIe H2D + RAM copy.

Uses Win32 CreateFileW with FILE_FLAG_NO_BUFFERING so measurements reflect true
device behaviour at MoE-expert block granularity rather than page-cache hits.
"""
import ctypes, ctypes.wintypes as wt
import json, mmap, os, random, sys, time
from concurrent.futures import ThreadPoolExecutor

GENERIC_READ = 0x80000000
GENERIC_WRITE = 0x40000000
FILE_SHARE_READ = 0x00000001
OPEN_EXISTING = 3
CREATE_ALWAYS = 2
FILE_FLAG_NO_BUFFERING = 0x20000000
FILE_FLAG_WRITE_THROUGH = 0x80000000
FILE_FLAG_RANDOM_ACCESS = 0x10000000
FILE_FLAG_SEQUENTIAL_SCAN = 0x08000000
INVALID_HANDLE = ctypes.c_void_p(-1).value

k32 = ctypes.WinDLL("kernel32", use_last_error=True)
k32.CreateFileW.restype = wt.HANDLE
k32.CreateFileW.argtypes = [wt.LPCWSTR, wt.DWORD, wt.DWORD, ctypes.c_void_p,
                            wt.DWORD, wt.DWORD, wt.HANDLE]
k32.ReadFile.argtypes = [wt.HANDLE, ctypes.c_void_p, wt.DWORD,
                         ctypes.POINTER(wt.DWORD), ctypes.c_void_p]
k32.WriteFile.argtypes = [wt.HANDLE, ctypes.c_void_p, wt.DWORD,
                          ctypes.POINTER(wt.DWORD), ctypes.c_void_p]
k32.SetFilePointerEx.argtypes = [wt.HANDLE, ctypes.c_longlong,
                                 ctypes.POINTER(ctypes.c_longlong), wt.DWORD]
k32.CloseHandle.argtypes = [wt.HANDLE]

SECTOR = 4096


def aligned_buf(nbytes):
    n = (nbytes + SECTOR - 1) // SECTOR * SECTOR
    mm = mmap.mmap(-1, n)
    ptr = ctypes.addressof(ctypes.c_char.from_buffer(mm))
    assert ptr % SECTOR == 0, "buffer not sector aligned"
    return mm, ptr


def open_unbuffered(path, write=False):
    access = (GENERIC_READ | GENERIC_WRITE) if write else GENERIC_READ
    create = CREATE_ALWAYS if write else OPEN_EXISTING
    flags = FILE_FLAG_NO_BUFFERING | (FILE_FLAG_WRITE_THROUGH if write
                                      else FILE_FLAG_RANDOM_ACCESS)
    h = k32.CreateFileW(path, access, FILE_SHARE_READ, None, create, flags, None)
    if h == INVALID_HANDLE:
        raise ctypes.WinError(ctypes.get_last_error())
    return h


def make_file(path, size_gb):
    if os.path.exists(path) and os.path.getsize(path) >= size_gb * (1 << 30):
        return
    h = open_unbuffered(path, write=True)
    chunk = 32 << 20
    mm, ptr = aligned_buf(chunk)
    mm.write(os.urandom(1 << 20) * (chunk >> 20))
    written = wt.DWORD(0)
    n = size_gb * (1 << 30) // chunk
    for i in range(n):
        if not k32.WriteFile(h, ptr, chunk, ctypes.byref(written), None):
            raise ctypes.WinError(ctypes.get_last_error())
    k32.CloseHandle(h)
    del mm


def read_worker(path, offsets, block):
    h = open_unbuffered(path)
    mm, ptr = aligned_buf(block)
    got = wt.DWORD(0)
    newpos = ctypes.c_longlong(0)
    total = 0
    for off in offsets:
        k32.SetFilePointerEx(h, ctypes.c_longlong(off), ctypes.byref(newpos), 0)
        if not k32.ReadFile(h, ptr, block, ctypes.byref(got), None):
            raise ctypes.WinError(ctypes.get_last_error())
        total += got.value
    k32.CloseHandle(h)
    del mm
    return total


def bench_random(path, fsize, block, nthreads, target_bytes=1 << 30):
    nreads = max(nthreads * 4, int(target_bytes // block))
    rng = random.Random(1234 + block + nthreads)
    maxoff = (fsize - block) // SECTOR
    offs = [rng.randrange(maxoff) * SECTOR for _ in range(nreads)]
    parts = [offs[i::nthreads] for i in range(nthreads)]
    t0 = time.perf_counter()
    with ThreadPoolExecutor(nthreads) as ex:
        tot = sum(ex.map(lambda o: read_worker(path, o, block), parts))
    dt = time.perf_counter() - t0
    return dict(block_kb=block // 1024, threads=nthreads,
                mb_s=tot / dt / 1e6, iops=nreads / dt,
                lat_ms=dt / nreads * nthreads * 1000)


def bench_sequential(path, fsize):
    h = open_unbuffered(path)
    block = 32 << 20
    mm, ptr = aligned_buf(block)
    got = wt.DWORD(0)
    n = min(64, fsize // block)
    t0 = time.perf_counter()
    for _ in range(n):
        k32.ReadFile(h, ptr, block, ctypes.byref(got), None)
    dt = time.perf_counter() - t0
    k32.CloseHandle(h)
    del mm
    return n * block / dt / 1e6


def bench_pcie():
    import torch
    if not torch.cuda.is_available():
        return {}
    out = {}
    for mb in [1, 4, 16, 64]:
        n = mb * (1 << 20)
        cpu = torch.empty(n, dtype=torch.uint8).pin_memory()
        gpu = torch.empty(n, dtype=torch.uint8, device="cuda")
        for _ in range(3):
            gpu.copy_(cpu, non_blocking=True)
        torch.cuda.synchronize()
        reps = max(5, 512 // mb)
        t0 = time.perf_counter()
        for _ in range(reps):
            gpu.copy_(cpu, non_blocking=True)
        torch.cuda.synchronize()
        dt = time.perf_counter() - t0
        out[f"h2d_{mb}MB_GBs"] = n * reps / dt / 1e9
        del gpu, cpu
        torch.cuda.empty_cache()
    return out


def bench_ram():
    import numpy as np
    a = np.empty(1 << 28, dtype=np.uint8)
    b = np.empty(1 << 28, dtype=np.uint8)
    a[:] = 7
    for _ in range(2):
        b[:] = a
    t0 = time.perf_counter()
    reps = 8
    for _ in range(reps):
        b[:] = a
    dt = time.perf_counter() - t0
    return a.nbytes * reps / dt / 1e9


if __name__ == "__main__":
    scratch = sys.argv[1]
    path = os.path.join(scratch, "iobench.bin")
    FSIZE_GB = 8
    print("creating test file...", flush=True)
    make_file(path, FSIZE_GB)
    fsize = os.path.getsize(path)
    res = {"file_gb": FSIZE_GB, "random": [], "host": {}}

    res["host"]["seq_read_mb_s"] = bench_sequential(path, fsize)
    print(f"sequential unbuffered read: {res['host']['seq_read_mb_s']:.0f} MB/s", flush=True)

    for block_kb in [64, 256, 1024, 4096, 16384]:
        for nt in [1, 2, 4, 8]:
            r = bench_random(path, fsize, block_kb * 1024, nt,
                             target_bytes=512 << 20)
            res["random"].append(r)
            print(f"  {block_kb:>6} KB x {nt} thr: {r['mb_s']:8.1f} MB/s  "
                  f"{r['iops']:8.1f} IOPS  {r['lat_ms']:.3f} ms", flush=True)

    res["host"]["ram_copy_GBs"] = bench_ram()
    print(f"RAM copy: {res['host']['ram_copy_GBs']:.2f} GB/s", flush=True)
    res["host"].update(bench_pcie())
    for k, v in res["host"].items():
        if k.startswith("h2d"):
            print(f"{k}: {v:.2f} GB/s", flush=True)

    with open(os.path.join(os.path.dirname(__file__), "..", "results",
                           "io_bench.json"), "w") as f:
        json.dump(res, f, indent=2)
    os.remove(path)
    print("saved results/io_bench.json")