| |
| """Minimal NCCL collective test intended to be launched with torchrun.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import os |
| from datetime import timedelta |
|
|
| import torch |
| import torch.distributed as dist |
|
|
|
|
| def parse_args() -> argparse.Namespace: |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("--timeout-seconds", type=int, default=120) |
| parser.add_argument("--tensor-elements", type=int, default=1_048_576) |
| parser.add_argument("--require-world-size", type=int) |
| return parser.parse_args() |
|
|
|
|
| def main() -> int: |
| args = parse_args() |
| if not torch.cuda.is_available(): |
| raise RuntimeError("NCCL smoke test requires CUDA") |
| if not dist.is_available() or not dist.is_nccl_available(): |
| raise RuntimeError("this PyTorch build does not provide NCCL") |
|
|
| local_rank = int(os.environ.get("LOCAL_RANK", "0")) |
| torch.cuda.set_device(local_rank) |
| dist.init_process_group( |
| backend="nccl", |
| timeout=timedelta(seconds=args.timeout_seconds), |
| device_id=torch.device("cuda", local_rank), |
| ) |
| try: |
| rank = dist.get_rank() |
| world_size = dist.get_world_size() |
| if args.require_world_size is not None and world_size != args.require_world_size: |
| raise RuntimeError( |
| f"expected world size {args.require_world_size}, initialized {world_size}" |
| ) |
|
|
| device = torch.device("cuda", local_rank) |
| value = torch.full( |
| (args.tensor_elements,), |
| float(rank + 1), |
| device=device, |
| dtype=torch.float32, |
| ) |
| dist.all_reduce(value, op=dist.ReduceOp.SUM) |
| expected_sum = world_size * (world_size + 1) / 2 |
| expected = torch.full_like(value, expected_sum) |
| torch.testing.assert_close(value, expected, rtol=0, atol=0) |
|
|
| broadcast = torch.tensor([rank], device=device, dtype=torch.int64) |
| dist.broadcast(broadcast, src=0) |
| if broadcast.item() != 0: |
| raise RuntimeError(f"broadcast returned {broadcast.item()}, expected 0") |
| dist.barrier(device_ids=[local_rank]) |
| torch.cuda.synchronize(device) |
|
|
| if rank == 0: |
| print( |
| json.dumps( |
| { |
| "backend": dist.get_backend(), |
| "cuda_devices": torch.cuda.device_count(), |
| "status": "passed", |
| "tensor_elements_per_rank": args.tensor_elements, |
| "world_size": world_size, |
| }, |
| sort_keys=True, |
| ), |
| flush=True, |
| ) |
| finally: |
| dist.destroy_process_group() |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
