// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: xla/service/gpu/executable.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_xla_2fservice_2fgpu_2fexecutable_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_xla_2fservice_2fgpu_2fexecutable_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3021000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3021009 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/map.h>  // IWYU pragma: export
#include <google/protobuf/map_entry.h>
#include <google/protobuf/map_field_inl.h>
#include <google/protobuf/unknown_field_set.h>
#include "xla/service/hlo.pb.h"
#include "xla/xla.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_xla_2fservice_2fgpu_2fexecutable_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_xla_2fservice_2fgpu_2fexecutable_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_xla_2fservice_2fgpu_2fexecutable_2eproto;
namespace xla {
namespace gpu {
class ClusterDimProto;
struct ClusterDimProtoDefaultTypeInternal;
extern ClusterDimProtoDefaultTypeInternal _ClusterDimProto_default_instance_;
class CompilationCacheEntryProto;
struct CompilationCacheEntryProtoDefaultTypeInternal;
extern CompilationCacheEntryProtoDefaultTypeInternal _CompilationCacheEntryProto_default_instance_;
class CompilationCacheProto;
struct CompilationCacheProtoDefaultTypeInternal;
extern CompilationCacheProtoDefaultTypeInternal _CompilationCacheProto_default_instance_;
class CompilationCacheProto_EntriesEntry_DoNotUse;
struct CompilationCacheProto_EntriesEntry_DoNotUseDefaultTypeInternal;
extern CompilationCacheProto_EntriesEntry_DoNotUseDefaultTypeInternal _CompilationCacheProto_EntriesEntry_DoNotUse_default_instance_;
class CompilationResultProto;
struct CompilationResultProtoDefaultTypeInternal;
extern CompilationResultProtoDefaultTypeInternal _CompilationResultProto_default_instance_;
class CompilationResultProto_DnnCompiledGraphsEntry_DoNotUse;
struct CompilationResultProto_DnnCompiledGraphsEntry_DoNotUseDefaultTypeInternal;
extern CompilationResultProto_DnnCompiledGraphsEntry_DoNotUseDefaultTypeInternal _CompilationResultProto_DnnCompiledGraphsEntry_DoNotUse_default_instance_;
class LaunchDimensionsProto;
struct LaunchDimensionsProtoDefaultTypeInternal;
extern LaunchDimensionsProtoDefaultTypeInternal _LaunchDimensionsProto_default_instance_;
}  // namespace gpu
}  // namespace xla
PROTOBUF_NAMESPACE_OPEN
template<> ::xla::gpu::ClusterDimProto* Arena::CreateMaybeMessage<::xla::gpu::ClusterDimProto>(Arena*);
template<> ::xla::gpu::CompilationCacheEntryProto* Arena::CreateMaybeMessage<::xla::gpu::CompilationCacheEntryProto>(Arena*);
template<> ::xla::gpu::CompilationCacheProto* Arena::CreateMaybeMessage<::xla::gpu::CompilationCacheProto>(Arena*);
template<> ::xla::gpu::CompilationCacheProto_EntriesEntry_DoNotUse* Arena::CreateMaybeMessage<::xla::gpu::CompilationCacheProto_EntriesEntry_DoNotUse>(Arena*);
template<> ::xla::gpu::CompilationResultProto* Arena::CreateMaybeMessage<::xla::gpu::CompilationResultProto>(Arena*);
template<> ::xla::gpu::CompilationResultProto_DnnCompiledGraphsEntry_DoNotUse* Arena::CreateMaybeMessage<::xla::gpu::CompilationResultProto_DnnCompiledGraphsEntry_DoNotUse>(Arena*);
template<> ::xla::gpu::LaunchDimensionsProto* Arena::CreateMaybeMessage<::xla::gpu::LaunchDimensionsProto>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace xla {
namespace gpu {

// ===================================================================

class CompilationResultProto_DnnCompiledGraphsEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<CompilationResultProto_DnnCompiledGraphsEntry_DoNotUse, 
    std::string, std::string,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BYTES> {
public:
  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<CompilationResultProto_DnnCompiledGraphsEntry_DoNotUse, 
    std::string, std::string,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BYTES> SuperType;
  CompilationResultProto_DnnCompiledGraphsEntry_DoNotUse();
  explicit PROTOBUF_CONSTEXPR CompilationResultProto_DnnCompiledGraphsEntry_DoNotUse(
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
  explicit CompilationResultProto_DnnCompiledGraphsEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void MergeFrom(const CompilationResultProto_DnnCompiledGraphsEntry_DoNotUse& other);
  static const CompilationResultProto_DnnCompiledGraphsEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const CompilationResultProto_DnnCompiledGraphsEntry_DoNotUse*>(&_CompilationResultProto_DnnCompiledGraphsEntry_DoNotUse_default_instance_); }
  static bool ValidateKey(std::string* s) {
    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "xla.gpu.CompilationResultProto.DnnCompiledGraphsEntry.key");
 }
  static bool ValidateValue(void*) { return true; }
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  friend struct ::TableStruct_xla_2fservice_2fgpu_2fexecutable_2eproto;
};

// -------------------------------------------------------------------

class CompilationResultProto final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.gpu.CompilationResultProto) */ {
 public:
  inline CompilationResultProto() : CompilationResultProto(nullptr) {}
  ~CompilationResultProto() override;
  explicit PROTOBUF_CONSTEXPR CompilationResultProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CompilationResultProto(const CompilationResultProto& from);
  CompilationResultProto(CompilationResultProto&& from) noexcept
    : CompilationResultProto() {
    *this = ::std::move(from);
  }

