auto persistor = std::make_unique<XlaDeviceExecutablePersistor>(
      XlaDeviceExecutablePersistor::Config(), device_type);
  auto compiler_client =
      std::make_unique<XlaDeviceCompilerClient>(local_client);
  return new XlaDeviceCompiler(std::move(persistor),
                               std::move(compiler_client));
}

PjRtDeviceCompiler* CreatePjRtDeviceCompiler(DeviceType device_type,

      uint64 signature_hash, const XlaCompiler::Options& options,
      const XlaCompiler::CompilationResult& compilation_result,
      const ExecutableType& executable,
      DeviceCompilerClient<ExecutableType, ClientType>* compiler_client) const;

  // Saves the cache entry in the file directory supplied during the
  // construction of this class. Overwrites existing entries.
  Status SaveSerializedEntry(const XlaSerializedCacheEntry& entry) const;

      XlaDeviceExecutablePersistor::Config(), device_type);
  auto compiler_client = std::make_unique<XlaDeviceCompilerClient>(client);
  auto xla_device_compiler =
      new DeviceCompiler<xla::LocalExecutable, xla::LocalClient>(
          std::move(persistor), std::move(compiler_client));
  core::ScopedUnref xla_device_compiler_ref(xla_device_compiler);

  auto profiler = new DeviceCompilationProfiler();

    std::unique_ptr<DeviceExecutablePersistor<ExecutableType, ClientType>>
        persistor,
    std::unique_ptr<DeviceCompilerClient<ExecutableType, ClientType>>
        compiler_client)
    : persistor_(std::move(persistor)),
      compiler_client_(std::move(compiler_client)) {
  cache_ = std::make_unique<DeviceCompilationCache<ExecutableType>>();
  async_compiler_threads_ = std::make_unique<tensorflow::thread::ThreadPool>(

    // cross platform lowering.
    *xla_device_compiler = new XlaDeviceCompiler(/*persistor=*/nullptr,
                                                 /*compiler_client=*/nullptr);
    return absl::OkStatus();
  }
  std::string persistent_cache_directory =
      GetPersistentCacheDirectory(platform_info.device_type());

  XlaDeviceExecutablePersistor::Config persistor_config(

                                             "graph", std::move(graph), args,
                                             &compilation_result));
    return xla_device_compiler_->compiler_client()->BuildExecutable(
        GetDefaultXlaOptions(), compilation_result);
  }

  std::unique_ptr<FunctionLibraryDefinition> flib_def_;
  JitCompilationListener* listener_;