const XlaCompiler::CompilationResult& result),
              (override));
  MOCK_METHOD(absl::StatusOr<std::unique_ptr<xla::LocalExecutable>>,
              LoadExecutable,
              (const XlaCompiler::Options& options,
               const XlaCompiler::CompilationResult& result,
               const std::string& serialized_executable),
              (override));
};

  TF_ASSIGN_OR_RETURN(auto executable, BuildExecutable(options, result));
  return executable->SerializeExecutable();
}

absl::StatusOr<std::unique_ptr<xla::PjRtLoadedExecutable>>
PjRtDeviceCompilerClient::LoadExecutable(
    const XlaCompiler::Options& options,
    const XlaCompiler::CompilationResult& result,
    const std::string& serialized_executable) {
  VLOG(1) << "Deserializing from string to xla::PjRtLoadedExecutable.";

  // Loads a serialized AOT result (`serialized_executable`) into an
  // xla::LocalExecutable and returns it.
  absl::StatusOr<std::unique_ptr<xla::LocalExecutable>> LoadExecutable(
      const XlaCompiler::Options& options,
      const XlaCompiler::CompilationResult& result,
      const std::string& serialized_executable) override;

  void WaitForProgramsToFinish() override;

      const XlaCompiler::CompilationResult& result) = 0;

  // Loads `serialized_executable` into an `ExecutableType` using `ClientType`.
  virtual StatusOr<std::unique_ptr<ExecutableType>> LoadExecutable(
      const XlaCompiler::Options& options,
      const XlaCompiler::CompilationResult& result,
      const std::string& serialized_executable) = 0;

  // Waits for the underlying `ClientType` backend's programs to finish

  TF_RET_CHECK(aot_results.size() == 1);
  return aot_results[0]->SerializeAsString();
}

absl::StatusOr<std::unique_ptr<xla::LocalExecutable>>
XlaDeviceCompilerClient::LoadExecutable(
    const XlaCompiler::Options& options,
    const XlaCompiler::CompilationResult& result,
    const std::string& serialized_executable) {
  VLOG(2) << "Loading xla::LocalExecutable from a serialized "

  // function doesn't use PjRtClient::LoadSerializedExecutable() and uses
  // PjRtClient::DeserializeExecutable() instead.
  absl::StatusOr<std::unique_ptr<xla::PjRtLoadedExecutable>> LoadExecutable(
      const XlaCompiler::Options& options,
      const XlaCompiler::CompilationResult& result,
      const std::string& serialized_executable) override;

  }

  TF_RETURN_IF_ERROR(
      VerifyLoadedCacheEntry(cache_key, hlo_module, *serialized_entry));

  VLOG(1) << "Loading cached entry for: " << signature_str;
  return compiler_client->LoadExecutable(options, compilation_result,
                                         serialized_entry->executable());
}

template <typename ExecutableType, typename ClientType>
Status