void WaitForProgramsToFinish() override;

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

 private:
  xla::PjRtClient* const client_;

  PjRtDeviceCompilerClient(const PjRtDeviceCompilerClient&) = delete;
  void operator=(const PjRtDeviceCompilerClient&) = delete;
};

// Generates CompileOptions for PJRT compilation.
xla::CompileOptions GetPjRtCompileOptions(
    const XlaCompiler::Options& options,

  return std::move(executable);
}

absl::StatusOr<std::string> PjRtDeviceCompilerClient::SerializeExecutable(
    const xla::PjRtLoadedExecutable& executable) {
  VLOG(1) << "Serializing xla::PjRtLoadedExecutable to string.";
  return executable.SerializeExecutable();
}

absl::StatusOr<std::string> PjRtDeviceCompilerClient::BuildSerializedExecutable(
    const XlaCompiler::Options& options,

    pjrt_compiler_client_ =
        std::make_unique<PjRtDeviceCompilerClient>(pjrt_client);
    return absl::OkStatus();
  }

  std::unique_ptr<FunctionLibraryDefinition> flib_def_;
  std::unique_ptr<XlaDeviceCompilerClient> xla_compiler_client_;
  std::unique_ptr<PjRtDeviceCompilerClient> pjrt_compiler_client_;
  XlaCompiler::CompilationResult compilation_result_add_;

    device_compiler_ = new PjRtDeviceCompiler(
        std::make_unique<PjRtDeviceExecutablePersistor>(
            PjRtDeviceExecutablePersistor::Config(), jit_device_type),
        std::make_unique<PjRtDeviceCompilerClient>(pjrt_client_));
    profiler_ = new DeviceCompilationProfiler();

    compiler_options_.device_type = jit_device_type;
    compiler_options_.client = nullptr;
    compiler_options_.flib_def = flib_def_.get();

  auto persistor = std::make_unique<PjRtDeviceExecutablePersistor>(
      PjRtDeviceExecutablePersistor::Config(), device_type);
  auto compiler_client =
      std::make_unique<PjRtDeviceCompilerClient>(pjrt_client);
  return new PjRtDeviceCompiler(std::move(persistor),
                                std::move(compiler_client));
}

std::vector<XlaShapeLayoutHelpers::ShapeDeterminationFns>

  return new PjRtDeviceCompiler(
      std::make_unique<PjRtDeviceExecutablePersistor>(
          std::move(persistor_config), compilation_device_type),
      std::make_unique<PjRtDeviceCompilerClient>(pjrt_client));
}

absl::StatusOr<std::optional<std::set<int>>> GetAllowedGpus(
    FunctionLibraryRuntime* flr) {
  std::optional<std::set<int>> gpu_ids = std::nullopt;

  if (flr->config_proto()) {

    device_compiler_ = new PjRtDeviceCompiler(
        std::make_unique<PjRtDeviceExecutablePersistor>(
            PjRtDeviceExecutablePersistor::Config(), jit_device_type),
        std::make_unique<PjRtDeviceCompilerClient>(pjrt_client_));
    profiler_ = new DeviceCompilationProfiler();

    compiler_options_.device_type = jit_device_type;
    compiler_options_.client = nullptr;
    compiler_options_.flib_def = flib_def_.get();