  inline CompilationResultProto& operator=(const CompilationResultProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline CompilationResultProto& operator=(CompilationResultProto&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CompilationResultProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const CompilationResultProto* internal_default_instance() {
    return reinterpret_cast<const CompilationResultProto*>(
               &_CompilationResultProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(CompilationResultProto& a, CompilationResultProto& b) {
    a.Swap(&b);
  }
  inline void Swap(CompilationResultProto* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CompilationResultProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CompilationResultProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CompilationResultProto>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CompilationResultProto& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CompilationResultProto& from) {
    CompilationResultProto::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CompilationResultProto* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xla.gpu.CompilationResultProto";
  }
  protected:
  explicit CompilationResultProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------


  // accessors -------------------------------------------------------

  enum : int {
    kDnnCompiledGraphsFieldNumber = 5,
    kAsmTextFieldNumber = 3,
    kBinaryFieldNumber = 4,
    kHloModuleWithConfigFieldNumber = 1,
    kBufferAssignmentFieldNumber = 2,
  };
  // map<string, bytes> dnn_compiled_graphs = 5;
  int dnn_compiled_graphs_size() const;
  private:
  int _internal_dnn_compiled_graphs_size() const;
  public:
  void clear_dnn_compiled_graphs();
  private:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
      _internal_dnn_compiled_graphs() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
      _internal_mutable_dnn_compiled_graphs();
  public:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
      dnn_compiled_graphs() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
      mutable_dnn_compiled_graphs();

  // string asm_text = 3;
  void clear_asm_text();
  const std::string& asm_text() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_asm_text(ArgT0&& arg0, ArgT... args);
  std::string* mutable_asm_text();
  PROTOBUF_NODISCARD std::string* release_asm_text();
  void set_allocated_asm_text(std::string* asm_text);
  private:
  const std::string& _internal_asm_text() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_asm_text(const std::string& value);
  std::string* _internal_mutable_asm_text();
  public:

  // bytes binary = 4;
  void clear_binary();
  const std::string& binary() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_binary(ArgT0&& arg0, ArgT... args);
  std::string* mutable_binary();
  PROTOBUF_NODISCARD std::string* release_binary();
  void set_allocated_binary(std::string* binary);
  private:
  const std::string& _internal_binary() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_binary(const std::string& value);
  std::string* _internal_mutable_binary();
  public:

  // .xla.HloModuleProtoWithConfig hlo_module_with_config = 1;
  bool has_hlo_module_with_config() const;
  private:
  bool _internal_has_hlo_module_with_config() const;
  public:
  void clear_hlo_module_with_config();
  const ::xla::HloModuleProtoWithConfig& hlo_module_with_config() const;
  PROTOBUF_NODISCARD ::xla::HloModuleProtoWithConfig* release_hlo_module_with_config();
  ::xla::HloModuleProtoWithConfig* mutable_hlo_module_with_config();
  void set_allocated_hlo_module_with_config(::xla::HloModuleProtoWithConfig* hlo_module_with_config);
  private:
  const ::xla::HloModuleProtoWithConfig& _internal_hlo_module_with_config() const;
  ::xla::HloModuleProtoWithConfig* _internal_mutable_hlo_module_with_config();
  public:
  void unsafe_arena_set_allocated_hlo_module_with_config(
      ::xla::HloModuleProtoWithConfig* hlo_module_with_config);
  ::xla::HloModuleProtoWithConfig* unsafe_arena_release_hlo_module_with_config();

  // .xla.BufferAssignmentProto buffer_assignment = 2;
  bool has_buffer_assignment() const;
  private:
  bool _internal_has_buffer_assignment() const;
  public:
  void clear_buffer_assignment();
  const ::xla::BufferAssignmentProto& buffer_assignment() const;
  PROTOBUF_NODISCARD ::xla::BufferAssignmentProto* release_buffer_assignment();
  ::xla::BufferAssignmentProto* mutable_buffer_assignment();
  void set_allocated_buffer_assignment(::xla::BufferAssignmentProto* buffer_assignment);
  private:
  const ::xla::BufferAssignmentProto& _internal_buffer_assignment() const;
  ::xla::BufferAssignmentProto* _internal_mutable_buffer_assignment();
  public:
  void unsafe_arena_set_allocated_buffer_assignment(
      ::xla::BufferAssignmentProto* buffer_assignment);
  ::xla::BufferAssignmentProto* unsafe_arena_release_buffer_assignment();

  // @@protoc_insertion_point(class_scope:xla.gpu.CompilationResultProto)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::MapField<
        CompilationResultProto_DnnCompiledGraphsEntry_DoNotUse,
        std::string, std::string,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BYTES> dnn_compiled_graphs_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr asm_text_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr binary_;
    ::xla::HloModuleProtoWithConfig* hlo_module_with_config_;
    ::xla::BufferAssignmentProto* buffer_assignment_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_xla_2fservice_2fgpu_2fexecutable_2eproto;
};
// -------------------------------------------------------------------

class LaunchDimensionsProto final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.gpu.LaunchDimensionsProto) */ {
 public:
  inline LaunchDimensionsProto() : LaunchDimensionsProto(nullptr) {}
  ~LaunchDimensionsProto() override;
  explicit PROTOBUF_CONSTEXPR LaunchDimensionsProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  LaunchDimensionsProto(const LaunchDimensionsProto& from);
  LaunchDimensionsProto(LaunchDimensionsProto&& from) noexcept
    : LaunchDimensionsProto() {
    *this = ::std::move(from);
  }

  inline LaunchDimensionsProto& operator=(const LaunchDimensionsProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline LaunchDimensionsProto& operator=(LaunchDimensionsProto&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const LaunchDimensionsProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const LaunchDimensionsProto* internal_default_instance() {
    return reinterpret_cast<const LaunchDimensionsProto*>(
               &_LaunchDimensionsProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(LaunchDimensionsProto& a, LaunchDimensionsProto& b) {
    a.Swap(&b);
  }
  inline void Swap(LaunchDimensionsProto* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(LaunchDimensionsProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  LaunchDimensionsProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<LaunchDimensionsProto>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const LaunchDimensionsProto& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const LaunchDimensionsProto& from) {
    LaunchDimensionsProto::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LaunchDimensionsProto* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xla.gpu.LaunchDimensionsProto";
  }
  protected:
  explicit LaunchDimensionsProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kNumBlocksFieldNumber = 1,
    kNumThreadsPerBlockFieldNumber = 2,
  };
  // uint64 num_blocks = 1;
  void clear_num_blocks();
  uint64_t num_blocks() const;
  void set_num_blocks(uint64_t value);
  private:
  uint64_t _internal_num_blocks() const;
  void _internal_set_num_blocks(uint64_t value);
  public:

  // uint64 num_threads_per_block = 2;
  void clear_num_threads_per_block();
  uint64_t num_threads_per_block() const;
  void set_num_threads_per_block(uint64_t value);
  private:
  uint64_t _internal_num_threads_per_block() const;
  void _internal_set_num_threads_per_block(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:xla.gpu.LaunchDimensionsProto)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    uint64_t num_blocks_;
    uint64_t num_threads_per_block_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_xla_2fservice_2fgpu_2fexecutable_2eproto;
};
// -------------------------------------------------------------------

class ClusterDimProto final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.gpu.ClusterDimProto) */ {
 public:
  inline ClusterDimProto() : ClusterDimProto(nullptr) {}
  ~ClusterDimProto() override;
  explicit PROTOBUF_CONSTEXPR ClusterDimProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  ClusterDimProto(const ClusterDimProto& from);
  ClusterDimProto(ClusterDimProto&& from) noexcept
    : ClusterDimProto() {
    *this = ::std::move(from);
  }

  inline ClusterDimProto& operator=(const ClusterDimProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline ClusterDimProto& operator=(ClusterDimProto&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ClusterDimProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const ClusterDimProto* internal_default_instance() {
    return reinterpret_cast<const ClusterDimProto*>(
               &_ClusterDimProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(ClusterDimProto& a, ClusterDimProto& b) {
    a.Swap(&b);
  }
  inline void Swap(ClusterDimProto* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ClusterDimProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  ClusterDimProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ClusterDimProto>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ClusterDimProto& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ClusterDimProto& from) {
    ClusterDimProto::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ClusterDimProto* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xla.gpu.ClusterDimProto";
  }
  protected:
  explicit ClusterDimProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kXFieldNumber = 1,
    kYFieldNumber = 2,
    kZFieldNumber = 3,
  };
  // uint64 x = 1;
  void clear_x();
  uint64_t x() const;
  void set_x(uint64_t value);
  private:
  uint64_t _internal_x() const;
  void _internal_set_x(uint64_t value);
  public:

  // uint64 y = 2;
  void clear_y();
  uint64_t y() const;
  void set_y(uint64_t value);
  private:
  uint64_t _internal_y() const;
  void _internal_set_y(uint64_t value);
  public:

  // uint64 z = 3;
  void clear_z();
  uint64_t z() const;
  void set_z(uint64_t value);
  private:
  uint64_t _internal_z() const;
  void _internal_set_z(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:xla.gpu.ClusterDimProto)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    uint64_t x_;
    uint64_t y_;
    uint64_t z_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_xla_2fservice_2fgpu_2fexecutable_2eproto;
};
// -------------------------------------------------------------------

class CompilationCacheEntryProto final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.gpu.CompilationCacheEntryProto) */ {
 public:
  inline CompilationCacheEntryProto() : CompilationCacheEntryProto(nullptr) {}
  ~CompilationCacheEntryProto() override;
  explicit PROTOBUF_CONSTEXPR CompilationCacheEntryProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CompilationCacheEntryProto(const CompilationCacheEntryProto& from);
  CompilationCacheEntryProto(CompilationCacheEntryProto&& from) noexcept
    : CompilationCacheEntryProto() {
    *this = ::std::move(from);
  }

  inline CompilationCacheEntryProto& operator=(const CompilationCacheEntryProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline CompilationCacheEntryProto& operator=(CompilationCacheEntryProto&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CompilationCacheEntryProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const CompilationCacheEntryProto* internal_default_instance() {
    return reinterpret_cast<const CompilationCacheEntryProto*>(
               &_CompilationCacheEntryProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(CompilationCacheEntryProto& a, CompilationCacheEntryProto& b) {
    a.Swap(&b);
  }
  inline void Swap(CompilationCacheEntryProto* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CompilationCacheEntryProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CompilationCacheEntryProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CompilationCacheEntryProto>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CompilationCacheEntryProto& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CompilationCacheEntryProto& from) {
    CompilationCacheEntryProto::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CompilationCacheEntryProto* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xla.gpu.CompilationCacheEntryProto";
  }
  protected:
  explicit CompilationCacheEntryProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kFingerprintFieldNumber = 1,
    kBinaryFieldNumber = 5,
    kLaunchDimensionsFieldNumber = 2,
    kClusterDimFieldNumber = 3,
    kShmemBytesFieldNumber = 4,
  };
  // string fingerprint = 1;
  void clear_fingerprint();
  const std::string& fingerprint() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_fingerprint(ArgT0&& arg0, ArgT... args);
  std::string* mutable_fingerprint();
  PROTOBUF_NODISCARD std::string* release_fingerprint();
  void set_allocated_fingerprint(std::string* fingerprint);
  private:
  const std::string& _internal_fingerprint() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_fingerprint(const std::string& value);
  std::string* _internal_mutable_fingerprint();
  public:

  // bytes binary = 5;
  void clear_binary();
  const std::string& binary() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_binary(ArgT0&& arg0, ArgT... args);
  std::string* mutable_binary();
  PROTOBUF_NODISCARD std::string* release_binary();
  void set_allocated_binary(std::string* binary);
  private:
  const std::string& _internal_binary() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_binary(const std::string& value);
  std::string* _internal_mutable_binary();
  public:

  // .xla.gpu.LaunchDimensionsProto launch_dimensions = 2;
  bool has_launch_dimensions() const;
  private:
  bool _internal_has_launch_dimensions() const;
  public:
  void clear_launch_dimensions();
  const ::xla::gpu::LaunchDimensionsProto& launch_dimensions() const;
  PROTOBUF_NODISCARD ::xla::gpu::LaunchDimensionsProto* release_launch_dimensions();
  ::xla::gpu::LaunchDimensionsProto* mutable_launch_dimensions();
  void set_allocated_launch_dimensions(::xla::gpu::LaunchDimensionsProto* launch_dimensions);
  private:
  const ::xla::gpu::LaunchDimensionsProto& _internal_launch_dimensions() const;
  ::xla::gpu::LaunchDimensionsProto* _internal_mutable_launch_dimensions();
  public:
  void unsafe_arena_set_allocated_launch_dimensions(
      ::xla::gpu::LaunchDimensionsProto* launch_dimensions);
  ::xla::gpu::LaunchDimensionsProto* unsafe_arena_release_launch_dimensions();

  // optional .xla.gpu.ClusterDimProto cluster_dim = 3;
  bool has_cluster_dim() const;
  private:
  bool _internal_has_cluster_dim() const;
  public:
  void clear_cluster_dim();
  const ::xla::gpu::ClusterDimProto& cluster_dim() const;
  PROTOBUF_NODISCARD ::xla::gpu::ClusterDimProto* release_cluster_dim();
  ::xla::gpu::ClusterDimProto* mutable_cluster_dim();
  void set_allocated_cluster_dim(::xla::gpu::ClusterDimProto* cluster_dim);
  private:
  const ::xla::gpu::ClusterDimProto& _internal_cluster_dim() const;
  ::xla::gpu::ClusterDimProto* _internal_mutable_cluster_dim();
  public:
  void unsafe_arena_set_allocated_cluster_dim(
      ::xla::gpu::ClusterDimProto* cluster_dim);
  ::xla::gpu::ClusterDimProto* unsafe_arena_release_cluster_dim();

  // int64 shmem_bytes = 4;
  void clear_shmem_bytes();
  int64_t shmem_bytes() const;
  void set_shmem_bytes(int64_t value);
  private:
  int64_t _internal_shmem_bytes() const;
  void _internal_set_shmem_bytes(int64_t value);
  public:

  // @@protoc_insertion_point(class_scope:xla.gpu.CompilationCacheEntryProto)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fingerprint_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr binary_;
    ::xla::gpu::LaunchDimensionsProto* launch_dimensions_;
    ::xla::gpu::ClusterDimProto* cluster_dim_;
    int64_t shmem_bytes_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_xla_2fservice_2fgpu_2fexecutable_2eproto;
};
// -------------------------------------------------------------------

class CompilationCacheProto_EntriesEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<CompilationCacheProto_EntriesEntry_DoNotUse, 
    std::string, ::xla::gpu::CompilationCacheEntryProto,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
public:
  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<CompilationCacheProto_EntriesEntry_DoNotUse, 
    std::string, ::xla::gpu::CompilationCacheEntryProto,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
  CompilationCacheProto_EntriesEntry_DoNotUse();
  explicit PROTOBUF_CONSTEXPR CompilationCacheProto_EntriesEntry_DoNotUse(
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
  explicit CompilationCacheProto_EntriesEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void MergeFrom(const CompilationCacheProto_EntriesEntry_DoNotUse& other);
  static const CompilationCacheProto_EntriesEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const CompilationCacheProto_EntriesEntry_DoNotUse*>(&_CompilationCacheProto_EntriesEntry_DoNotUse_default_instance_); }
  static bool ValidateKey(std::string* s) {
    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "xla.gpu.CompilationCacheProto.EntriesEntry.key");
 }
  static bool ValidateValue(void*) { return true; }
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  friend struct ::TableStruct_xla_2fservice_2fgpu_2fexecutable_2eproto;
};

// -------------------------------------------------------------------

class CompilationCacheProto final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.gpu.CompilationCacheProto) */ {
 public:
  inline CompilationCacheProto() : CompilationCacheProto(nullptr) {}
  ~CompilationCacheProto() override;
  explicit PROTOBUF_CONSTEXPR CompilationCacheProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CompilationCacheProto(const CompilationCacheProto& from);
  CompilationCacheProto(CompilationCacheProto&& from) noexcept
    : CompilationCacheProto() {
    *this = ::std::move(from);
  }

  inline CompilationCacheProto& operator=(const CompilationCacheProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline CompilationCacheProto& operator=(CompilationCacheProto&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CompilationCacheProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const CompilationCacheProto* internal_default_instance() {
    return reinterpret_cast<const CompilationCacheProto*>(
               &_CompilationCacheProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  friend void swap(CompilationCacheProto& a, CompilationCacheProto& b) {
    a.Swap(&b);
  }
  inline void Swap(CompilationCacheProto* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CompilationCacheProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CompilationCacheProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CompilationCacheProto>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CompilationCacheProto& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CompilationCacheProto& from) {
    CompilationCacheProto::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CompilationCacheProto* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xla.gpu.CompilationCacheProto";
  }
  protected:
  explicit CompilationCacheProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------


  // accessors -------------------------------------------------------

  enum : int {
    kEntriesFieldNumber = 1,
  };
  // map<string, .xla.gpu.CompilationCacheEntryProto> entries = 1;
  int entries_size() const;
  private:
  int _internal_entries_size() const;
  public:
  void clear_entries();
  private:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::xla::gpu::CompilationCacheEntryProto >&
      _internal_entries() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::xla::gpu::CompilationCacheEntryProto >*
      _internal_mutable_entries();
  public:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::xla::gpu::CompilationCacheEntryProto >&
      entries() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::xla::gpu::CompilationCacheEntryProto >*
      mutable_entries();

  // @@protoc_insertion_point(class_scope:xla.gpu.CompilationCacheProto)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::MapField<
        CompilationCacheProto_EntriesEntry_DoNotUse,
        std::string, ::xla::gpu::CompilationCacheEntryProto,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> entries_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_xla_2fservice_2fgpu_2fexecutable_2eproto;
};
// ===================================================================


// ===================================================================

#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// -------------------------------------------------------------------

// CompilationResultProto

// .xla.HloModuleProtoWithConfig hlo_module_with_config = 1;
inline bool CompilationResultProto::_internal_has_hlo_module_with_config() const {
  return this != internal_default_instance() && _impl_.hlo_module_with_config_ != nullptr;
}
inline bool CompilationResultProto::has_hlo_module_with_config() const {
  return _internal_has_hlo_module_with_config();
}
inline const ::xla::HloModuleProtoWithConfig& CompilationResultProto::_internal_hlo_module_with_config() const {
  const ::xla::HloModuleProtoWithConfig* p = _impl_.hlo_module_with_config_;
  return p != nullptr ? *p : reinterpret_cast<const ::xla::HloModuleProtoWithConfig&>(
      ::xla::_HloModuleProtoWithConfig_default_instance_);
}
inline const ::xla::HloModuleProtoWithConfig& CompilationResultProto::hlo_module_with_config() const {
  // @@protoc_insertion_point(field_get:xla.gpu.CompilationResultProto.hlo_module_with_config)
  return _internal_hlo_module_with_config();
}
inline void CompilationResultProto::unsafe_arena_set_allocated_hlo_module_with_config(
    ::xla::HloModuleProtoWithConfig* hlo_module_with_config) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.hlo_module_with_config_);
  }
  _impl_.hlo_module_with_config_ = hlo_module_with_config;
  if (hlo_module_with_config) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.gpu.CompilationResultProto.hlo_module_with_config)
}
inline ::xla::HloModuleProtoWithConfig* CompilationResultProto::release_hlo_module_with_config() {
  
  ::xla::HloModuleProtoWithConfig* temp = _impl_.hlo_module_with_config_;
  _impl_.hlo_module_with_config_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::xla::HloModuleProtoWithConfig* CompilationResultProto::unsafe_arena_release_hlo_module_with_config() {
  // @@protoc_insertion_point(field_release:xla.gpu.CompilationResultProto.hlo_module_with_config)
  
  ::xla::HloModuleProtoWithConfig* temp = _impl_.hlo_module_with_config_;
  _impl_.hlo_module_with_config_ = nullptr;
  return temp;
}
inline ::xla::HloModuleProtoWithConfig* CompilationResultProto::_internal_mutable_hlo_module_with_config() {
  
  if (_impl_.hlo_module_with_config_ == nullptr) {
    auto* p = CreateMaybeMessage<::xla::HloModuleProtoWithConfig>(GetArenaForAllocation());
    _impl_.hlo_module_with_config_ = p;
  }
  return _impl_.hlo_module_with_config_;
}
inline ::xla::HloModuleProtoWithConfig* CompilationResultProto::mutable_hlo_module_with_config() {
  ::xla::HloModuleProtoWithConfig* _msg = _internal_mutable_hlo_module_with_config();
  // @@protoc_insertion_point(field_mutable:xla.gpu.CompilationResultProto.hlo_module_with_config)
  return _msg;
}
inline void CompilationResultProto::set_allocated_hlo_module_with_config(::xla::HloModuleProtoWithConfig* hlo_module_with_config) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.hlo_module_with_config_);
  }
  if (hlo_module_with_config) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(hlo_module_with_config));
    if (message_arena != submessage_arena) {
      hlo_module_with_config = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, hlo_module_with_config, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.hlo_module_with_config_ = hlo_module_with_config;
  // @@protoc_insertion_point(field_set_allocated:xla.gpu.CompilationResultProto.hlo_module_with_config)
}

// .xla.BufferAssignmentProto buffer_assignment = 2;
inline bool CompilationResultProto::_internal_has_buffer_assignment() const {
  return this != internal_default_instance() && _impl_.buffer_assignment_ != nullptr;
}
inline bool CompilationResultProto::has_buffer_assignment() const {
  return _internal_has_buffer_assignment();
}
inline const ::xla::BufferAssignmentProto& CompilationResultProto::_internal_buffer_assignment() const {
  const ::xla::BufferAssignmentProto* p = _impl_.buffer_assignment_;
  return p != nullptr ? *p : reinterpret_cast<const ::xla::BufferAssignmentProto&>(
      ::xla::_BufferAssignmentProto_default_instance_);
}
inline const ::xla::BufferAssignmentProto& CompilationResultProto::buffer_assignment() const {
  // @@protoc_insertion_point(field_get:xla.gpu.CompilationResultProto.buffer_assignment)
  return _internal_buffer_assignment();
}
inline void CompilationResultProto::unsafe_arena_set_allocated_buffer_assignment(
    ::xla::BufferAssignmentProto* buffer_assignment) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.buffer_assignment_);
  }
  _impl_.buffer_assignment_ = buffer_assignment;
  if (buffer_assignment) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.gpu.CompilationResultProto.buffer_assignment)
}
inline ::xla::BufferAssignmentProto* CompilationResultProto::release_buffer_assignment() {
  
  ::xla::BufferAssignmentProto* temp = _impl_.buffer_assignment_;
  _impl_.buffer_assignment_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::xla::BufferAssignmentProto* CompilationResultProto::unsafe_arena_release_buffer_assignment() {
  // @@protoc_insertion_point(field_release:xla.gpu.CompilationResultProto.buffer_assignment)
  
  ::xla::BufferAssignmentProto* temp = _impl_.buffer_assignment_;
  _impl_.buffer_assignment_ = nullptr;
  return temp;
}
inline ::xla::BufferAssignmentProto* CompilationResultProto::_internal_mutable_buffer_assignment() {
  
  if (_impl_.buffer_assignment_ == nullptr) {
    auto* p = CreateMaybeMessage<::xla::BufferAssignmentProto>(GetArenaForAllocation());
    _impl_.buffer_assignment_ = p;
  }
  return _impl_.buffer_assignment_;
}
inline ::xla::BufferAssignmentProto* CompilationResultProto::mutable_buffer_assignment() {
  ::xla::BufferAssignmentProto* _msg = _internal_mutable_buffer_assignment();
  // @@protoc_insertion_point(field_mutable:xla.gpu.CompilationResultProto.buffer_assignment)
  return _msg;
}
inline void CompilationResultProto::set_allocated_buffer_assignment(::xla::BufferAssignmentProto* buffer_assignment) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.buffer_assignment_);
  }
  if (buffer_assignment) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(buffer_assignment));
    if (message_arena != submessage_arena) {
      buffer_assignment = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, buffer_assignment, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.buffer_assignment_ = buffer_assignment;
  // @@protoc_insertion_point(field_set_allocated:xla.gpu.CompilationResultProto.buffer_assignment)
}

