code: def scatter_object_list(
      scatter_object_output_list,
      scatter_object_input_list,
      src=0,
      group=None,
  ) -> None:
      r"""Modified from `torch.distributed.scatter_object_list
      <https://pytorch.org/docs/stable/_modules/torch/distributed/distributed_c10d.html#scatter_object_list>` to fix issues
      """
      if dist.distributed_c10d._rank_not_in_group(group):
          return
  
      if (
          not isinstance(scatter_object_output_list, list)
          or len(scatter_object_output_list) < 1
      ):
          raise RuntimeError(
              "Expected argument scatter_object_output_list to be a list of size at least 1."
          )
  
      # set tensor device to cuda if backend is nccl
      device = (
          torch.cuda.current_device()
          if dist.get_backend(group) == "nccl"
          else torch.device("cpu")
      )
  
      my_rank = dist.get_rank()  # use global rank
      if my_rank == src:
          tensor_list, tensor_sizes = zip(
              *[
                  dist.distributed_c10d._object_to_tensor(obj)
                  for obj in scatter_object_input_list
              ]
          )
          tensor_list = list(map(lambda x: x.to(device), tensor_list))
          tensor_sizes = list(map(lambda x: x.to(device), tensor_sizes))
  
      # Src rank broadcasts the maximum tensor size. This is because all ranks are
      # expected to call into scatter() with equal-sized tensors.
      if my_rank == src:
          max_tensor_size = max(tensor_sizes)
          for tensor in tensor_list:
              tensor.resize_(max_tensor_size)
      else:
          max_tensor_size = torch.tensor([0], dtype=torch.long).to(
              device
          )
  
      dist.broadcast(max_tensor_size, src=src, group=group)
  
      # Scatter actual serialized objects
      output_tensor = torch.empty(
          max_tensor_size.item(), dtype=torch.uint8
      ).to(device)
      dist.scatter(
          output_tensor,
          scatter_list=None if my_rank != src else tensor_list,
          src=src,
          group=group,
      )
  
      # Scatter per-object sizes to trim tensors when deserializing back to object
      obj_tensor_size = torch.tensor([0], dtype=torch.long).to(device)
      dist.scatter(
          obj_tensor_size,
          scatter_list=None if my_rank != src else tensor_sizes,
          src=src,
          group=group,
      )
  
      output_tensor, obj_tensor_size = (
          output_tensor.cpu(),
          obj_tensor_size.cpu(),
      )
      # Deserialize back to object
      scatter_object_output_list[
          0
      ] = dist.distributed_c10d._tensor_to_object(
          output_tensor, obj_tensor_size
      )
  
file_path: ColossalAI/colossalai/legacy/communication/collective.py
imports: import torch
  import torch.distributed
  from torch import Tensor
  from torch.distributed import ReduceOp
  from colossalai.legacy.context import ParallelMode
  from colossalai.legacy.core import global_context
label_desc: Use image node_id 6 for calling a global function with example usage: scatter_object_list(scatter_object_output_list, scatter_object_input_list, src, group) without return types