code: def receive_generate_info():
      """
      Needs to be synced up with send_generate_info
      """
      model_parallel_group = parallel_state.get_model_parallel_group()
      src = get_model_parallel_src_rank()
      input_info_tensor = torch.empty(
          11, dtype=torch.float32, device=torch.cuda.current_device()
      )
      torch.distributed.broadcast(
          input_info_tensor, src, model_parallel_group
      )
      batch_size = int(input_info_tensor[0].item())
      seq_len = int(input_info_tensor[1].item())
      tokens_to_generate = int(input_info_tensor[2].item())
      all_probs = bool(input_info_tensor[3].item())
      compute_logprob = bool(
          input_info_tensor[4].item()
      )  # whether to compute log probabilities matrix
      temperature = float(input_info_tensor[5].item())
      top_k = int(input_info_tensor[6].item())
      top_p = float(input_info_tensor[7].item())
      greedy = bool(input_info_tensor[8].item())
      repetition_penalty = float(input_info_tensor[9].item())
      min_tokens_to_generate = int(input_info_tensor[10].item())
  
      context_length_tensor = torch.empty(
          batch_size,
          dtype=torch.int64,
          device=torch.cuda.current_device(),
      )
      context_tokens_tensor = torch.empty(
          batch_size,
          seq_len,
          dtype=torch.int64,
          device=torch.cuda.current_device(),
      )
      # Send variables to all ranks
      torch.distributed.broadcast(
          context_length_tensor, src, model_parallel_group
      )
      torch.distributed.broadcast(
          context_tokens_tensor, src, model_parallel_group
      )
  
      array_size = torch.empty(
          1, dtype=torch.int64, device=torch.cuda.current_device()
      )
      torch.distributed.broadcast(array_size, src, model_parallel_group)
  
      string_tensor = torch.empty(
          array_size[0],
          dtype=torch.int8,
          device=torch.cuda.current_device(),
      )
      torch.distributed.broadcast(
          string_tensor, src, model_parallel_group
      )
      bytes = string_tensor.cpu().numpy().tobytes()
      end_strings = pickle.loads(bytes)
  
      return (
          context_length_tensor,
          context_tokens_tensor,
          tokens_to_generate,
          all_probs,
          compute_logprob,
          temperature,
          top_k,
          top_p,
          greedy,
          repetition_penalty,
          min_tokens_to_generate,
          end_strings,
      )
  
imports: import os
  import pickle
  import re
  from collections.abc import Iterable
  from functools import partial
  from typing import Callable, Tuple
  import numpy
  import torch
  import torch.nn.functional
  from nemo.collections.common.tokenizers.tabular_tokenizer import TabularTokenizer
  from nemo.collections.nlp.modules.common.megatron.utils import get_ltor_masks_and_position_ids
  from nemo.collections.nlp.modules.common.text_generation_strategy import model_inference_strategy_dispatcher
  from nemo.collections.nlp.modules.common.transformer.text_generation import LengthParam, OutputType, SamplingParam
  from nemo.utils import AppState
label_desc: Use image node_id 12 for calling a global function with example usage: receive_generate_info() and returns: context_length_tensor,  context_tokens_tensor,  tokens_to_generate,  all_probs,  compute_logprob,  temperature,  top_k,  top_p,  greedy,  repetition_penalty,  min_tokens_to_generate,  end_strings