// string asm_text = 3;
inline void CompilationResultProto::clear_asm_text() {
  _impl_.asm_text_.ClearToEmpty();
}
inline const std::string& CompilationResultProto::asm_text() const {
  // @@protoc_insertion_point(field_get:xla.gpu.CompilationResultProto.asm_text)
  return _internal_asm_text();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CompilationResultProto::set_asm_text(ArgT0&& arg0, ArgT... args) {
 
 _impl_.asm_text_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:xla.gpu.CompilationResultProto.asm_text)
}
inline std::string* CompilationResultProto::mutable_asm_text() {
  std::string* _s = _internal_mutable_asm_text();
  // @@protoc_insertion_point(field_mutable:xla.gpu.CompilationResultProto.asm_text)
  return _s;
}
inline const std::string& CompilationResultProto::_internal_asm_text() const {
  return _impl_.asm_text_.Get();
}
inline void CompilationResultProto::_internal_set_asm_text(const std::string& value) {
  
  _impl_.asm_text_.Set(value, GetArenaForAllocation());
}
inline std::string* CompilationResultProto::_internal_mutable_asm_text() {
  
  return _impl_.asm_text_.Mutable(GetArenaForAllocation());
}
inline std::string* CompilationResultProto::release_asm_text() {
  // @@protoc_insertion_point(field_release:xla.gpu.CompilationResultProto.asm_text)
  return _impl_.asm_text_.Release();
}
inline void CompilationResultProto::set_allocated_asm_text(std::string* asm_text) {
  if (asm_text != nullptr) {
    
  } else {
    
  }
  _impl_.asm_text_.SetAllocated(asm_text, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.asm_text_.IsDefault()) {
    _impl_.asm_text_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:xla.gpu.CompilationResultProto.asm_text)
}

