class_docstr: Run correctness checks in multi-proc runner, mark with minimum # GPUs to run under
code: def test_all_to_all_single_inductor_input_split_sizes_none(self):
      def example(
          inp, output_split_sizes_tensor, *, tag, ranks, group_size
      ):
          output_split_sizes = _tolist_with_constrain_as_size(
              output_split_sizes_tensor
          )
          a2a = torch.ops.c10d_functional.all_to_all_single(
              inp,
              output_split_sizes,
              None,
              tag,
              ranks,
              group_size,
          )
          a2a = torch.ops.c10d_functional.wait_tensor(a2a)
          out = a2a / a2a.sum(dim=0)
          return out
  
      with _dynamo_dist_per_rank_init(
          self.rank, self.world_size
      ), torch._dynamo.config.patch(
          dynamic_shapes=True,
          capture_dynamic_output_shape_ops=True,
          capture_scalar_outputs=True,
      ):
          output_split_sizes_tensor = torch.tensor(
              [1] * self.world_size, dtype=torch.int64
          )
          inputs = (
              torch.ones(
                  self.world_size, self.world_size, device="cuda"
              )
              * (self.rank + 1),
              output_split_sizes_tensor,
          )
          trs = self.get_world_trs()
  
          compiled_fn = torch.compile(
              example, fullgraph=True, dynamic=True
          )
          code = run_and_get_triton_code(compiled_fn, *inputs, **trs)
          FileCheck().check_regex(
              "all_to_all_single\\(buf\\d+\\[0\\], buf\\d+_inputs\\[0\\], output_split_sizes=\\[i\\d+, i\\d+\\], input_split_sizes=None"
          ).run(
              code
          )  # noqa: B950
  
          eager_out = example(*inputs, **trs)
          inductor_out = compiled_fn(*inputs, **trs)
          self.assertTrue(same(eager_out, inductor_out, tol=0.001))
  
imports: import functools
  import unittest
  from unittest.mock import patch
  import torch
  from torch._C import FileCheck
  import torch.distributed._functional_collectives
  import torch._dynamo
  import torch._dynamo.test_case
  from torch._dynamo.utils import same
  from torch._dynamo.testing import CompileCounter
  from torch.distributed.distributed_c10d import GroupMember
  from torch.fx.experimental.proxy_tensor import make_fx
  from torch.testing._internal.common_distributed import DynamoDistributedSingleProcTestCase, DynamoDistributedMultiProcTestCase, _dynamo_dist_per_rank_init, requires_nccl, skip_if_lt_x_gpu
  from torch._inductor.compile_fx import compile_fx
  from torch.utils._triton import has_triton
  from torch._inductor.utils import run_and_get_triton_code
  import torch._dynamo.logging
label_desc: Use image node_id 16 for calling the TestCollectivesMultiProc obj's underlying member method code with example usage: obj.test_all_to_all_single_inductor_input_split_sizes_none() and returns: out