workload_staged.py

"""Compare inline, split, and pinned-staged Ray Data GPU inference.

Run against the patched Ray installation on a CUDA box:
    python workload_staged.py --mode split
    python workload_staged.py --mode staged
    python workload_staged.py --mode staged --profile

E2E measures materialize(), including CPU loading, actor startup, and warmup.
Use unprofiled runs for timing and profiled runs for the CUDA/NVTX timeline.
"""

import argparse
import inspect
import time
from pathlib import Path

import numpy as np
import ray


ROWS = 2048
WIDTH = 8192
ITER = 9
GROUP = 4
BLOCK_ROWS = GROUP * ROWS
LOAD_MS = 40


def load_batch(batch):
    """Generate one feature row per input ID; preserve the input row count."""
    n = len(batch["id"])
    x = np.empty((n, WIDTH), dtype=np.float32)
    for start in range(0, n, ROWS):
        time.sleep(LOAD_MS / 1000)
        x[start : start + ROWS].fill(1.0)
    return {"x": x}


class Predict:
    def __init__(self, mode):
        import torch

        self.torch = torch
        self.mode = mode
        self.device = torch.device("cuda", 0)
        torch.set_num_threads(1)
        torch.cuda.set_device(self.device)
        torch.set_float32_matmul_precision("highest")
        self.weight = torch.eye(WIDTH, dtype=torch.float32, device=self.device)

        with torch.inference_mode(), torch.cuda.nvtx.range("warmup"):
            warm = torch.ones(
                (ROWS, WIDTH), dtype=torch.float32, device=self.device
            )
            warm = warm @ self.weight
        torch.cuda.synchronize(self.device)
        del warm
        print(
            f"Predict ready: mode={mode}, torch={torch.__version__}, "
            f"gpu={torch.cuda.get_device_name(self.device)}, "
            "dtype=float32, matmul_precision=highest",
            flush=True,
        )

    def __call__(self, batch):
        torch = self.torch
        with torch.cuda.nvtx.range(f"Predict::{self.mode}"):
            if self.mode == "inline":
                with torch.cuda.nvtx.range("load_cpu"):
                    batch = load_batch(batch)

            if self.mode == "staged":
                x = batch["x"]
                if (
                    not isinstance(x, torch.Tensor)
                    or x.device != self.device
                    or x.dtype != torch.float32
                ):
                    raise TypeError("staged mode must receive CUDA float32 tensors")
                # PinnedPrefetch has already waited/recorded the current stream.
            else:
                with torch.cuda.nvtx.range("H2D"):
                    # Preserve the original split/inline baseline transfer.
                    x = torch.tensor(batch["x"], device=self.device)

            if tuple(x.shape) != (ROWS, WIDTH):
                raise ValueError(f"Expected {(ROWS, WIDTH)}, got {tuple(x.shape)}")

            with torch.inference_mode(), torch.cuda.nvtx.range("forward"):
                for _ in range(ITER):
                    x = x @ self.weight

            with torch.cuda.nvtx.range("D2H"):
                # Same synchronous column-only D2H as the original Predict.
                out = x[:, 0].to("cpu", non_blocking=False)
            return {"out": out.numpy()}


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument(
        "--mode", choices=("inline", "split", "staged"), default="staged"
    )
    parser.add_argument("--profile", action="store_true")
    parser.add_argument(
        "--blocks", type=int, default=32, help="Input blocks; each has GROUP=4 batches"
    )
    parser.add_argument("--num-cpus", type=int, default=8)
    parser.add_argument("--cpu-workers", type=int, default=4)
    args = parser.parse_args()
    if args.blocks < 1 or args.cpu_workers < 1 or args.num_cpus < 2:
        parser.error("--blocks/--cpu-workers must be positive; --num-cpus must be >= 2")

    strategy_args = dict(
        size=1,
        max_tasks_in_flight_per_actor=4,
        max_concurrent_calls_per_actor=1,
        enable_true_multi_threading=False,
    )
    if args.mode == "staged":
        parameters = inspect.signature(ray.data.ActorPoolStrategy).parameters
        if "pinned_staging" not in parameters:
            raise RuntimeError(
                f"Imported Ray lacks the pinned-staging patch: {ray.__file__}"
            )
        from ray.data._internal.block_batching.pinned_staging import PinnedPrefetch

        print(f"PinnedPrefetch: {inspect.getfile(PinnedPrefetch)}", flush=True)
        strategy_args.update(pinned_staging=True, staging_collate_fn=None)

    init_context = ray.init(
        address="local",
        num_cpus=args.num_cpus,
        num_gpus=1,
        include_dashboard=False,
    )
    try:
        context = ray.data.DataContext.get_current()
        # Four 64-MiB batches form one 256-MiB feature block. The default
        # 128-MiB target would split it. Keep all four batches in the block
        # presented to the GPU actor, so each task can prefetch N+1.
        context.target_max_block_size = 512 * 1024 * 1024
        context.enable_progress_bars = False
        context.enable_operator_progress_bars = False

        total_batches = args.blocks * GROUP
        total_rows = total_batches * ROWS
        ds = ray.data.range(total_rows, override_num_blocks=args.blocks)
        if args.mode in ("split", "staged"):
            ds = ds.map_batches(
                load_batch,
                batch_size=BLOCK_ROWS,
                batch_format="numpy",
                zero_copy_batch=True,
                compute=ray.data.TaskPoolStrategy(size=args.cpu_workers),
                num_cpus=1,
            )

        gpu_args = dict(
            batch_size=ROWS,
            batch_format="numpy",
            # Required at the public API; the staging planner internally
            # uses zero-copy CPU views and then makes owned staging copies.
            zero_copy_batch=False,
            fn_constructor_kwargs={"mode": args.mode},
            compute=ray.data.ActorPoolStrategy(**strategy_args),
            num_cpus=1,
            num_gpus=1,
        )
        if args.profile:
            gpu_args["runtime_env"] = {
                "nsight": {
                    "t": "cuda,nvtx",
                    "sample": "none",
                    "cpuctxsw": "none",
                    "stop-on-exit": "true",
                    "force-overwrite": "true",
                    "o": f"workload_{args.mode}_%p",
                }
            }

        ds = ds.map_batches(Predict, **gpu_args)
        print(
            f"Ray={ray.__version__} ({ray.__file__})\n"
            f"MODE={args.mode} PROFILE={args.profile} BLOCKS={args.blocks} "
            f"GROUP={GROUP} BATCHES={total_batches} "
            f"SHAPE=({ROWS}, {WIDTH}) FP32 MATMULS={ITER}",
            flush=True,
        )
        started = time.perf_counter()
        result = ds.materialize()
        elapsed = time.perf_counter() - started

        print(
            f"MODE={args.mode} E2E={elapsed:.3f}s "
            f"BATCHES_PER_SEC={total_batches / elapsed:.3f}",
            flush=True,
        )
        print(result.stats(), flush=True)
        actual_rows = result.count()
        if actual_rows != total_rows:
            raise AssertionError(f"Expected {total_rows} rows, got {actual_rows}")
        sample = result.take_batch(8, batch_format="numpy")["out"]
        np.testing.assert_allclose(sample, 1.0, rtol=1e-5, atol=1e-5)
        print(f"CHECK=PASS ROWS={actual_rows}", flush=True)

        if args.profile:
            report_dir = (
                Path(init_context.address_info["session_dir"]) / "logs" / "nsight"
            )
            print(
                f"NSIGHT_REPORTS={report_dir}/workload_{args.mode}_*.nsys-rep\n"
                "Reports are finalized when the GPU actor exits.",
                flush=True,
            )
    finally:
        if args.profile:
            # ray#60904 workaround: give nsys stop-on-exit time to export the
            # report before teardown SIGKILLs the profiler's process group.
            import glob as _glob, time as _time
            nd = str(Path(init_context.address_info["session_dir"]) / "logs" / "nsight")
            for _ in range(30):
                _time.sleep(1)
                r = _glob.glob(nd + "/*.nsys-rep")
                if r and __import__("os").path.getsize(r[0]) > 0:
                    break
            print("PROFILER FLUSH WAIT done, reps:", _glob.glob(nd + "/*.nsys-rep"), flush=True)
        ray.shutdown()


if __name__ == "__main__":
    main()