// bytes binary = 4;
inline void CompilationResultProto::clear_binary() {
  _impl_.binary_.ClearToEmpty();
}
inline const std::string& CompilationResultProto::binary() const {
  // @@protoc_insertion_point(field_get:xla.gpu.CompilationResultProto.binary)
  return _internal_binary();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CompilationResultProto::set_binary(ArgT0&& arg0, ArgT... args) {
 
 _impl_.binary_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:xla.gpu.CompilationResultProto.binary)
}
inline std::string* CompilationResultProto::mutable_binary() {
  std::string* _s = _internal_mutable_binary();
  // @@protoc_insertion_point(field_mutable:xla.gpu.CompilationResultProto.binary)
  return _s;
}
inline const std::string& CompilationResultProto::_internal_binary() const {
  return _impl_.binary_.Get();
}
inline void CompilationResultProto::_internal_set_binary(const std::string& value) {
  
  _impl_.binary_.Set(value, GetArenaForAllocation());
}
inline std::string* CompilationResultProto::_internal_mutable_binary() {
  
  return _impl_.binary_.Mutable(GetArenaForAllocation());
}
inline std::string* CompilationResultProto::release_binary() {
  // @@protoc_insertion_point(field_release:xla.gpu.CompilationResultProto.binary)
  return _impl_.binary_.Release();
}
inline void CompilationResultProto::set_allocated_binary(std::string* binary) {
  if (binary != nullptr) {
    
  } else {
    
  }
  _impl_.binary_.SetAllocated(binary, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.binary_.IsDefault()) {
    _impl_.binary_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:xla.gpu.CompilationResultProto.binary)
}

