// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: tensorflow/compiler/xla/pjrt/distributed/protocol.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3009000
#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 3009002 < 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_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/inlined_string_field.h>
#include <google/protobuf/metadata.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/unknown_field_set.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto {
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxillaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[17]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto;
namespace xla {
class ConnectRequest;
class ConnectRequestDefaultTypeInternal;
extern ConnectRequestDefaultTypeInternal _ConnectRequest_default_instance_;
class ConnectResponse;
class ConnectResponseDefaultTypeInternal;
extern ConnectResponseDefaultTypeInternal _ConnectResponse_default_instance_;
class DeviceProto;
class DeviceProtoDefaultTypeInternal;
extern DeviceProtoDefaultTypeInternal _DeviceProto_default_instance_;
class EnumerateDevicesRequest;
class EnumerateDevicesRequestDefaultTypeInternal;
extern EnumerateDevicesRequestDefaultTypeInternal _EnumerateDevicesRequest_default_instance_;
class EnumerateDevicesResponse;
class EnumerateDevicesResponseDefaultTypeInternal;
extern EnumerateDevicesResponseDefaultTypeInternal _EnumerateDevicesResponse_default_instance_;
class GlobalTopologyProto;
class GlobalTopologyProtoDefaultTypeInternal;
extern GlobalTopologyProtoDefaultTypeInternal _GlobalTopologyProto_default_instance_;
class HeartbeatRequest;
class HeartbeatRequestDefaultTypeInternal;
extern HeartbeatRequestDefaultTypeInternal _HeartbeatRequest_default_instance_;
class HeartbeatResponse;
class HeartbeatResponseDefaultTypeInternal;
extern HeartbeatResponseDefaultTypeInternal _HeartbeatResponse_default_instance_;
class KeyValueGetRequest;
class KeyValueGetRequestDefaultTypeInternal;
extern KeyValueGetRequestDefaultTypeInternal _KeyValueGetRequest_default_instance_;
class KeyValueGetResponse;
class KeyValueGetResponseDefaultTypeInternal;
extern KeyValueGetResponseDefaultTypeInternal _KeyValueGetResponse_default_instance_;
class KeyValueSetRequest;
class KeyValueSetRequestDefaultTypeInternal;
extern KeyValueSetRequestDefaultTypeInternal _KeyValueSetRequest_default_instance_;
class KeyValueSetResponse;
class KeyValueSetResponseDefaultTypeInternal;
extern KeyValueSetResponseDefaultTypeInternal _KeyValueSetResponse_default_instance_;
class LocalTopologyProto;
class LocalTopologyProtoDefaultTypeInternal;
extern LocalTopologyProtoDefaultTypeInternal _LocalTopologyProto_default_instance_;
class ShutdownRequest;
class ShutdownRequestDefaultTypeInternal;
extern ShutdownRequestDefaultTypeInternal _ShutdownRequest_default_instance_;
class ShutdownResponse;
class ShutdownResponseDefaultTypeInternal;
extern ShutdownResponseDefaultTypeInternal _ShutdownResponse_default_instance_;
class WaitAtBarrierRequest;
class WaitAtBarrierRequestDefaultTypeInternal;
extern WaitAtBarrierRequestDefaultTypeInternal _WaitAtBarrierRequest_default_instance_;
class WaitAtBarrierResponse;
class WaitAtBarrierResponseDefaultTypeInternal;
extern WaitAtBarrierResponseDefaultTypeInternal _WaitAtBarrierResponse_default_instance_;
}  // namespace xla
PROTOBUF_NAMESPACE_OPEN
template<> ::xla::ConnectRequest* Arena::CreateMaybeMessage<::xla::ConnectRequest>(Arena*);
template<> ::xla::ConnectResponse* Arena::CreateMaybeMessage<::xla::ConnectResponse>(Arena*);
template<> ::xla::DeviceProto* Arena::CreateMaybeMessage<::xla::DeviceProto>(Arena*);
template<> ::xla::EnumerateDevicesRequest* Arena::CreateMaybeMessage<::xla::EnumerateDevicesRequest>(Arena*);
template<> ::xla::EnumerateDevicesResponse* Arena::CreateMaybeMessage<::xla::EnumerateDevicesResponse>(Arena*);
template<> ::xla::GlobalTopologyProto* Arena::CreateMaybeMessage<::xla::GlobalTopologyProto>(Arena*);
template<> ::xla::HeartbeatRequest* Arena::CreateMaybeMessage<::xla::HeartbeatRequest>(Arena*);
template<> ::xla::HeartbeatResponse* Arena::CreateMaybeMessage<::xla::HeartbeatResponse>(Arena*);
template<> ::xla::KeyValueGetRequest* Arena::CreateMaybeMessage<::xla::KeyValueGetRequest>(Arena*);
template<> ::xla::KeyValueGetResponse* Arena::CreateMaybeMessage<::xla::KeyValueGetResponse>(Arena*);
template<> ::xla::KeyValueSetRequest* Arena::CreateMaybeMessage<::xla::KeyValueSetRequest>(Arena*);
template<> ::xla::KeyValueSetResponse* Arena::CreateMaybeMessage<::xla::KeyValueSetResponse>(Arena*);
template<> ::xla::LocalTopologyProto* Arena::CreateMaybeMessage<::xla::LocalTopologyProto>(Arena*);
template<> ::xla::ShutdownRequest* Arena::CreateMaybeMessage<::xla::ShutdownRequest>(Arena*);
template<> ::xla::ShutdownResponse* Arena::CreateMaybeMessage<::xla::ShutdownResponse>(Arena*);
template<> ::xla::WaitAtBarrierRequest* Arena::CreateMaybeMessage<::xla::WaitAtBarrierRequest>(Arena*);
template<> ::xla::WaitAtBarrierResponse* Arena::CreateMaybeMessage<::xla::WaitAtBarrierResponse>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace xla {

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

class DeviceProto :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.DeviceProto) */ {
 public:
  DeviceProto();
  virtual ~DeviceProto();

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

