code: def recv(
      communicator,
      rank,
      delegate_variable=None,
      tag=0,
      force_tuple=False,
  ):
      """Receive elements from target process.
  
      This function returns data received from target process. If ``backward()``
      is invoked, it will try to send gradients to the target process.
      The received array will be on the current CUDA device if the corresponding
      ``send()`` is invoked with arrays on GPU.
      Please be aware that the current CUDA device is intended one.
      (``https://docs-cupy.chainer.org/en/stable/tutorial/basic.html#current-device``)
  
      .. note::
          If you define non-connected computational graph on one process,
          you have to use ``delegate_variable`` to specify the output of
          previous computational graph component.
          Otherwise ``backward()`` does not work well.
          Please refer ``chainermn.functions.pseudo_connect`` for detail.
  
      Args:
          communicator (chainer.communicators.CommunicatorBase):
              ChainerMN communicator.
          rank (int): Target process specifier.
          delegate_variable (chainer.Variable):
              Pointer to the other non-connected component.
          tag (int): Optional message ID (MPI feature).
          force_tuple (bool): If ``False`` (the default) a Variable will be
              returned when the number of outputs is one. Otherwise, this
              method returns a tuple even when the number of outputs is one.
  
      Returns:
          ~chainer.Variable:
              Data received from target process. If ``backward()`` is invoked
              by this variable, it will send gradients to the target process.
  
      """
      chainer.utils.experimental("chainermn.functions.recv")
  
      if rank == communicator.rank:
          raise ValueError(
              "rank must be different from communicator rank, "
              "otherwise deadlock occurs"
          )
  
      if delegate_variable is None:
          res = Recv(communicator, peer_rank=rank, peer_tag=tag)()
      else:
          delegate_variable.name = "delegate_variable"
          res = Recv(communicator, peer_rank=rank, peer_tag=tag)(
              delegate_variable
          )
  
      if force_tuple and not isinstance(res, tuple):
          return tuple([res])
      else:
          return res
  
file_path: chainer/chainermn/functions/point_to_point_communication.py
imports: import chainer
  from chainer import backend
  import chainer.utils
label_desc: Use image node_id 2 for calling a global function with example usage: recv(communicator, rank, delegate_variable, tag, force_tuple) and returns: tuple, res