// map<string, bytes> dnn_compiled_graphs = 5;
inline int CompilationResultProto::_internal_dnn_compiled_graphs_size() const {
  return _impl_.dnn_compiled_graphs_.size();
}
inline int CompilationResultProto::dnn_compiled_graphs_size() const {
  return _internal_dnn_compiled_graphs_size();
}
inline void CompilationResultProto::clear_dnn_compiled_graphs() {
  _impl_.dnn_compiled_graphs_.Clear();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
CompilationResultProto::_internal_dnn_compiled_graphs() const {
  return _impl_.dnn_compiled_graphs_.GetMap();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
CompilationResultProto::dnn_compiled_graphs() const {
  // @@protoc_insertion_point(field_map:xla.gpu.CompilationResultProto.dnn_compiled_graphs)
  return _internal_dnn_compiled_graphs();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
CompilationResultProto::_internal_mutable_dnn_compiled_graphs() {
  return _impl_.dnn_compiled_graphs_.MutableMap();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
CompilationResultProto::mutable_dnn_compiled_graphs() {
  // @@protoc_insertion_point(field_mutable_map:xla.gpu.CompilationResultProto.dnn_compiled_graphs)
  return _internal_mutable_dnn_compiled_graphs();
}

// -------------------------------------------------------------------

// LaunchDimensionsProto

// uint64 num_blocks = 1;
inline void LaunchDimensionsProto::clear_num_blocks() {
  _impl_.num_blocks_ = uint64_t{0u};
}
inline uint64_t LaunchDimensionsProto::_internal_num_blocks() const {
  return _impl_.num_blocks_;
}
inline uint64_t LaunchDimensionsProto::num_blocks() const {
  // @@protoc_insertion_point(field_get:xla.gpu.LaunchDimensionsProto.num_blocks)
  return _internal_num_blocks();
}
inline void LaunchDimensionsProto::_internal_set_num_blocks(uint64_t value) {
  
  _impl_.num_blocks_ = value;
}
inline void LaunchDimensionsProto::set_num_blocks(uint64_t value) {
  _internal_set_num_blocks(value);
  // @@protoc_insertion_point(field_set:xla.gpu.LaunchDimensionsProto.num_blocks)
}

// uint64 num_threads_per_block = 2;
inline void LaunchDimensionsProto::clear_num_threads_per_block() {
  _impl_.num_threads_per_block_ = uint64_t{0u};
}
inline uint64_t LaunchDimensionsProto::_internal_num_threads_per_block() const {
  return _impl_.num_threads_per_block_;
}
inline uint64_t LaunchDimensionsProto::num_threads_per_block() const {
  // @@protoc_insertion_point(field_get:xla.gpu.LaunchDimensionsProto.num_threads_per_block)
  return _internal_num_threads_per_block();
}
inline void LaunchDimensionsProto::_internal_set_num_threads_per_block(uint64_t value) {
  
  _impl_.num_threads_per_block_ = value;
}
inline void LaunchDimensionsProto::set_num_threads_per_block(uint64_t value) {
  _internal_set_num_threads_per_block(value);
  // @@protoc_insertion_point(field_set:xla.gpu.LaunchDimensionsProto.num_threads_per_block)
}

// -------------------------------------------------------------------

// ClusterDimProto

// uint64 x = 1;
inline void ClusterDimProto::clear_x() {
  _impl_.x_ = uint64_t{0u};
}
inline uint64_t ClusterDimProto::_internal_x() const {
  return _impl_.x_;
}
inline uint64_t ClusterDimProto::x() const {
  // @@protoc_insertion_point(field_get:xla.gpu.ClusterDimProto.x)
  return _internal_x();
}
inline void ClusterDimProto::_internal_set_x(uint64_t value) {
  
  _impl_.x_ = value;
}
inline void ClusterDimProto::set_x(uint64_t value) {
  _internal_set_x(value);
  // @@protoc_insertion_point(field_set:xla.gpu.ClusterDimProto.x)
}

// uint64 y = 2;
inline void ClusterDimProto::clear_y() {
  _impl_.y_ = uint64_t{0u};
}
inline uint64_t ClusterDimProto::_internal_y() const {
  return _impl_.y_;
}
inline uint64_t ClusterDimProto::y() const {
  // @@protoc_insertion_point(field_get:xla.gpu.ClusterDimProto.y)
  return _internal_y();
}
inline void ClusterDimProto::_internal_set_y(uint64_t value) {
  
  _impl_.y_ = value;
}
inline void ClusterDimProto::set_y(uint64_t value) {
  _internal_set_y(value);
  // @@protoc_insertion_point(field_set:xla.gpu.ClusterDimProto.y)
}

// uint64 z = 3;
inline void ClusterDimProto::clear_z() {
  _impl_.z_ = uint64_t{0u};
}
inline uint64_t ClusterDimProto::_internal_z() const {
  return _impl_.z_;
}
inline uint64_t ClusterDimProto::z() const {
  // @@protoc_insertion_point(field_get:xla.gpu.ClusterDimProto.z)
  return _internal_z();
}
inline void ClusterDimProto::_internal_set_z(uint64_t value) {
  
  _impl_.z_ = value;
}
inline void ClusterDimProto::set_z(uint64_t value) {
  _internal_set_z(value);
  // @@protoc_insertion_point(field_set:xla.gpu.ClusterDimProto.z)
}

// -------------------------------------------------------------------

// CompilationCacheEntryProto

// string fingerprint = 1;
inline void CompilationCacheEntryProto::clear_fingerprint() {
  _impl_.fingerprint_.ClearToEmpty();
}
inline const std::string& CompilationCacheEntryProto::fingerprint() const {
  // @@protoc_insertion_point(field_get:xla.gpu.CompilationCacheEntryProto.fingerprint)
  return _internal_fingerprint();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CompilationCacheEntryProto::set_fingerprint(ArgT0&& arg0, ArgT... args) {
 
 _impl_.fingerprint_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:xla.gpu.CompilationCacheEntryProto.fingerprint)
}
inline std::string* CompilationCacheEntryProto::mutable_fingerprint() {
  std::string* _s = _internal_mutable_fingerprint();
  // @@protoc_insertion_point(field_mutable:xla.gpu.CompilationCacheEntryProto.fingerprint)
  return _s;
}
inline const std::string& CompilationCacheEntryProto::_internal_fingerprint() const {
  return _impl_.fingerprint_.Get();
}
inline void CompilationCacheEntryProto::_internal_set_fingerprint(const std::string& value) {
  
  _impl_.fingerprint_.Set(value, GetArenaForAllocation());
}
inline std::string* CompilationCacheEntryProto::_internal_mutable_fingerprint() {
  
  return _impl_.fingerprint_.Mutable(GetArenaForAllocation());
}
inline std::string* CompilationCacheEntryProto::release_fingerprint() {
  // @@protoc_insertion_point(field_release:xla.gpu.CompilationCacheEntryProto.fingerprint)
  return _impl_.fingerprint_.Release();
}
inline void CompilationCacheEntryProto::set_allocated_fingerprint(std::string* fingerprint) {
  if (fingerprint != nullptr) {
    
  } else {
    
  }
  _impl_.fingerprint_.SetAllocated(fingerprint, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.fingerprint_.IsDefault()) {
    _impl_.fingerprint_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:xla.gpu.CompilationCacheEntryProto.fingerprint)
}

// .xla.gpu.LaunchDimensionsProto launch_dimensions = 2;
inline bool CompilationCacheEntryProto::_internal_has_launch_dimensions() const {
  return this != internal_default_instance() && _impl_.launch_dimensions_ != nullptr;
}
inline bool CompilationCacheEntryProto::has_launch_dimensions() const {
  return _internal_has_launch_dimensions();
}
inline void CompilationCacheEntryProto::clear_launch_dimensions() {
  if (GetArenaForAllocation() == nullptr && _impl_.launch_dimensions_ != nullptr) {
    delete _impl_.launch_dimensions_;
  }
  _impl_.launch_dimensions_ = nullptr;
}
inline const ::xla::gpu::LaunchDimensionsProto& CompilationCacheEntryProto::_internal_launch_dimensions() const {
  const ::xla::gpu::LaunchDimensionsProto* p = _impl_.launch_dimensions_;
  return p != nullptr ? *p : reinterpret_cast<const ::xla::gpu::LaunchDimensionsProto&>(
      ::xla::gpu::_LaunchDimensionsProto_default_instance_);
}
inline const ::xla::gpu::LaunchDimensionsProto& CompilationCacheEntryProto::launch_dimensions() const {
  // @@protoc_insertion_point(field_get:xla.gpu.CompilationCacheEntryProto.launch_dimensions)
  return _internal_launch_dimensions();
}
inline void CompilationCacheEntryProto::unsafe_arena_set_allocated_launch_dimensions(
    ::xla::gpu::LaunchDimensionsProto* launch_dimensions) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.launch_dimensions_);
  }
  _impl_.launch_dimensions_ = launch_dimensions;
  if (launch_dimensions) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.gpu.CompilationCacheEntryProto.launch_dimensions)
}
inline ::xla::gpu::LaunchDimensionsProto* CompilationCacheEntryProto::release_launch_dimensions() {
  
  ::xla::gpu::LaunchDimensionsProto* temp = _impl_.launch_dimensions_;
  _impl_.launch_dimensions_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::xla::gpu::LaunchDimensionsProto* CompilationCacheEntryProto::unsafe_arena_release_launch_dimensions() {
  // @@protoc_insertion_point(field_release:xla.gpu.CompilationCacheEntryProto.launch_dimensions)
  
  ::xla::gpu::LaunchDimensionsProto* temp = _impl_.launch_dimensions_;
  _impl_.launch_dimensions_ = nullptr;
  return temp;
}
inline ::xla::gpu::LaunchDimensionsProto* CompilationCacheEntryProto::_internal_mutable_launch_dimensions() {
  
  if (_impl_.launch_dimensions_ == nullptr) {
    auto* p = CreateMaybeMessage<::xla::gpu::LaunchDimensionsProto>(GetArenaForAllocation());
    _impl_.launch_dimensions_ = p;
  }
  return _impl_.launch_dimensions_;
}
inline ::xla::gpu::LaunchDimensionsProto* CompilationCacheEntryProto::mutable_launch_dimensions() {
  ::xla::gpu::LaunchDimensionsProto* _msg = _internal_mutable_launch_dimensions();
  // @@protoc_insertion_point(field_mutable:xla.gpu.CompilationCacheEntryProto.launch_dimensions)
  return _msg;
}
inline void CompilationCacheEntryProto::set_allocated_launch_dimensions(::xla::gpu::LaunchDimensionsProto* launch_dimensions) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.launch_dimensions_;
  }
  if (launch_dimensions) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(launch_dimensions);
    if (message_arena != submessage_arena) {
      launch_dimensions = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, launch_dimensions, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.launch_dimensions_ = launch_dimensions;
  // @@protoc_insertion_point(field_set_allocated:xla.gpu.CompilationCacheEntryProto.launch_dimensions)
}

