code: def jit_load(self, verbose=True):
      if not self.is_compatible(verbose):
          raise RuntimeError(
              f"Unable to JIT load the {self.name} op due to it not being compatible due to hardware/software issue. {self.error_log}"
          )
      try:
          import ninja  # noqa: F401 # type: ignore
      except ImportError:
          raise RuntimeError(
              f"Unable to JIT load the {self.name} op due to ninja not being installed."
          )
  
      if isinstance(self, CUDAOpBuilder) and not self.is_rocm_pytorch():
          self.build_for_cpu = not torch.cuda.is_available()
  
      self.jit_mode = True
      from torch.utils.cpp_extension import load
  
      start_build = time.time()
      sources = [
          os.path.abspath(self.deepspeed_src_path(path))
          for path in self.sources()
      ]
      extra_include_paths = [
          os.path.abspath(self.deepspeed_src_path(path))
          for path in self.include_paths()
      ]
  
      # Torch will try and apply whatever CCs are in the arch list at compile time,
      # we have already set the intended targets ourselves we know that will be
      # needed at runtime. This prevents CC collisions such as multiple __half
      # implementations. Stash arch list to reset after build.
      torch_arch_list = None
      if "TORCH_CUDA_ARCH_LIST" in os.environ:
          torch_arch_list = os.environ.get("TORCH_CUDA_ARCH_LIST")
          os.environ["TORCH_CUDA_ARCH_LIST"] = ""
  
      nvcc_args = self.strip_empty_entries(self.nvcc_args())
      cxx_args = self.strip_empty_entries(self.cxx_args())
  
      if isinstance(self, CUDAOpBuilder):
          if not self.build_for_cpu and self.enable_bf16:
              cxx_args.append("-DBF16_AVAILABLE")
              nvcc_args.append("-DBF16_AVAILABLE")
              nvcc_args.append("-U__CUDA_NO_BFLOAT16_OPERATORS__")
              nvcc_args.append("-U__CUDA_NO_BFLOAT162_OPERATORS__")
  
      if self.is_rocm_pytorch():
          cxx_args.append("-D__HIP_PLATFORM_AMD__=1")
  
      op_module = load(
          name=self.name,
          sources=self.strip_empty_entries(sources),
          extra_include_paths=self.strip_empty_entries(
              extra_include_paths
          ),
          extra_cflags=cxx_args,
          extra_cuda_cflags=nvcc_args,
          extra_ldflags=self.strip_empty_entries(self.extra_ldflags()),
          verbose=verbose,
      )
  
      build_duration = time.time() - start_build
      if verbose:
          print(
              f"Time to load {self.name} op: {build_duration} seconds"
          )
  
      # Reset arch list so we are not silently removing it for other possible use cases
      if torch_arch_list:
          os.environ["TORCH_CUDA_ARCH_LIST"] = torch_arch_list
  
      __class__._loaded_ops[self.name] = op_module
  
      return op_module
  
imports: import os
  import sys
  import time
  import importlib
  from pathlib import Path
  import subprocess
  import shlex
  import shutil
  import tempfile
  import distutils.ccompiler
  import distutils.log
  import distutils.sysconfig
  from distutils.errors import CompileError, LinkError
  from abc import ABC, abstractmethod
  from typing import List
label_desc: Use image node_id 27 for calling the OpBuilder obj's underlying member method code with example usage: obj.jit_load(verbose) and returns: op_module