import argparse, time
import numpy as np
import nvtx
import ray
import torch

ROWS, WIDTH, BATCHES = 2048, 8192, 32
LOAD_MS, ITER = 40, 9

def load_batch(batch):
    with nvtx.annotate("load_cpu"):
        time.sleep(LOAD_MS / 1000)
        return {"x": np.ones((ROWS, WIDTH), dtype=np.float32)}

import threading

class Predict:
    def __init__(self, inline, pinned=False, overlap=False):
        self.overlap = overlap
        self.tls = threading.local()
        torch.set_num_threads(1)
        torch.cuda.set_device(0)
        self.inline = inline
        self.pinned = pinned
        self.weight = torch.eye(WIDTH, device="cuda")
        if pinned:
            self.host = torch.empty((ROWS, WIDTH), dtype=torch.float32, pin_memory=True)
            self.dev = torch.empty((ROWS, WIDTH), dtype=torch.float32, device="cuda")
        _ = torch.ones((ROWS, WIDTH), device="cuda") @ self.weight
        torch.cuda.synchronize()
    def _buffers(self):
        if not hasattr(self.tls, "stream"):
            self.tls.stream = torch.cuda.Stream()
            self.tls.host = torch.empty((ROWS, WIDTH), dtype=torch.float32, pin_memory=True)
            self.tls.dev = torch.empty((ROWS, WIDTH), dtype=torch.float32, device="cuda")
        return self.tls

    def __call__(self, batch):
        if self.inline:
            batch = load_batch(batch)
        if self.overlap:
            b = self._buffers()
            with torch.cuda.stream(b.stream):
                with nvtx.annotate("stage_pinned"):
                    b.host.copy_(torch.from_numpy(batch["x"]))
                with nvtx.annotate("H2D"):
                    b.dev.copy_(b.host, non_blocking=True)
                    x = b.dev
                with torch.inference_mode(), nvtx.annotate("forward"):
                    for _ in range(ITER):
                        x = x @ self.weight
                with nvtx.annotate("D2H"):
                    out = x[:, 0].to("cpu", non_blocking=False)
            return {"out": out.numpy()}
        if self.pinned:
            with nvtx.annotate("stage_pinned"):
                self.host.copy_(torch.from_numpy(batch["x"]))
            with nvtx.annotate("H2D"):
                self.dev.copy_(self.host, non_blocking=True)
                x = self.dev
        else:
            with nvtx.annotate("H2D"):
                x = torch.tensor(batch["x"], device="cuda")
        with torch.inference_mode(), nvtx.annotate("forward"):
            for _ in range(ITER):
                x = x @ self.weight
        with nvtx.annotate("D2H"):
            return {"out": x[:, 0].cpu().numpy()}

def main():
    p = argparse.ArgumentParser()
    p.add_argument("--mode", choices=["inline", "split", "pinned", "overlap"], required=True)
    p.add_argument("--profile", action="store_true")
    args = p.parse_args()
    nsight_env = {"nsight": {"t": "cuda,nvtx", "sample": "none",
                             "cpuctxsw": "none", "stop-on-exit": "true"}}
    ray.init(address="local", num_cpus=8, num_gpus=1, include_dashboard=False)
    ds = ray.data.range(ROWS * BATCHES, override_num_blocks=BATCHES)
    if args.mode in ("split", "pinned", "overlap"):
        ds = ds.map_batches(load_batch, batch_size=ROWS, batch_format="numpy",
                            compute=ray.data.TaskPoolStrategy(size=4), num_cpus=1)
    gpu_kwargs = dict(
        batch_size=ROWS, batch_format="numpy",
        fn_constructor_args=(args.mode == "inline", args.mode == "pinned", args.mode == "overlap"),
        compute=ray.data.ActorPoolStrategy(size=1, max_tasks_in_flight_per_actor=4,
                                            enable_true_multi_threading=(args.mode == "overlap")),
        num_cpus=1, num_gpus=1, max_concurrency=2,
    )
    if args.profile:
        gpu_kwargs["runtime_env"] = nsight_env
    ds = ds.map_batches(Predict, **gpu_kwargs)
    t0 = time.perf_counter()
    r = ds.materialize()
    print(f"MODE={args.mode} E2E={time.perf_counter()-t0:.3f}s")
    for line in r.stats().splitlines():
        if "Operator" in line or "Remote wall time" in line or "Ray Data throughput" in line:
            print("  ", line.strip()[:110])
    ray.shutdown()

if __name__ == "__main__":
    main()