// optional .xla.gpu.ClusterDimProto cluster_dim = 3;
inline bool CompilationCacheEntryProto::_internal_has_cluster_dim() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.cluster_dim_ != nullptr);
  return value;
}
inline bool CompilationCacheEntryProto::has_cluster_dim() const {
  return _internal_has_cluster_dim();
}
inline void CompilationCacheEntryProto::clear_cluster_dim() {
  if (_impl_.cluster_dim_ != nullptr) _impl_.cluster_dim_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::xla::gpu::ClusterDimProto& CompilationCacheEntryProto::_internal_cluster_dim() const {
  const ::xla::gpu::ClusterDimProto* p = _impl_.cluster_dim_;
  return p != nullptr ? *p : reinterpret_cast<const ::xla::gpu::ClusterDimProto&>(
      ::xla::gpu::_ClusterDimProto_default_instance_);
}
inline const ::xla::gpu::ClusterDimProto& CompilationCacheEntryProto::cluster_dim() const {
  // @@protoc_insertion_point(field_get:xla.gpu.CompilationCacheEntryProto.cluster_dim)
  return _internal_cluster_dim();
}
inline void CompilationCacheEntryProto::unsafe_arena_set_allocated_cluster_dim(
    ::xla::gpu::ClusterDimProto* cluster_dim) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.cluster_dim_);
  }
  _impl_.cluster_dim_ = cluster_dim;
  if (cluster_dim) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.gpu.CompilationCacheEntryProto.cluster_dim)
}
inline ::xla::gpu::ClusterDimProto* CompilationCacheEntryProto::release_cluster_dim() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::xla::gpu::ClusterDimProto* temp = _impl_.cluster_dim_;
  _impl_.cluster_dim_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::xla::gpu::ClusterDimProto* CompilationCacheEntryProto::unsafe_arena_release_cluster_dim() {
  // @@protoc_insertion_point(field_release:xla.gpu.CompilationCacheEntryProto.cluster_dim)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::xla::gpu::ClusterDimProto* temp = _impl_.cluster_dim_;
  _impl_.cluster_dim_ = nullptr;
  return temp;
}
inline ::xla::gpu::ClusterDimProto* CompilationCacheEntryProto::_internal_mutable_cluster_dim() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.cluster_dim_ == nullptr) {
    auto* p = CreateMaybeMessage<::xla::gpu::ClusterDimProto>(GetArenaForAllocation());
    _impl_.cluster_dim_ = p;
  }
  return _impl_.cluster_dim_;
}
inline ::xla::gpu::ClusterDimProto* CompilationCacheEntryProto::mutable_cluster_dim() {
  ::xla::gpu::ClusterDimProto* _msg = _internal_mutable_cluster_dim();
  // @@protoc_insertion_point(field_mutable:xla.gpu.CompilationCacheEntryProto.cluster_dim)
  return _msg;
}
inline void CompilationCacheEntryProto::set_allocated_cluster_dim(::xla::gpu::ClusterDimProto* cluster_dim) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.cluster_dim_;
  }
  if (cluster_dim) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(cluster_dim);
    if (message_arena != submessage_arena) {
      cluster_dim = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, cluster_dim, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.cluster_dim_ = cluster_dim;
  // @@protoc_insertion_point(field_set_allocated:xla.gpu.CompilationCacheEntryProto.cluster_dim)
}

