code: def get_meta(
      op,
      key,
      device_name=None,
      version=(0, torch.float16, 0.5),
      exact=False,
  ):
      """Return triton kernel meta parameters of the specified op and its inputs key.
  
      Parameters
      ----------
      op (str): The name of an operation that implementation uses meta parameters.
      key (tuple): A tuple of op input parameters, e.g. shapes, etc.
      device_name (optional, str): The name of a device for which op
        parameters are provided.
      version (optional, hashable): Specifies the version of parameters.
      exact (optional, bool): When True, the returned data (if
        available) corresponds exactly to the specified device_name and
        version information. Otherwise, if the corresponding data is not
        available but there exists a data set that is computed for a
        similar GPU device, then this data set will be returned.
  
      Returns
      -------
      result (dict): The requested mapping of parameter names and
        values, or None when no data is available.
      """
      if device_name is None:
          device_name = torch.cuda.get_device_name()
      op_data = _operation_device_version_data.get(
          (op, device_name, version)
      )
      if op_data is None and not exact:
          # A lack of op data could be due to using a (slightly)
          # different GPU model compared to a model for which optimal
          # meta parameters have been computed. In the following we'll
          # assume that there is a set of GPU models that all have
          # a similar set of optimal meta parameters.
          if re.match(r"NVIDIA A100[^\d]", device_name) is not None:
              device_name = "NVIDIA A100-SXM4-80GB"
          else:
              return
          op_data = _operation_device_version_data.get(
              (op, device_name, version)
          )
      if op_data is None:
          return
      values = op_data.get(key)
      if values is not None:
          if op == "scatter_mm":
              names = (
                  "GROUP_SIZE",
                  "SPLIT_N",
                  "TILE_M",
                  "TILE_N",
                  "num_stages",
                  "num_warps",
              )
              return dict(zip(names, values))
          elif op == "bsr_dense_addmm":
              return dict(
                  zip(
                      (
                          "GROUP_SIZE_ROW",
                          "SPLIT_N",
                          "num_stages",
                          "num_warps",
                      ),
                      values,
                  )
              )
          raise NotImplementedError(f"names for {op=}")
  
file_path: pytorch/torch/sparse/_triton_ops_meta.py
imports: import inspect
  import itertools
  import re
  import warnings
  from typing import Any, Dict
  import torch
  from torch.hub import tqdm
  from torch.testing import make_tensor
label_desc: Use image node_id 1 for calling a global function with example usage: get_meta(op, key, device_name, version, exact) and returns: dict, dict