return client_->DeserializeExecutable(serialized_executable,
                                        GetPjRtCompileOptions(options, result));
}

void PjRtDeviceCompilerClient::WaitForProgramsToFinish() {
  // TODO(b/255826209): Modify this if PjRtClient exposes a function to wait for
  // programs to finish.
  LOG(INFO) << "Unimplemented: PJRT uses futures and waiting for programs to "

      options, result, client_->default_device_ordinal());
  return client_->Load(serialized_executable, build_options);
}

void XlaDeviceCompilerClient::WaitForProgramsToFinish() {
  if (client_ == nullptr) return;

  for (auto* executor : client_->backend().stream_executors()) {
    bool ok = executor->SynchronizeAllActivity();
    if (!ok) {

      const XlaCompiler::Options& options,
      const XlaCompiler::CompilationResult& result,
      const std::string& serialized_executable) override;

  void WaitForProgramsToFinish() override;

  xla::LocalClient* client() const override { return client_; }

 private:
  xla::LocalClient* const client_;

  XlaDeviceCompilerClient(const XlaDeviceCompilerClient&) = delete;

      const std::string& serialized_executable) = 0;

  // Waits for the underlying `ClientType` backend's programs to finish
  // executing before returning.
  virtual void WaitForProgramsToFinish() = 0;

  virtual ClientType* client() const = 0;

 private:
  DeviceCompilerClient(const DeviceCompilerClient&) = delete;
  void operator=(const DeviceCompilerClient&) = delete;
};

      const XlaCompiler::CompilationResult& result,
      const std::string& serialized_executable) override;

  // No-op. PJRT uses futures and waiting for programs to finish isn't
  // necessary.
  void WaitForProgramsToFinish() override;

  xla::PjRtClient* client() const override { return client_; }

 private:
  xla::PjRtClient* const client_;

  PjRtDeviceCompilerClient(const PjRtDeviceCompilerClient&) = delete;

DeviceCompiler<ExecutableType, ClientType>::~DeviceCompiler() {
  // Since programs are owned by the cache, ensure any use of our programs have
  // completed by waiting for all stream executors to complete.
  compiler_client_->WaitForProgramsToFinish();
  // Wait for all outstanding compilations to finish.
  // Resetting the pointer explicitly in the top level destructor.
  // Without this, the pointer would be reset when the AsyncCompilationState