// int64 shmem_bytes = 4;
inline void CompilationCacheEntryProto::clear_shmem_bytes() {
  _impl_.shmem_bytes_ = int64_t{0};
}
inline int64_t CompilationCacheEntryProto::_internal_shmem_bytes() const {
  return _impl_.shmem_bytes_;
}
inline int64_t CompilationCacheEntryProto::shmem_bytes() const {
  // @@protoc_insertion_point(field_get:xla.gpu.CompilationCacheEntryProto.shmem_bytes)
  return _internal_shmem_bytes();
}
inline void CompilationCacheEntryProto::_internal_set_shmem_bytes(int64_t value) {
  
  _impl_.shmem_bytes_ = value;
}
inline void CompilationCacheEntryProto::set_shmem_bytes(int64_t value) {
  _internal_set_shmem_bytes(value);
  // @@protoc_insertion_point(field_set:xla.gpu.CompilationCacheEntryProto.shmem_bytes)
}

// bytes binary = 5;
inline void CompilationCacheEntryProto::clear_binary() {
  _impl_.binary_.ClearToEmpty();
}
inline const std::string& CompilationCacheEntryProto::binary() const {
  // @@protoc_insertion_point(field_get:xla.gpu.CompilationCacheEntryProto.binary)
  return _internal_binary();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CompilationCacheEntryProto::set_binary(ArgT0&& arg0, ArgT... args) {
 
 _impl_.binary_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:xla.gpu.CompilationCacheEntryProto.binary)
}
inline std::string* CompilationCacheEntryProto::mutable_binary() {
  std::string* _s = _internal_mutable_binary();
  // @@protoc_insertion_point(field_mutable:xla.gpu.CompilationCacheEntryProto.binary)
  return _s;
}
inline const std::string& CompilationCacheEntryProto::_internal_binary() const {
  return _impl_.binary_.Get();
}
inline void CompilationCacheEntryProto::_internal_set_binary(const std::string& value) {
  
  _impl_.binary_.Set(value, GetArenaForAllocation());
}
inline std::string* CompilationCacheEntryProto::_internal_mutable_binary() {
  
  return _impl_.binary_.Mutable(GetArenaForAllocation());
}
inline std::string* CompilationCacheEntryProto::release_binary() {
  // @@protoc_insertion_point(field_release:xla.gpu.CompilationCacheEntryProto.binary)
  return _impl_.binary_.Release();
}
inline void CompilationCacheEntryProto::set_allocated_binary(std::string* binary) {
  if (binary != nullptr) {
    
  } else {
    
  }
  _impl_.binary_.SetAllocated(binary, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.binary_.IsDefault()) {
    _impl_.binary_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:xla.gpu.CompilationCacheEntryProto.binary)
}

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// CompilationCacheProto