  inline DeviceProto& operator=(const DeviceProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline DeviceProto& operator=(DeviceProto&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const DeviceProto& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const DeviceProto* internal_default_instance() {
    return reinterpret_cast<const DeviceProto*>(
               &_DeviceProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(DeviceProto& a, DeviceProto& b) {
    a.Swap(&b);
  }
  inline void Swap(DeviceProto* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline DeviceProto* New() const final {
    return CreateMaybeMessage<DeviceProto>(nullptr);
  }

  DeviceProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<DeviceProto>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const DeviceProto& from);
  void MergeFrom(const DeviceProto& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(DeviceProto* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xla.DeviceProto";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto);
    return ::descriptor_table_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kNameFieldNumber = 2,
    kVendorFieldNumber = 3,
    kLocalDeviceOrdinalFieldNumber = 1,
    kGlobalDeviceIdFieldNumber = 4,
  };
  // string name = 2;
  void clear_name();
  const std::string& name() const;
  void set_name(const std::string& value);
  void set_name(std::string&& value);
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  std::string* mutable_name();
  std::string* release_name();
  void set_allocated_name(std::string* name);

  // string vendor = 3;
  void clear_vendor();
  const std::string& vendor() const;
  void set_vendor(const std::string& value);
  void set_vendor(std::string&& value);
  void set_vendor(const char* value);
  void set_vendor(const char* value, size_t size);
  std::string* mutable_vendor();
  std::string* release_vendor();
  void set_allocated_vendor(std::string* vendor);

  // int32 local_device_ordinal = 1;
  void clear_local_device_ordinal();
  ::PROTOBUF_NAMESPACE_ID::int32 local_device_ordinal() const;
  void set_local_device_ordinal(::PROTOBUF_NAMESPACE_ID::int32 value);

  // int32 global_device_id = 4;
  void clear_global_device_id();
  ::PROTOBUF_NAMESPACE_ID::int32 global_device_id() const;
  void set_global_device_id(::PROTOBUF_NAMESPACE_ID::int32 value);

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr vendor_;
  ::PROTOBUF_NAMESPACE_ID::int32 local_device_ordinal_;
  ::PROTOBUF_NAMESPACE_ID::int32 global_device_id_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto;
};
// -------------------------------------------------------------------

class LocalTopologyProto :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.LocalTopologyProto) */ {
 public:
  LocalTopologyProto();
  virtual ~LocalTopologyProto();

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

  inline LocalTopologyProto& operator=(const LocalTopologyProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline LocalTopologyProto& operator=(LocalTopologyProto&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const LocalTopologyProto& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const LocalTopologyProto* internal_default_instance() {
    return reinterpret_cast<const LocalTopologyProto*>(
               &_LocalTopologyProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(LocalTopologyProto& a, LocalTopologyProto& b) {
    a.Swap(&b);
  }
  inline void Swap(LocalTopologyProto* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline LocalTopologyProto* New() const final {
    return CreateMaybeMessage<LocalTopologyProto>(nullptr);
  }

  LocalTopologyProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<LocalTopologyProto>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const LocalTopologyProto& from);
  void MergeFrom(const LocalTopologyProto& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LocalTopologyProto* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xla.LocalTopologyProto";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto);
    return ::descriptor_table_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kDevicesFieldNumber = 2,
    kNodeIdFieldNumber = 1,
  };
  // repeated .xla.DeviceProto devices = 2;
  int devices_size() const;
  void clear_devices();
  ::xla::DeviceProto* mutable_devices(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::DeviceProto >*
      mutable_devices();
  const ::xla::DeviceProto& devices(int index) const;
  ::xla::DeviceProto* add_devices();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::DeviceProto >&
      devices() const;

  // int32 node_id = 1;
  void clear_node_id();
  ::PROTOBUF_NAMESPACE_ID::int32 node_id() const;
  void set_node_id(::PROTOBUF_NAMESPACE_ID::int32 value);

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::DeviceProto > devices_;
  ::PROTOBUF_NAMESPACE_ID::int32 node_id_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto;
};
// -------------------------------------------------------------------

class GlobalTopologyProto :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.GlobalTopologyProto) */ {
 public:
  GlobalTopologyProto();
  virtual ~GlobalTopologyProto();

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

  inline GlobalTopologyProto& operator=(const GlobalTopologyProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline GlobalTopologyProto& operator=(GlobalTopologyProto&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const GlobalTopologyProto& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const GlobalTopologyProto* internal_default_instance() {
    return reinterpret_cast<const GlobalTopologyProto*>(
               &_GlobalTopologyProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(GlobalTopologyProto& a, GlobalTopologyProto& b) {
    a.Swap(&b);
  }
  inline void Swap(GlobalTopologyProto* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline GlobalTopologyProto* New() const final {
    return CreateMaybeMessage<GlobalTopologyProto>(nullptr);
  }

  GlobalTopologyProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GlobalTopologyProto>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GlobalTopologyProto& from);
  void MergeFrom(const GlobalTopologyProto& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(GlobalTopologyProto* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xla.GlobalTopologyProto";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto);
    return ::descriptor_table_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kNodesFieldNumber = 1,
  };
  // repeated .xla.LocalTopologyProto nodes = 1;
  int nodes_size() const;
  void clear_nodes();
  ::xla::LocalTopologyProto* mutable_nodes(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::LocalTopologyProto >*
      mutable_nodes();
  const ::xla::LocalTopologyProto& nodes(int index) const;
  ::xla::LocalTopologyProto* add_nodes();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::LocalTopologyProto >&
      nodes() const;

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::LocalTopologyProto > nodes_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto;
};
// -------------------------------------------------------------------

class ConnectRequest :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.ConnectRequest) */ {
 public:
  ConnectRequest();
  virtual ~ConnectRequest();

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

  inline ConnectRequest& operator=(const ConnectRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline ConnectRequest& operator=(ConnectRequest&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const ConnectRequest& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ConnectRequest* internal_default_instance() {
    return reinterpret_cast<const ConnectRequest*>(
               &_ConnectRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(ConnectRequest& a, ConnectRequest& b) {
    a.Swap(&b);
  }
  inline void Swap(ConnectRequest* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline ConnectRequest* New() const final {
    return CreateMaybeMessage<ConnectRequest>(nullptr);
  }

  ConnectRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ConnectRequest>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const ConnectRequest& from);
  void MergeFrom(const ConnectRequest& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ConnectRequest* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xla.ConnectRequest";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto);
    return ::descriptor_table_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kProtocolVersionFieldNumber = 1,
    kTimeoutMillisecondsFieldNumber = 2,
    kClientIdFieldNumber = 4,
    kNodeIdFieldNumber = 3,
  };
  // int32 protocol_version = 1;
  void clear_protocol_version();
  ::PROTOBUF_NAMESPACE_ID::int32 protocol_version() const;
  void set_protocol_version(::PROTOBUF_NAMESPACE_ID::int32 value);

  // int32 timeout_milliseconds = 2;
  void clear_timeout_milliseconds();
  ::PROTOBUF_NAMESPACE_ID::int32 timeout_milliseconds() const;
  void set_timeout_milliseconds(::PROTOBUF_NAMESPACE_ID::int32 value);

  // uint64 client_id = 4;
  void clear_client_id();
  ::PROTOBUF_NAMESPACE_ID::uint64 client_id() const;
  void set_client_id(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // int32 node_id = 3;
  void clear_node_id();
  ::PROTOBUF_NAMESPACE_ID::int32 node_id() const;
  void set_node_id(::PROTOBUF_NAMESPACE_ID::int32 value);

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::int32 protocol_version_;
  ::PROTOBUF_NAMESPACE_ID::int32 timeout_milliseconds_;
  ::PROTOBUF_NAMESPACE_ID::uint64 client_id_;
  ::PROTOBUF_NAMESPACE_ID::int32 node_id_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto;
};
// -------------------------------------------------------------------

class ConnectResponse :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.ConnectResponse) */ {
 public:
  ConnectResponse();
  virtual ~ConnectResponse();

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

  inline ConnectResponse& operator=(const ConnectResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline ConnectResponse& operator=(ConnectResponse&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const ConnectResponse& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ConnectResponse* internal_default_instance() {
    return reinterpret_cast<const ConnectResponse*>(
               &_ConnectResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(ConnectResponse& a, ConnectResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(ConnectResponse* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline ConnectResponse* New() const final {
    return CreateMaybeMessage<ConnectResponse>(nullptr);
  }

  ConnectResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ConnectResponse>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const ConnectResponse& from);
  void MergeFrom(const ConnectResponse& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ConnectResponse* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xla.ConnectResponse";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto);
    return ::descriptor_table_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kSessionIdFieldNumber = 1,
  };
  // uint64 session_id = 1;
  void clear_session_id();
  ::PROTOBUF_NAMESPACE_ID::uint64 session_id() const;
  void set_session_id(::PROTOBUF_NAMESPACE_ID::uint64 value);

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::uint64 session_id_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto;
};
// -------------------------------------------------------------------

class EnumerateDevicesRequest :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.EnumerateDevicesRequest) */ {
 public:
  EnumerateDevicesRequest();
  virtual ~EnumerateDevicesRequest();

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

  inline EnumerateDevicesRequest& operator=(const EnumerateDevicesRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline EnumerateDevicesRequest& operator=(EnumerateDevicesRequest&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const EnumerateDevicesRequest& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const EnumerateDevicesRequest* internal_default_instance() {
    return reinterpret_cast<const EnumerateDevicesRequest*>(
               &_EnumerateDevicesRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  friend void swap(EnumerateDevicesRequest& a, EnumerateDevicesRequest& b) {
    a.Swap(&b);
  }
  inline void Swap(EnumerateDevicesRequest* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline EnumerateDevicesRequest* New() const final {
    return CreateMaybeMessage<EnumerateDevicesRequest>(nullptr);
  }

  EnumerateDevicesRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<EnumerateDevicesRequest>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const EnumerateDevicesRequest& from);
  void MergeFrom(const EnumerateDevicesRequest& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(EnumerateDevicesRequest* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xla.EnumerateDevicesRequest";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto);
    return ::descriptor_table_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kLocalTopologyFieldNumber = 3,
    kSessionIdFieldNumber = 1,
  };
  // .xla.LocalTopologyProto local_topology = 3;
  bool has_local_topology() const;
  void clear_local_topology();
  const ::xla::LocalTopologyProto& local_topology() const;
  ::xla::LocalTopologyProto* release_local_topology();
  ::xla::LocalTopologyProto* mutable_local_topology();
  void set_allocated_local_topology(::xla::LocalTopologyProto* local_topology);

  // uint64 session_id = 1;
  void clear_session_id();
  ::PROTOBUF_NAMESPACE_ID::uint64 session_id() const;
  void set_session_id(::PROTOBUF_NAMESPACE_ID::uint64 value);

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::xla::LocalTopologyProto* local_topology_;
  ::PROTOBUF_NAMESPACE_ID::uint64 session_id_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto;
};
// -------------------------------------------------------------------

class EnumerateDevicesResponse :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.EnumerateDevicesResponse) */ {
 public:
  EnumerateDevicesResponse();
  virtual ~EnumerateDevicesResponse();

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

  inline EnumerateDevicesResponse& operator=(const EnumerateDevicesResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline EnumerateDevicesResponse& operator=(EnumerateDevicesResponse&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const EnumerateDevicesResponse& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const EnumerateDevicesResponse* internal_default_instance() {
    return reinterpret_cast<const EnumerateDevicesResponse*>(
               &_EnumerateDevicesResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  friend void swap(EnumerateDevicesResponse& a, EnumerateDevicesResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(EnumerateDevicesResponse* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline EnumerateDevicesResponse* New() const final {
    return CreateMaybeMessage<EnumerateDevicesResponse>(nullptr);
  }

  EnumerateDevicesResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<EnumerateDevicesResponse>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const EnumerateDevicesResponse& from);
  void MergeFrom(const EnumerateDevicesResponse& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(EnumerateDevicesResponse* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xla.EnumerateDevicesResponse";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto);
    return ::descriptor_table_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kGlobalTopologyFieldNumber = 1,
  };
  // .xla.GlobalTopologyProto global_topology = 1;
  bool has_global_topology() const;
  void clear_global_topology();
  const ::xla::GlobalTopologyProto& global_topology() const;
  ::xla::GlobalTopologyProto* release_global_topology();
  ::xla::GlobalTopologyProto* mutable_global_topology();
  void set_allocated_global_topology(::xla::GlobalTopologyProto* global_topology);

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::xla::GlobalTopologyProto* global_topology_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto;
};
// -------------------------------------------------------------------

class KeyValueGetRequest :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.KeyValueGetRequest) */ {
 public:
  KeyValueGetRequest();
  virtual ~KeyValueGetRequest();

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

  inline KeyValueGetRequest& operator=(const KeyValueGetRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline KeyValueGetRequest& operator=(KeyValueGetRequest&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const KeyValueGetRequest& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const KeyValueGetRequest* internal_default_instance() {
    return reinterpret_cast<const KeyValueGetRequest*>(
               &_KeyValueGetRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

  friend void swap(KeyValueGetRequest& a, KeyValueGetRequest& b) {
    a.Swap(&b);
  }
  inline void Swap(KeyValueGetRequest* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline KeyValueGetRequest* New() const final {
    return CreateMaybeMessage<KeyValueGetRequest>(nullptr);
  }

  KeyValueGetRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<KeyValueGetRequest>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const KeyValueGetRequest& from);
  void MergeFrom(const KeyValueGetRequest& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(KeyValueGetRequest* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xla.KeyValueGetRequest";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto);
    return ::descriptor_table_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kKeyFieldNumber = 2,
    kSessionIdFieldNumber = 1,
    kTimeoutMillisecondsFieldNumber = 3,
  };
  // bytes key = 2;
  void clear_key();
  const std::string& key() const;
  void set_key(const std::string& value);
  void set_key(std::string&& value);
  void set_key(const char* value);
  void set_key(const void* value, size_t size);
  std::string* mutable_key();
  std::string* release_key();
  void set_allocated_key(std::string* key);

  // uint64 session_id = 1;
  void clear_session_id();
  ::PROTOBUF_NAMESPACE_ID::uint64 session_id() const;
  void set_session_id(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // int32 timeout_milliseconds = 3;
  void clear_timeout_milliseconds();
  ::PROTOBUF_NAMESPACE_ID::int32 timeout_milliseconds() const;
  void set_timeout_milliseconds(::PROTOBUF_NAMESPACE_ID::int32 value);

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_;
  ::PROTOBUF_NAMESPACE_ID::uint64 session_id_;
  ::PROTOBUF_NAMESPACE_ID::int32 timeout_milliseconds_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto;
};
// -------------------------------------------------------------------

class KeyValueGetResponse :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.KeyValueGetResponse) */ {
 public:
  KeyValueGetResponse();
  virtual ~KeyValueGetResponse();

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

  inline KeyValueGetResponse& operator=(const KeyValueGetResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline KeyValueGetResponse& operator=(KeyValueGetResponse&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const KeyValueGetResponse& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const KeyValueGetResponse* internal_default_instance() {
    return reinterpret_cast<const KeyValueGetResponse*>(
               &_KeyValueGetResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

  friend void swap(KeyValueGetResponse& a, KeyValueGetResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(KeyValueGetResponse* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline KeyValueGetResponse* New() const final {
    return CreateMaybeMessage<KeyValueGetResponse>(nullptr);
  }

  KeyValueGetResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<KeyValueGetResponse>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const KeyValueGetResponse& from);
  void MergeFrom(const KeyValueGetResponse& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(KeyValueGetResponse* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xla.KeyValueGetResponse";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto);
    return ::descriptor_table_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kValueFieldNumber = 2,
    kFoundFieldNumber = 1,
  };
  // bytes value = 2;
  void clear_value();
  const std::string& value() const;
  void set_value(const std::string& value);
  void set_value(std::string&& value);
  void set_value(const char* value);
  void set_value(const void* value, size_t size);
  std::string* mutable_value();
  std::string* release_value();
  void set_allocated_value(std::string* value);

  // bool found = 1;
  void clear_found();
  bool found() const;
  void set_found(bool value);

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
  bool found_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto;
};
// -------------------------------------------------------------------

class KeyValueSetRequest :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.KeyValueSetRequest) */ {
 public:
  KeyValueSetRequest();
  virtual ~KeyValueSetRequest();

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

  inline KeyValueSetRequest& operator=(const KeyValueSetRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline KeyValueSetRequest& operator=(KeyValueSetRequest&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const KeyValueSetRequest& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const KeyValueSetRequest* internal_default_instance() {
    return reinterpret_cast<const KeyValueSetRequest*>(
               &_KeyValueSetRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;

  friend void swap(KeyValueSetRequest& a, KeyValueSetRequest& b) {
    a.Swap(&b);
  }
  inline void Swap(KeyValueSetRequest* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline KeyValueSetRequest* New() const final {
    return CreateMaybeMessage<KeyValueSetRequest>(nullptr);
  }

  KeyValueSetRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<KeyValueSetRequest>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const KeyValueSetRequest& from);
  void MergeFrom(const KeyValueSetRequest& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(KeyValueSetRequest* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xla.KeyValueSetRequest";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto);
    return ::descriptor_table_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kKeyFieldNumber = 2,
    kValueFieldNumber = 3,
    kSessionIdFieldNumber = 1,
  };
  // bytes key = 2;
  void clear_key();
  const std::string& key() const;
  void set_key(const std::string& value);
  void set_key(std::string&& value);
  void set_key(const char* value);
  void set_key(const void* value, size_t size);
  std::string* mutable_key();
  std::string* release_key();
  void set_allocated_key(std::string* key);

  // bytes value = 3;
  void clear_value();
  const std::string& value() const;
  void set_value(const std::string& value);
  void set_value(std::string&& value);
  void set_value(const char* value);
  void set_value(const void* value, size_t size);
  std::string* mutable_value();
  std::string* release_value();
  void set_allocated_value(std::string* value);

  // uint64 session_id = 1;
  void clear_session_id();
  ::PROTOBUF_NAMESPACE_ID::uint64 session_id() const;
  void set_session_id(::PROTOBUF_NAMESPACE_ID::uint64 value);

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
  ::PROTOBUF_NAMESPACE_ID::uint64 session_id_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto;
};
// -------------------------------------------------------------------

class KeyValueSetResponse :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.KeyValueSetResponse) */ {
 public:
  KeyValueSetResponse();
  virtual ~KeyValueSetResponse();

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

  inline KeyValueSetResponse& operator=(const KeyValueSetResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline KeyValueSetResponse& operator=(KeyValueSetResponse&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const KeyValueSetResponse& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const KeyValueSetResponse* internal_default_instance() {
    return reinterpret_cast<const KeyValueSetResponse*>(
               &_KeyValueSetResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;

  friend void swap(KeyValueSetResponse& a, KeyValueSetResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(KeyValueSetResponse* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline KeyValueSetResponse* New() const final {
    return CreateMaybeMessage<KeyValueSetResponse>(nullptr);
  }

  KeyValueSetResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<KeyValueSetResponse>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const KeyValueSetResponse& from);
  void MergeFrom(const KeyValueSetResponse& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(KeyValueSetResponse* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xla.KeyValueSetResponse";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto);
    return ::descriptor_table_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto;
};
// -------------------------------------------------------------------

class WaitAtBarrierRequest :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.WaitAtBarrierRequest) */ {
 public:
  WaitAtBarrierRequest();
  virtual ~WaitAtBarrierRequest();

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

  inline WaitAtBarrierRequest& operator=(const WaitAtBarrierRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline WaitAtBarrierRequest& operator=(WaitAtBarrierRequest&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const WaitAtBarrierRequest& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const WaitAtBarrierRequest* internal_default_instance() {
    return reinterpret_cast<const WaitAtBarrierRequest*>(
               &_WaitAtBarrierRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    11;

  friend void swap(WaitAtBarrierRequest& a, WaitAtBarrierRequest& b) {
    a.Swap(&b);
  }
  inline void Swap(WaitAtBarrierRequest* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline WaitAtBarrierRequest* New() const final {
    return CreateMaybeMessage<WaitAtBarrierRequest>(nullptr);
  }

  WaitAtBarrierRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<WaitAtBarrierRequest>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const WaitAtBarrierRequest& from);
  void MergeFrom(const WaitAtBarrierRequest& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(WaitAtBarrierRequest* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xla.WaitAtBarrierRequest";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto);
    return ::descriptor_table_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kBarrierIdFieldNumber = 2,
    kSessionIdFieldNumber = 1,
    kNodeIdFieldNumber = 3,
    kTimeoutMillisecondsFieldNumber = 4,
  };
  // bytes barrier_id = 2;
  void clear_barrier_id();
  const std::string& barrier_id() const;
  void set_barrier_id(const std::string& value);
  void set_barrier_id(std::string&& value);
  void set_barrier_id(const char* value);
  void set_barrier_id(const void* value, size_t size);
  std::string* mutable_barrier_id();
  std::string* release_barrier_id();
  void set_allocated_barrier_id(std::string* barrier_id);

  // uint64 session_id = 1;
  void clear_session_id();
  ::PROTOBUF_NAMESPACE_ID::uint64 session_id() const;
  void set_session_id(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // int32 node_id = 3;
  void clear_node_id();
  ::PROTOBUF_NAMESPACE_ID::int32 node_id() const;
  void set_node_id(::PROTOBUF_NAMESPACE_ID::int32 value);

  // int32 timeout_milliseconds = 4;
  void clear_timeout_milliseconds();
  ::PROTOBUF_NAMESPACE_ID::int32 timeout_milliseconds() const;
  void set_timeout_milliseconds(::PROTOBUF_NAMESPACE_ID::int32 value);

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr barrier_id_;
  ::PROTOBUF_NAMESPACE_ID::uint64 session_id_;
  ::PROTOBUF_NAMESPACE_ID::int32 node_id_;
  ::PROTOBUF_NAMESPACE_ID::int32 timeout_milliseconds_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto;
};
// -------------------------------------------------------------------

class WaitAtBarrierResponse :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.WaitAtBarrierResponse) */ {
 public:
  WaitAtBarrierResponse();
  virtual ~WaitAtBarrierResponse();

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

  inline WaitAtBarrierResponse& operator=(const WaitAtBarrierResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline WaitAtBarrierResponse& operator=(WaitAtBarrierResponse&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const WaitAtBarrierResponse& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const WaitAtBarrierResponse* internal_default_instance() {
    return reinterpret_cast<const WaitAtBarrierResponse*>(
               &_WaitAtBarrierResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    12;

  friend void swap(WaitAtBarrierResponse& a, WaitAtBarrierResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(WaitAtBarrierResponse* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline WaitAtBarrierResponse* New() const final {
    return CreateMaybeMessage<WaitAtBarrierResponse>(nullptr);
  }

  WaitAtBarrierResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<WaitAtBarrierResponse>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const WaitAtBarrierResponse& from);
  void MergeFrom(const WaitAtBarrierResponse& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(WaitAtBarrierResponse* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xla.WaitAtBarrierResponse";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto);
    return ::descriptor_table_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto;
};
// -------------------------------------------------------------------

class HeartbeatRequest :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.HeartbeatRequest) */ {
 public:
  HeartbeatRequest();
  virtual ~HeartbeatRequest();

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

  inline HeartbeatRequest& operator=(const HeartbeatRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline HeartbeatRequest& operator=(HeartbeatRequest&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const HeartbeatRequest& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const HeartbeatRequest* internal_default_instance() {
    return reinterpret_cast<const HeartbeatRequest*>(
               &_HeartbeatRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    13;

  friend void swap(HeartbeatRequest& a, HeartbeatRequest& b) {
    a.Swap(&b);
  }
  inline void Swap(HeartbeatRequest* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline HeartbeatRequest* New() const final {
    return CreateMaybeMessage<HeartbeatRequest>(nullptr);
  }

  HeartbeatRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<HeartbeatRequest>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const HeartbeatRequest& from);
  void MergeFrom(const HeartbeatRequest& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(HeartbeatRequest* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xla.HeartbeatRequest";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto);
    return ::descriptor_table_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kSessionIdFieldNumber = 1,
    kNodeIdFieldNumber = 2,
  };
  // uint64 session_id = 1;
  void clear_session_id();
  ::PROTOBUF_NAMESPACE_ID::uint64 session_id() const;
  void set_session_id(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // int32 node_id = 2;
  void clear_node_id();
  ::PROTOBUF_NAMESPACE_ID::int32 node_id() const;
  void set_node_id(::PROTOBUF_NAMESPACE_ID::int32 value);

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::uint64 session_id_;
  ::PROTOBUF_NAMESPACE_ID::int32 node_id_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto;
};
// -------------------------------------------------------------------

class HeartbeatResponse :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.HeartbeatResponse) */ {
 public:
  HeartbeatResponse();
  virtual ~HeartbeatResponse();

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

  inline HeartbeatResponse& operator=(const HeartbeatResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline HeartbeatResponse& operator=(HeartbeatResponse&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const HeartbeatResponse& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const HeartbeatResponse* internal_default_instance() {
    return reinterpret_cast<const HeartbeatResponse*>(
               &_HeartbeatResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    14;

  friend void swap(HeartbeatResponse& a, HeartbeatResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(HeartbeatResponse* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline HeartbeatResponse* New() const final {
    return CreateMaybeMessage<HeartbeatResponse>(nullptr);
  }

  HeartbeatResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<HeartbeatResponse>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const HeartbeatResponse& from);
  void MergeFrom(const HeartbeatResponse& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(HeartbeatResponse* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xla.HeartbeatResponse";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto);
    return ::descriptor_table_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto;
};
// -------------------------------------------------------------------

class ShutdownRequest :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.ShutdownRequest) */ {
 public:
  ShutdownRequest();
  virtual ~ShutdownRequest();

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

  inline ShutdownRequest& operator=(const ShutdownRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline ShutdownRequest& operator=(ShutdownRequest&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const ShutdownRequest& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ShutdownRequest* internal_default_instance() {
    return reinterpret_cast<const ShutdownRequest*>(
               &_ShutdownRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    15;

  friend void swap(ShutdownRequest& a, ShutdownRequest& b) {
    a.Swap(&b);
  }
  inline void Swap(ShutdownRequest* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline ShutdownRequest* New() const final {
    return CreateMaybeMessage<ShutdownRequest>(nullptr);
  }

  ShutdownRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ShutdownRequest>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const ShutdownRequest& from);
  void MergeFrom(const ShutdownRequest& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ShutdownRequest* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xla.ShutdownRequest";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto);
    return ::descriptor_table_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kSessionIdFieldNumber = 1,
    kNodeIdFieldNumber = 2,
  };
  // uint64 session_id = 1;
  void clear_session_id();
  ::PROTOBUF_NAMESPACE_ID::uint64 session_id() const;
  void set_session_id(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // int32 node_id = 2;
  void clear_node_id();
  ::PROTOBUF_NAMESPACE_ID::int32 node_id() const;
  void set_node_id(::PROTOBUF_NAMESPACE_ID::int32 value);

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::uint64 session_id_;
  ::PROTOBUF_NAMESPACE_ID::int32 node_id_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto;
};
// -------------------------------------------------------------------

class ShutdownResponse :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.ShutdownResponse) */ {
 public:
  ShutdownResponse();
  virtual ~ShutdownResponse();

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

  inline ShutdownResponse& operator=(const ShutdownResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline ShutdownResponse& operator=(ShutdownResponse&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const ShutdownResponse& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ShutdownResponse* internal_default_instance() {
    return reinterpret_cast<const ShutdownResponse*>(
               &_ShutdownResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    16;

  friend void swap(ShutdownResponse& a, ShutdownResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(ShutdownResponse* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline ShutdownResponse* New() const final {
    return CreateMaybeMessage<ShutdownResponse>(nullptr);
  }

  ShutdownResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ShutdownResponse>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const ShutdownResponse& from);
  void MergeFrom(const ShutdownResponse& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ShutdownResponse* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "xla.ShutdownResponse";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto);
    return ::descriptor_table_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto;
};
// ===================================================================


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

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

// int32 local_device_ordinal = 1;
inline void DeviceProto::clear_local_device_ordinal() {
  local_device_ordinal_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 DeviceProto::local_device_ordinal() const {
  // @@protoc_insertion_point(field_get:xla.DeviceProto.local_device_ordinal)
  return local_device_ordinal_;
}
inline void DeviceProto::set_local_device_ordinal(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  local_device_ordinal_ = value;
  // @@protoc_insertion_point(field_set:xla.DeviceProto.local_device_ordinal)
}

// string name = 2;
inline void DeviceProto::clear_name() {
  name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& DeviceProto::name() const {
  // @@protoc_insertion_point(field_get:xla.DeviceProto.name)
  return name_.GetNoArena();
}
inline void DeviceProto::set_name(const std::string& value) {
  
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:xla.DeviceProto.name)
}
inline void DeviceProto::set_name(std::string&& value) {
  
  name_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:xla.DeviceProto.name)
}
inline void DeviceProto::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:xla.DeviceProto.name)
}
inline void DeviceProto::set_name(const char* value, size_t size) {
  
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:xla.DeviceProto.name)
}
inline std::string* DeviceProto::mutable_name() {
  
  // @@protoc_insertion_point(field_mutable:xla.DeviceProto.name)
  return name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* DeviceProto::release_name() {
  // @@protoc_insertion_point(field_release:xla.DeviceProto.name)
  
  return name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void DeviceProto::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name);
  // @@protoc_insertion_point(field_set_allocated:xla.DeviceProto.name)
}

// string vendor = 3;
inline void DeviceProto::clear_vendor() {
  vendor_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& DeviceProto::vendor() const {
  // @@protoc_insertion_point(field_get:xla.DeviceProto.vendor)
  return vendor_.GetNoArena();
}
inline void DeviceProto::set_vendor(const std::string& value) {
  
  vendor_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:xla.DeviceProto.vendor)
}
inline void DeviceProto::set_vendor(std::string&& value) {
  
  vendor_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:xla.DeviceProto.vendor)
}
inline void DeviceProto::set_vendor(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  vendor_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:xla.DeviceProto.vendor)
}
inline void DeviceProto::set_vendor(const char* value, size_t size) {
  
  vendor_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:xla.DeviceProto.vendor)
}
inline std::string* DeviceProto::mutable_vendor() {
  
  // @@protoc_insertion_point(field_mutable:xla.DeviceProto.vendor)
  return vendor_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* DeviceProto::release_vendor() {
  // @@protoc_insertion_point(field_release:xla.DeviceProto.vendor)
  
  return vendor_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void DeviceProto::set_allocated_vendor(std::string* vendor) {
  if (vendor != nullptr) {
    
  } else {
    
  }
  vendor_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), vendor);
  // @@protoc_insertion_point(field_set_allocated:xla.DeviceProto.vendor)
}

// int32 global_device_id = 4;
inline void DeviceProto::clear_global_device_id() {
  global_device_id_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 DeviceProto::global_device_id() const {
  // @@protoc_insertion_point(field_get:xla.DeviceProto.global_device_id)
  return global_device_id_;
}
inline void DeviceProto::set_global_device_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  global_device_id_ = value;
  // @@protoc_insertion_point(field_set:xla.DeviceProto.global_device_id)
}

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

// LocalTopologyProto

// int32 node_id = 1;
inline void LocalTopologyProto::clear_node_id() {
  node_id_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 LocalTopologyProto::node_id() const {
  // @@protoc_insertion_point(field_get:xla.LocalTopologyProto.node_id)
  return node_id_;
}
inline void LocalTopologyProto::set_node_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  node_id_ = value;
  // @@protoc_insertion_point(field_set:xla.LocalTopologyProto.node_id)
}

// repeated .xla.DeviceProto devices = 2;
inline int LocalTopologyProto::devices_size() const {
  return devices_.size();
}
inline void LocalTopologyProto::clear_devices() {
  devices_.Clear();
}
inline ::xla::DeviceProto* LocalTopologyProto::mutable_devices(int index) {
  // @@protoc_insertion_point(field_mutable:xla.LocalTopologyProto.devices)
  return devices_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::DeviceProto >*
LocalTopologyProto::mutable_devices() {
  // @@protoc_insertion_point(field_mutable_list:xla.LocalTopologyProto.devices)
  return &devices_;
}
inline const ::xla::DeviceProto& LocalTopologyProto::devices(int index) const {
  // @@protoc_insertion_point(field_get:xla.LocalTopologyProto.devices)
  return devices_.Get(index);
}
inline ::xla::DeviceProto* LocalTopologyProto::add_devices() {
  // @@protoc_insertion_point(field_add:xla.LocalTopologyProto.devices)
  return devices_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::DeviceProto >&
LocalTopologyProto::devices() const {
  // @@protoc_insertion_point(field_list:xla.LocalTopologyProto.devices)
  return devices_;
}

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

// GlobalTopologyProto

// repeated .xla.LocalTopologyProto nodes = 1;
inline int GlobalTopologyProto::nodes_size() const {
  return nodes_.size();
}
inline void GlobalTopologyProto::clear_nodes() {
  nodes_.Clear();
}
inline ::xla::LocalTopologyProto* GlobalTopologyProto::mutable_nodes(int index) {
  // @@protoc_insertion_point(field_mutable:xla.GlobalTopologyProto.nodes)
  return nodes_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::LocalTopologyProto >*
GlobalTopologyProto::mutable_nodes() {
  // @@protoc_insertion_point(field_mutable_list:xla.GlobalTopologyProto.nodes)
  return &nodes_;
}
inline const ::xla::LocalTopologyProto& GlobalTopologyProto::nodes(int index) const {
  // @@protoc_insertion_point(field_get:xla.GlobalTopologyProto.nodes)
  return nodes_.Get(index);
}
inline ::xla::LocalTopologyProto* GlobalTopologyProto::add_nodes() {
  // @@protoc_insertion_point(field_add:xla.GlobalTopologyProto.nodes)
  return nodes_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::LocalTopologyProto >&
GlobalTopologyProto::nodes() const {
  // @@protoc_insertion_point(field_list:xla.GlobalTopologyProto.nodes)
  return nodes_;
}

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

// ConnectRequest

// int32 protocol_version = 1;
inline void ConnectRequest::clear_protocol_version() {
  protocol_version_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ConnectRequest::protocol_version() const {
  // @@protoc_insertion_point(field_get:xla.ConnectRequest.protocol_version)
  return protocol_version_;
}
inline void ConnectRequest::set_protocol_version(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  protocol_version_ = value;
  // @@protoc_insertion_point(field_set:xla.ConnectRequest.protocol_version)
}

// int32 timeout_milliseconds = 2;
inline void ConnectRequest::clear_timeout_milliseconds() {
  timeout_milliseconds_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ConnectRequest::timeout_milliseconds() const {
  // @@protoc_insertion_point(field_get:xla.ConnectRequest.timeout_milliseconds)
  return timeout_milliseconds_;
}
inline void ConnectRequest::set_timeout_milliseconds(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  timeout_milliseconds_ = value;
  // @@protoc_insertion_point(field_set:xla.ConnectRequest.timeout_milliseconds)
}

// int32 node_id = 3;
inline void ConnectRequest::clear_node_id() {
  node_id_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ConnectRequest::node_id() const {
  // @@protoc_insertion_point(field_get:xla.ConnectRequest.node_id)
  return node_id_;
}
inline void ConnectRequest::set_node_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  node_id_ = value;
  // @@protoc_insertion_point(field_set:xla.ConnectRequest.node_id)
}

// uint64 client_id = 4;
inline void ConnectRequest::clear_client_id() {
  client_id_ = PROTOBUF_ULONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 ConnectRequest::client_id() const {
  // @@protoc_insertion_point(field_get:xla.ConnectRequest.client_id)
  return client_id_;
}
inline void ConnectRequest::set_client_id(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  
  client_id_ = value;
  // @@protoc_insertion_point(field_set:xla.ConnectRequest.client_id)
}

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

// ConnectResponse

// uint64 session_id = 1;
inline void ConnectResponse::clear_session_id() {
  session_id_ = PROTOBUF_ULONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 ConnectResponse::session_id() const {
  // @@protoc_insertion_point(field_get:xla.ConnectResponse.session_id)
  return session_id_;
}
inline void ConnectResponse::set_session_id(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  
  session_id_ = value;
  // @@protoc_insertion_point(field_set:xla.ConnectResponse.session_id)
}

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

// EnumerateDevicesRequest

// uint64 session_id = 1;
inline void EnumerateDevicesRequest::clear_session_id() {
  session_id_ = PROTOBUF_ULONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 EnumerateDevicesRequest::session_id() const {
  // @@protoc_insertion_point(field_get:xla.EnumerateDevicesRequest.session_id)
  return session_id_;
}
inline void EnumerateDevicesRequest::set_session_id(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  
  session_id_ = value;
  // @@protoc_insertion_point(field_set:xla.EnumerateDevicesRequest.session_id)
}

// .xla.LocalTopologyProto local_topology = 3;
inline bool EnumerateDevicesRequest::has_local_topology() const {
  return this != internal_default_instance() && local_topology_ != nullptr;
}
inline void EnumerateDevicesRequest::clear_local_topology() {
  if (GetArenaNoVirtual() == nullptr && local_topology_ != nullptr) {
    delete local_topology_;
  }
  local_topology_ = nullptr;
}
inline const ::xla::LocalTopologyProto& EnumerateDevicesRequest::local_topology() const {
  const ::xla::LocalTopologyProto* p = local_topology_;
  // @@protoc_insertion_point(field_get:xla.EnumerateDevicesRequest.local_topology)
  return p != nullptr ? *p : *reinterpret_cast<const ::xla::LocalTopologyProto*>(
      &::xla::_LocalTopologyProto_default_instance_);
}
inline ::xla::LocalTopologyProto* EnumerateDevicesRequest::release_local_topology() {
  // @@protoc_insertion_point(field_release:xla.EnumerateDevicesRequest.local_topology)
  
  ::xla::LocalTopologyProto* temp = local_topology_;
  local_topology_ = nullptr;
  return temp;
}
inline ::xla::LocalTopologyProto* EnumerateDevicesRequest::mutable_local_topology() {
  
  if (local_topology_ == nullptr) {
    auto* p = CreateMaybeMessage<::xla::LocalTopologyProto>(GetArenaNoVirtual());
    local_topology_ = p;
  }
  // @@protoc_insertion_point(field_mutable:xla.EnumerateDevicesRequest.local_topology)
  return local_topology_;
}
inline void EnumerateDevicesRequest::set_allocated_local_topology(::xla::LocalTopologyProto* local_topology) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete local_topology_;
  }
  if (local_topology) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      local_topology = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, local_topology, submessage_arena);
    }
    
  } else {
    
  }
  local_topology_ = local_topology;
  // @@protoc_insertion_point(field_set_allocated:xla.EnumerateDevicesRequest.local_topology)
}

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

// EnumerateDevicesResponse

// .xla.GlobalTopologyProto global_topology = 1;
inline bool EnumerateDevicesResponse::has_global_topology() const {
  return this != internal_default_instance() && global_topology_ != nullptr;
}
inline void EnumerateDevicesResponse::clear_global_topology() {
  if (GetArenaNoVirtual() == nullptr && global_topology_ != nullptr) {
    delete global_topology_;
  }
  global_topology_ = nullptr;
}
inline const ::xla::GlobalTopologyProto& EnumerateDevicesResponse::global_topology() const {
  const ::xla::GlobalTopologyProto* p = global_topology_;
  // @@protoc_insertion_point(field_get:xla.EnumerateDevicesResponse.global_topology)
  return p != nullptr ? *p : *reinterpret_cast<const ::xla::GlobalTopologyProto*>(
      &::xla::_GlobalTopologyProto_default_instance_);
}
inline ::xla::GlobalTopologyProto* EnumerateDevicesResponse::release_global_topology() {
  // @@protoc_insertion_point(field_release:xla.EnumerateDevicesResponse.global_topology)
  
  ::xla::GlobalTopologyProto* temp = global_topology_;
  global_topology_ = nullptr;
  return temp;
}
inline ::xla::GlobalTopologyProto* EnumerateDevicesResponse::mutable_global_topology() {
  
  if (global_topology_ == nullptr) {
    auto* p = CreateMaybeMessage<::xla::GlobalTopologyProto>(GetArenaNoVirtual());
    global_topology_ = p;
  }
  // @@protoc_insertion_point(field_mutable:xla.EnumerateDevicesResponse.global_topology)
  return global_topology_;
}
inline void EnumerateDevicesResponse::set_allocated_global_topology(::xla::GlobalTopologyProto* global_topology) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete global_topology_;
  }
  if (global_topology) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      global_topology = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, global_topology, submessage_arena);
    }
    
  } else {
    
  }
  global_topology_ = global_topology;
  // @@protoc_insertion_point(field_set_allocated:xla.EnumerateDevicesResponse.global_topology)
}

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

// KeyValueGetRequest

// uint64 session_id = 1;
inline void KeyValueGetRequest::clear_session_id() {
  session_id_ = PROTOBUF_ULONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 KeyValueGetRequest::session_id() const {
  // @@protoc_insertion_point(field_get:xla.KeyValueGetRequest.session_id)
  return session_id_;
}
inline void KeyValueGetRequest::set_session_id(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  
  session_id_ = value;
  // @@protoc_insertion_point(field_set:xla.KeyValueGetRequest.session_id)
}

// bytes key = 2;
inline void KeyValueGetRequest::clear_key() {
  key_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& KeyValueGetRequest::key() const {
  // @@protoc_insertion_point(field_get:xla.KeyValueGetRequest.key)
  return key_.GetNoArena();
}
inline void KeyValueGetRequest::set_key(const std::string& value) {
  
  key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:xla.KeyValueGetRequest.key)
}
inline void KeyValueGetRequest::set_key(std::string&& value) {
  
  key_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:xla.KeyValueGetRequest.key)
}
inline void KeyValueGetRequest::set_key(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:xla.KeyValueGetRequest.key)
}
inline void KeyValueGetRequest::set_key(const void* value, size_t size) {
  
  key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:xla.KeyValueGetRequest.key)
}
inline std::string* KeyValueGetRequest::mutable_key() {
  
  // @@protoc_insertion_point(field_mutable:xla.KeyValueGetRequest.key)
  return key_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* KeyValueGetRequest::release_key() {
  // @@protoc_insertion_point(field_release:xla.KeyValueGetRequest.key)
  
  return key_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void KeyValueGetRequest::set_allocated_key(std::string* key) {
  if (key != nullptr) {
    
  } else {
    
  }
  key_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), key);
  // @@protoc_insertion_point(field_set_allocated:xla.KeyValueGetRequest.key)
}

// int32 timeout_milliseconds = 3;
inline void KeyValueGetRequest::clear_timeout_milliseconds() {
  timeout_milliseconds_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 KeyValueGetRequest::timeout_milliseconds() const {
  // @@protoc_insertion_point(field_get:xla.KeyValueGetRequest.timeout_milliseconds)
  return timeout_milliseconds_;
}
inline void KeyValueGetRequest::set_timeout_milliseconds(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  timeout_milliseconds_ = value;
  // @@protoc_insertion_point(field_set:xla.KeyValueGetRequest.timeout_milliseconds)
}

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

// KeyValueGetResponse

// bool found = 1;
inline void KeyValueGetResponse::clear_found() {
  found_ = false;
}
inline bool KeyValueGetResponse::found() const {
  // @@protoc_insertion_point(field_get:xla.KeyValueGetResponse.found)
  return found_;
}
inline void KeyValueGetResponse::set_found(bool value) {
  
  found_ = value;
  // @@protoc_insertion_point(field_set:xla.KeyValueGetResponse.found)
}

// bytes value = 2;
inline void KeyValueGetResponse::clear_value() {
  value_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& KeyValueGetResponse::value() const {
  // @@protoc_insertion_point(field_get:xla.KeyValueGetResponse.value)
  return value_.GetNoArena();
}
inline void KeyValueGetResponse::set_value(const std::string& value) {
  
  value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:xla.KeyValueGetResponse.value)
}
inline void KeyValueGetResponse::set_value(std::string&& value) {
  
  value_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:xla.KeyValueGetResponse.value)
}
inline void KeyValueGetResponse::set_value(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:xla.KeyValueGetResponse.value)
}
inline void KeyValueGetResponse::set_value(const void* value, size_t size) {
  
  value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:xla.KeyValueGetResponse.value)
}
inline std::string* KeyValueGetResponse::mutable_value() {
  
  // @@protoc_insertion_point(field_mutable:xla.KeyValueGetResponse.value)
  return value_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* KeyValueGetResponse::release_value() {
  // @@protoc_insertion_point(field_release:xla.KeyValueGetResponse.value)
  
  return value_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void KeyValueGetResponse::set_allocated_value(std::string* value) {
  if (value != nullptr) {
    
  } else {
    
  }
  value_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set_allocated:xla.KeyValueGetResponse.value)
}

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

// KeyValueSetRequest

// uint64 session_id = 1;
inline void KeyValueSetRequest::clear_session_id() {
  session_id_ = PROTOBUF_ULONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 KeyValueSetRequest::session_id() const {
  // @@protoc_insertion_point(field_get:xla.KeyValueSetRequest.session_id)
  return session_id_;
}
inline void KeyValueSetRequest::set_session_id(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  
  session_id_ = value;
  // @@protoc_insertion_point(field_set:xla.KeyValueSetRequest.session_id)
}

// bytes key = 2;
inline void KeyValueSetRequest::clear_key() {
  key_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& KeyValueSetRequest::key() const {
  // @@protoc_insertion_point(field_get:xla.KeyValueSetRequest.key)
  return key_.GetNoArena();
}
inline void KeyValueSetRequest::set_key(const std::string& value) {
  
  key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:xla.KeyValueSetRequest.key)
}
inline void KeyValueSetRequest::set_key(std::string&& value) {
  
  key_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:xla.KeyValueSetRequest.key)
}
inline void KeyValueSetRequest::set_key(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:xla.KeyValueSetRequest.key)
}
inline void KeyValueSetRequest::set_key(const void* value, size_t size) {
  
  key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:xla.KeyValueSetRequest.key)
}
inline std::string* KeyValueSetRequest::mutable_key() {
  
  // @@protoc_insertion_point(field_mutable:xla.KeyValueSetRequest.key)
  return key_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* KeyValueSetRequest::release_key() {
  // @@protoc_insertion_point(field_release:xla.KeyValueSetRequest.key)
  
  return key_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void KeyValueSetRequest::set_allocated_key(std::string* key) {
  if (key != nullptr) {
    
  } else {
    
  }
  key_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), key);
  // @@protoc_insertion_point(field_set_allocated:xla.KeyValueSetRequest.key)
}

// bytes value = 3;
inline void KeyValueSetRequest::clear_value() {
  value_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& KeyValueSetRequest::value() const {
  // @@protoc_insertion_point(field_get:xla.KeyValueSetRequest.value)
  return value_.GetNoArena();
}
inline void KeyValueSetRequest::set_value(const std::string& value) {
  
  value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:xla.KeyValueSetRequest.value)
}
inline void KeyValueSetRequest::set_value(std::string&& value) {
  
  value_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:xla.KeyValueSetRequest.value)
}
inline void KeyValueSetRequest::set_value(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:xla.KeyValueSetRequest.value)
}
inline void KeyValueSetRequest::set_value(const void* value, size_t size) {
  
  value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:xla.KeyValueSetRequest.value)
}
inline std::string* KeyValueSetRequest::mutable_value() {
  
  // @@protoc_insertion_point(field_mutable:xla.KeyValueSetRequest.value)
  return value_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* KeyValueSetRequest::release_value() {
  // @@protoc_insertion_point(field_release:xla.KeyValueSetRequest.value)
  
  return value_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void KeyValueSetRequest::set_allocated_value(std::string* value) {
  if (value != nullptr) {
    
  } else {
    
  }
  value_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set_allocated:xla.KeyValueSetRequest.value)
}

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

// KeyValueSetResponse

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

// WaitAtBarrierRequest

// uint64 session_id = 1;
inline void WaitAtBarrierRequest::clear_session_id() {
  session_id_ = PROTOBUF_ULONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 WaitAtBarrierRequest::session_id() const {
  // @@protoc_insertion_point(field_get:xla.WaitAtBarrierRequest.session_id)
  return session_id_;
}
inline void WaitAtBarrierRequest::set_session_id(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  
  session_id_ = value;
  // @@protoc_insertion_point(field_set:xla.WaitAtBarrierRequest.session_id)
}

// bytes barrier_id = 2;
inline void WaitAtBarrierRequest::clear_barrier_id() {
  barrier_id_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& WaitAtBarrierRequest::barrier_id() const {
  // @@protoc_insertion_point(field_get:xla.WaitAtBarrierRequest.barrier_id)
  return barrier_id_.GetNoArena();
}
inline void WaitAtBarrierRequest::set_barrier_id(const std::string& value) {
  
  barrier_id_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:xla.WaitAtBarrierRequest.barrier_id)
}
inline void WaitAtBarrierRequest::set_barrier_id(std::string&& value) {
  
  barrier_id_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:xla.WaitAtBarrierRequest.barrier_id)
}
inline void WaitAtBarrierRequest::set_barrier_id(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  barrier_id_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:xla.WaitAtBarrierRequest.barrier_id)
}
inline void WaitAtBarrierRequest::set_barrier_id(const void* value, size_t size) {
  
  barrier_id_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:xla.WaitAtBarrierRequest.barrier_id)
}
inline std::string* WaitAtBarrierRequest::mutable_barrier_id() {
  
  // @@protoc_insertion_point(field_mutable:xla.WaitAtBarrierRequest.barrier_id)
  return barrier_id_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* WaitAtBarrierRequest::release_barrier_id() {
  // @@protoc_insertion_point(field_release:xla.WaitAtBarrierRequest.barrier_id)
  
  return barrier_id_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void WaitAtBarrierRequest::set_allocated_barrier_id(std::string* barrier_id) {
  if (barrier_id != nullptr) {
    
  } else {
    
  }
  barrier_id_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), barrier_id);
  // @@protoc_insertion_point(field_set_allocated:xla.WaitAtBarrierRequest.barrier_id)
}

// int32 node_id = 3;
inline void WaitAtBarrierRequest::clear_node_id() {
  node_id_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 WaitAtBarrierRequest::node_id() const {
  // @@protoc_insertion_point(field_get:xla.WaitAtBarrierRequest.node_id)
  return node_id_;
}
inline void WaitAtBarrierRequest::set_node_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  node_id_ = value;
  // @@protoc_insertion_point(field_set:xla.WaitAtBarrierRequest.node_id)
}

// int32 timeout_milliseconds = 4;
inline void WaitAtBarrierRequest::clear_timeout_milliseconds() {
  timeout_milliseconds_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 WaitAtBarrierRequest::timeout_milliseconds() const {
  // @@protoc_insertion_point(field_get:xla.WaitAtBarrierRequest.timeout_milliseconds)
  return timeout_milliseconds_;
}
inline void WaitAtBarrierRequest::set_timeout_milliseconds(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  timeout_milliseconds_ = value;
  // @@protoc_insertion_point(field_set:xla.WaitAtBarrierRequest.timeout_milliseconds)
}

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

// WaitAtBarrierResponse

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

// HeartbeatRequest

// uint64 session_id = 1;
inline void HeartbeatRequest::clear_session_id() {
  session_id_ = PROTOBUF_ULONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 HeartbeatRequest::session_id() const {
  // @@protoc_insertion_point(field_get:xla.HeartbeatRequest.session_id)
  return session_id_;
}
inline void HeartbeatRequest::set_session_id(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  
  session_id_ = value;
  // @@protoc_insertion_point(field_set:xla.HeartbeatRequest.session_id)
}

// int32 node_id = 2;
inline void HeartbeatRequest::clear_node_id() {
  node_id_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 HeartbeatRequest::node_id() const {
  // @@protoc_insertion_point(field_get:xla.HeartbeatRequest.node_id)
  return node_id_;
}
inline void HeartbeatRequest::set_node_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  node_id_ = value;
  // @@protoc_insertion_point(field_set:xla.HeartbeatRequest.node_id)
}

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

// HeartbeatResponse

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

// ShutdownRequest

// uint64 session_id = 1;
inline void ShutdownRequest::clear_session_id() {
  session_id_ = PROTOBUF_ULONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 ShutdownRequest::session_id() const {
  // @@protoc_insertion_point(field_get:xla.ShutdownRequest.session_id)
  return session_id_;
}
inline void ShutdownRequest::set_session_id(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  
  session_id_ = value;
  // @@protoc_insertion_point(field_set:xla.ShutdownRequest.session_id)
}

// int32 node_id = 2;
inline void ShutdownRequest::clear_node_id() {
  node_id_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ShutdownRequest::node_id() const {
  // @@protoc_insertion_point(field_get:xla.ShutdownRequest.node_id)
  return node_id_;
}
inline void ShutdownRequest::set_node_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  node_id_ = value;
  // @@protoc_insertion_point(field_set:xla.ShutdownRequest.node_id)
}

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

// ShutdownResponse

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace xla

// @@protoc_insertion_point(global_scope)

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