// map<string, .xla.gpu.CompilationCacheEntryProto> entries = 1;
inline int CompilationCacheProto::_internal_entries_size() const {
  return _impl_.entries_.size();
}
inline int CompilationCacheProto::entries_size() const {
  return _internal_entries_size();
}
inline void CompilationCacheProto::clear_entries() {
  _impl_.entries_.Clear();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::xla::gpu::CompilationCacheEntryProto >&
CompilationCacheProto::_internal_entries() const {
  return _impl_.entries_.GetMap();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::xla::gpu::CompilationCacheEntryProto >&
CompilationCacheProto::entries() const {
  // @@protoc_insertion_point(field_map:xla.gpu.CompilationCacheProto.entries)
  return _internal_entries();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::xla::gpu::CompilationCacheEntryProto >*
CompilationCacheProto::_internal_mutable_entries() {
  return _impl_.entries_.MutableMap();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::xla::gpu::CompilationCacheEntryProto >*
CompilationCacheProto::mutable_entries() {
  // @@protoc_insertion_point(field_mutable_map:xla.gpu.CompilationCacheProto.entries)
  return _internal_mutable_entries();
}

#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------


// @@protoc_insertion_point(namespace_scope)

}  // namespace gpu
}  // namespace xla

// @@protoc_insertion_point(global_scope)

#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_xla_2fservice_2fgpu_2fexecutable_2eproto