1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
2 // source: tensorflow/compiler/xla/pjrt/distributed/protocol.proto
3 
4 #ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto
5 #define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto
6 
7 #include <cstdint>
8 #include <limits>
9 #include <string>
10 
11 #include <google/protobuf/port_def.inc>
12 #if PROTOBUF_VERSION < 3021000
13 #error This file was generated by a newer version of protoc which is
14 #error incompatible with your Protocol Buffer headers. Please update
15 #error your headers.
16 #endif
17 #if 3021012 < PROTOBUF_MIN_PROTOC_VERSION
18 #error This file was generated by an older version of protoc which is
19 #error incompatible with your Protocol Buffer headers. Please
20 #error regenerate this file with a newer version of protoc.
21 #endif
22 
23 #include <google/protobuf/port_undef.inc>
24 #include <google/protobuf/io/coded_stream.h>
25 #include <google/protobuf/arena.h>
26 #include <google/protobuf/arenastring.h>
27 #include <google/protobuf/generated_message_util.h>
28 #include <google/protobuf/metadata_lite.h>
29 #include <google/protobuf/message_lite.h>
30 #include <google/protobuf/repeated_field.h>  // IWYU pragma: export
31 #include <google/protobuf/extension_set.h>  // IWYU pragma: export
32 // @@protoc_insertion_point(includes)
33 #include <google/protobuf/port_def.inc>
34 #define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto
35 PROTOBUF_NAMESPACE_OPEN
36 namespace internal {
37 class AnyMetadata;
38 }  // namespace internal
39 PROTOBUF_NAMESPACE_CLOSE
40 
41 // Internal implementation detail -- do not use these members.
42 struct TableStruct_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto {
43   static const ::uint32_t offsets[];
44 };
45 namespace xla {
46 class ConnectRequest;
47 struct ConnectRequestDefaultTypeInternal;
48 extern ConnectRequestDefaultTypeInternal _ConnectRequest_default_instance_;
49 class ConnectResponse;
50 struct ConnectResponseDefaultTypeInternal;
51 extern ConnectResponseDefaultTypeInternal _ConnectResponse_default_instance_;
52 class DeviceProto;
53 struct DeviceProtoDefaultTypeInternal;
54 extern DeviceProtoDefaultTypeInternal _DeviceProto_default_instance_;
55 class EnumerateDevicesRequest;
56 struct EnumerateDevicesRequestDefaultTypeInternal;
57 extern EnumerateDevicesRequestDefaultTypeInternal _EnumerateDevicesRequest_default_instance_;
58 class EnumerateDevicesResponse;
59 struct EnumerateDevicesResponseDefaultTypeInternal;
60 extern EnumerateDevicesResponseDefaultTypeInternal _EnumerateDevicesResponse_default_instance_;
61 class GlobalTopologyProto;
62 struct GlobalTopologyProtoDefaultTypeInternal;
63 extern GlobalTopologyProtoDefaultTypeInternal _GlobalTopologyProto_default_instance_;
64 class HeartbeatRequest;
65 struct HeartbeatRequestDefaultTypeInternal;
66 extern HeartbeatRequestDefaultTypeInternal _HeartbeatRequest_default_instance_;
67 class HeartbeatResponse;
68 struct HeartbeatResponseDefaultTypeInternal;
69 extern HeartbeatResponseDefaultTypeInternal _HeartbeatResponse_default_instance_;
70 class KeyValueGetRequest;
71 struct KeyValueGetRequestDefaultTypeInternal;
72 extern KeyValueGetRequestDefaultTypeInternal _KeyValueGetRequest_default_instance_;
73 class KeyValueGetResponse;
74 struct KeyValueGetResponseDefaultTypeInternal;
75 extern KeyValueGetResponseDefaultTypeInternal _KeyValueGetResponse_default_instance_;
76 class KeyValueSetRequest;
77 struct KeyValueSetRequestDefaultTypeInternal;
78 extern KeyValueSetRequestDefaultTypeInternal _KeyValueSetRequest_default_instance_;
79 class KeyValueSetResponse;
80 struct KeyValueSetResponseDefaultTypeInternal;
81 extern KeyValueSetResponseDefaultTypeInternal _KeyValueSetResponse_default_instance_;
82 class LocalTopologyProto;
83 struct LocalTopologyProtoDefaultTypeInternal;
84 extern LocalTopologyProtoDefaultTypeInternal _LocalTopologyProto_default_instance_;
85 class ShutdownRequest;
86 struct ShutdownRequestDefaultTypeInternal;
87 extern ShutdownRequestDefaultTypeInternal _ShutdownRequest_default_instance_;
88 class ShutdownResponse;
89 struct ShutdownResponseDefaultTypeInternal;
90 extern ShutdownResponseDefaultTypeInternal _ShutdownResponse_default_instance_;
91 class WaitAtBarrierRequest;
92 struct WaitAtBarrierRequestDefaultTypeInternal;
93 extern WaitAtBarrierRequestDefaultTypeInternal _WaitAtBarrierRequest_default_instance_;
94 class WaitAtBarrierResponse;
95 struct WaitAtBarrierResponseDefaultTypeInternal;
96 extern WaitAtBarrierResponseDefaultTypeInternal _WaitAtBarrierResponse_default_instance_;
97 }  // namespace xla
98 PROTOBUF_NAMESPACE_OPEN
99 template<> ::xla::ConnectRequest* Arena::CreateMaybeMessage<::xla::ConnectRequest>(Arena*);
100 template<> ::xla::ConnectResponse* Arena::CreateMaybeMessage<::xla::ConnectResponse>(Arena*);
101 template<> ::xla::DeviceProto* Arena::CreateMaybeMessage<::xla::DeviceProto>(Arena*);
102 template<> ::xla::EnumerateDevicesRequest* Arena::CreateMaybeMessage<::xla::EnumerateDevicesRequest>(Arena*);
103 template<> ::xla::EnumerateDevicesResponse* Arena::CreateMaybeMessage<::xla::EnumerateDevicesResponse>(Arena*);
104 template<> ::xla::GlobalTopologyProto* Arena::CreateMaybeMessage<::xla::GlobalTopologyProto>(Arena*);
105 template<> ::xla::HeartbeatRequest* Arena::CreateMaybeMessage<::xla::HeartbeatRequest>(Arena*);
106 template<> ::xla::HeartbeatResponse* Arena::CreateMaybeMessage<::xla::HeartbeatResponse>(Arena*);
107 template<> ::xla::KeyValueGetRequest* Arena::CreateMaybeMessage<::xla::KeyValueGetRequest>(Arena*);
108 template<> ::xla::KeyValueGetResponse* Arena::CreateMaybeMessage<::xla::KeyValueGetResponse>(Arena*);
109 template<> ::xla::KeyValueSetRequest* Arena::CreateMaybeMessage<::xla::KeyValueSetRequest>(Arena*);
110 template<> ::xla::KeyValueSetResponse* Arena::CreateMaybeMessage<::xla::KeyValueSetResponse>(Arena*);
111 template<> ::xla::LocalTopologyProto* Arena::CreateMaybeMessage<::xla::LocalTopologyProto>(Arena*);
112 template<> ::xla::ShutdownRequest* Arena::CreateMaybeMessage<::xla::ShutdownRequest>(Arena*);
113 template<> ::xla::ShutdownResponse* Arena::CreateMaybeMessage<::xla::ShutdownResponse>(Arena*);
114 template<> ::xla::WaitAtBarrierRequest* Arena::CreateMaybeMessage<::xla::WaitAtBarrierRequest>(Arena*);
115 template<> ::xla::WaitAtBarrierResponse* Arena::CreateMaybeMessage<::xla::WaitAtBarrierResponse>(Arena*);
116 PROTOBUF_NAMESPACE_CLOSE
117 namespace xla {
118 
119 // ===================================================================
120 
121 class DeviceProto final :
122     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:xla.DeviceProto) */ {
123  public:
DeviceProto()124   inline DeviceProto() : DeviceProto(nullptr) {}
125   ~DeviceProto() override;
126   explicit PROTOBUF_CONSTEXPR DeviceProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
127 
128   DeviceProto(const DeviceProto& from);
DeviceProto(DeviceProto && from)129   DeviceProto(DeviceProto&& from) noexcept
130     : DeviceProto() {
131     *this = ::std::move(from);
132   }
133 
134   inline DeviceProto& operator=(const DeviceProto& from) {
135     if (this == &from) return *this;
136     CopyFrom(from);
137     return *this;
138   }
139   inline DeviceProto& operator=(DeviceProto&& from) noexcept {
140     if (this == &from) return *this;
141     if (GetOwningArena() == from.GetOwningArena()
142   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
143         && GetOwningArena() != nullptr
144   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
145     ) {
146       InternalSwap(&from);
147     } else {
148       CopyFrom(from);
149     }
150     return *this;
151   }
152 
default_instance()153   static const DeviceProto& default_instance() {
154     return *internal_default_instance();
155   }
internal_default_instance()156   static inline const DeviceProto* internal_default_instance() {
157     return reinterpret_cast<const DeviceProto*>(
158                &_DeviceProto_default_instance_);
159   }
160   static constexpr int kIndexInFileMessages =
161     0;
162 
swap(DeviceProto & a,DeviceProto & b)163   friend void swap(DeviceProto& a, DeviceProto& b) {
164     a.Swap(&b);
165   }
Swap(DeviceProto * other)166   inline void Swap(DeviceProto* other) {
167     if (other == this) return;
168   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
169     if (GetOwningArena() != nullptr &&
170         GetOwningArena() == other->GetOwningArena()) {
171    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
172     if (GetOwningArena() == other->GetOwningArena()) {
173   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
174       InternalSwap(other);
175     } else {
176       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
177     }
178   }
179   void UnsafeArenaSwap(DeviceProto* other) {
180     if (other == this) return;
181     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
182     InternalSwap(other);
183   }
184 
185   // implements Message ----------------------------------------------
186 
187   DeviceProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
188     return CreateMaybeMessage<DeviceProto>(arena);
189   }
190   DeviceProto* New() const {
191     return New(nullptr);
192   }
193   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
194   void CopyFrom(const DeviceProto& from);
195   void MergeFrom(const DeviceProto& from);
196   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
197   bool IsInitialized() const final;
198 
199   size_t ByteSizeLong() const final;
200   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
201   ::uint8_t* _InternalSerialize(
202       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
203   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
204 
205   private:
206   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
207   void SharedDtor();
208   void SetCachedSize(int size) const;
209   void InternalSwap(DeviceProto* other);
210 
211   private:
212   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
213   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
214     return "xla.DeviceProto";
215   }
216   protected:
217   explicit DeviceProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
218                        bool is_message_owned = false);
219   public:
220 
221   std::string GetTypeName() const final;
222 
223   // nested types ----------------------------------------------------
224 
225   // accessors -------------------------------------------------------
226 
227   enum : int {
228     kNameFieldNumber = 2,
229     kVendorFieldNumber = 3,
230     kLocalDeviceOrdinalFieldNumber = 1,
231     kGlobalDeviceIdFieldNumber = 4,
232   };
233   // string name = 2;
234   void clear_name();
235   const std::string& name() const;
236   template <typename ArgT0 = const std::string&, typename... ArgT>
237   void set_name(ArgT0&& arg0, ArgT... args);
238   std::string* mutable_name();
239   PROTOBUF_NODISCARD std::string* release_name();
240   void set_allocated_name(std::string* name);
241   private:
242   const std::string& _internal_name() const;
243   inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
244   std::string* _internal_mutable_name();
245   public:
246 
247   // string vendor = 3;
248   void clear_vendor();
249   const std::string& vendor() const;
250   template <typename ArgT0 = const std::string&, typename... ArgT>
251   void set_vendor(ArgT0&& arg0, ArgT... args);
252   std::string* mutable_vendor();
253   PROTOBUF_NODISCARD std::string* release_vendor();
254   void set_allocated_vendor(std::string* vendor);
255   private:
256   const std::string& _internal_vendor() const;
257   inline PROTOBUF_ALWAYS_INLINE void _internal_set_vendor(const std::string& value);
258   std::string* _internal_mutable_vendor();
259   public:
260 
261   // int32 local_device_ordinal = 1;
262   void clear_local_device_ordinal();
263   ::int32_t local_device_ordinal() const;
264   void set_local_device_ordinal(::int32_t value);
265   private:
266   ::int32_t _internal_local_device_ordinal() const;
267   void _internal_set_local_device_ordinal(::int32_t value);
268   public:
269 
270   // int32 global_device_id = 4;
271   void clear_global_device_id();
272   ::int32_t global_device_id() const;
273   void set_global_device_id(::int32_t value);
274   private:
275   ::int32_t _internal_global_device_id() const;
276   void _internal_set_global_device_id(::int32_t value);
277   public:
278 
279   // @@protoc_insertion_point(class_scope:xla.DeviceProto)
280  private:
281   class _Internal;
282 
283   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
284   typedef void InternalArenaConstructable_;
285   typedef void DestructorSkippable_;
286   struct Impl_ {
287     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
288     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr vendor_;
289     ::int32_t local_device_ordinal_;
290     ::int32_t global_device_id_;
291     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
292   };
293   union { Impl_ _impl_; };
294   friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto;
295 };
296 // -------------------------------------------------------------------
297 
298 class LocalTopologyProto final :
299     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:xla.LocalTopologyProto) */ {
300  public:
LocalTopologyProto()301   inline LocalTopologyProto() : LocalTopologyProto(nullptr) {}
302   ~LocalTopologyProto() override;
303   explicit PROTOBUF_CONSTEXPR LocalTopologyProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
304 
305   LocalTopologyProto(const LocalTopologyProto& from);
LocalTopologyProto(LocalTopologyProto && from)306   LocalTopologyProto(LocalTopologyProto&& from) noexcept
307     : LocalTopologyProto() {
308     *this = ::std::move(from);
309   }
310 
311   inline LocalTopologyProto& operator=(const LocalTopologyProto& from) {
312     if (this == &from) return *this;
313     CopyFrom(from);
314     return *this;
315   }
316   inline LocalTopologyProto& operator=(LocalTopologyProto&& from) noexcept {
317     if (this == &from) return *this;
318     if (GetOwningArena() == from.GetOwningArena()
319   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
320         && GetOwningArena() != nullptr
321   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
322     ) {
323       InternalSwap(&from);
324     } else {
325       CopyFrom(from);
326     }
327     return *this;
328   }
329 
default_instance()330   static const LocalTopologyProto& default_instance() {
331     return *internal_default_instance();
332   }
internal_default_instance()333   static inline const LocalTopologyProto* internal_default_instance() {
334     return reinterpret_cast<const LocalTopologyProto*>(
335                &_LocalTopologyProto_default_instance_);
336   }
337   static constexpr int kIndexInFileMessages =
338     1;
339 
swap(LocalTopologyProto & a,LocalTopologyProto & b)340   friend void swap(LocalTopologyProto& a, LocalTopologyProto& b) {
341     a.Swap(&b);
342   }
Swap(LocalTopologyProto * other)343   inline void Swap(LocalTopologyProto* other) {
344     if (other == this) return;
345   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
346     if (GetOwningArena() != nullptr &&
347         GetOwningArena() == other->GetOwningArena()) {
348    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
349     if (GetOwningArena() == other->GetOwningArena()) {
350   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
351       InternalSwap(other);
352     } else {
353       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
354     }
355   }
356   void UnsafeArenaSwap(LocalTopologyProto* other) {
357     if (other == this) return;
358     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
359     InternalSwap(other);
360   }
361 
362   // implements Message ----------------------------------------------
363 
364   LocalTopologyProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
365     return CreateMaybeMessage<LocalTopologyProto>(arena);
366   }
367   LocalTopologyProto* New() const {
368     return New(nullptr);
369   }
370   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
371   void CopyFrom(const LocalTopologyProto& from);
372   void MergeFrom(const LocalTopologyProto& from);
373   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
374   bool IsInitialized() const final;
375 
376   size_t ByteSizeLong() const final;
377   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
378   ::uint8_t* _InternalSerialize(
379       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
380   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
381 
382   private:
383   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
384   void SharedDtor();
385   void SetCachedSize(int size) const;
386   void InternalSwap(LocalTopologyProto* other);
387 
388   private:
389   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
390   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
391     return "xla.LocalTopologyProto";
392   }
393   protected:
394   explicit LocalTopologyProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
395                        bool is_message_owned = false);
396   public:
397 
398   std::string GetTypeName() const final;
399 
400   // nested types ----------------------------------------------------
401 
402   // accessors -------------------------------------------------------
403 
404   enum : int {
405     kDevicesFieldNumber = 2,
406     kNodeIdFieldNumber = 1,
407   };
408   // repeated .xla.DeviceProto devices = 2;
409   int devices_size() const;
410   private:
411   int _internal_devices_size() const;
412   public:
413   void clear_devices();
414   ::xla::DeviceProto* mutable_devices(int index);
415   ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::DeviceProto >*
416       mutable_devices();
417   private:
418   const ::xla::DeviceProto& _internal_devices(int index) const;
419   ::xla::DeviceProto* _internal_add_devices();
420   public:
421   const ::xla::DeviceProto& devices(int index) const;
422   ::xla::DeviceProto* add_devices();
423   const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::DeviceProto >&
424       devices() const;
425 
426   // int32 node_id = 1;
427   void clear_node_id();
428   ::int32_t node_id() const;
429   void set_node_id(::int32_t value);
430   private:
431   ::int32_t _internal_node_id() const;
432   void _internal_set_node_id(::int32_t value);
433   public:
434 
435   // @@protoc_insertion_point(class_scope:xla.LocalTopologyProto)
436  private:
437   class _Internal;
438 
439   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
440   typedef void InternalArenaConstructable_;
441   typedef void DestructorSkippable_;
442   struct Impl_ {
443     ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::DeviceProto > devices_;
444     ::int32_t node_id_;
445     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
446   };
447   union { Impl_ _impl_; };
448   friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto;
449 };
450 // -------------------------------------------------------------------
451 
452 class GlobalTopologyProto final :
453     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:xla.GlobalTopologyProto) */ {
454  public:
GlobalTopologyProto()455   inline GlobalTopologyProto() : GlobalTopologyProto(nullptr) {}
456   ~GlobalTopologyProto() override;
457   explicit PROTOBUF_CONSTEXPR GlobalTopologyProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
458 
459   GlobalTopologyProto(const GlobalTopologyProto& from);
GlobalTopologyProto(GlobalTopologyProto && from)460   GlobalTopologyProto(GlobalTopologyProto&& from) noexcept
461     : GlobalTopologyProto() {
462     *this = ::std::move(from);
463   }
464 
465   inline GlobalTopologyProto& operator=(const GlobalTopologyProto& from) {
466     if (this == &from) return *this;
467     CopyFrom(from);
468     return *this;
469   }
470   inline GlobalTopologyProto& operator=(GlobalTopologyProto&& from) noexcept {
471     if (this == &from) return *this;
472     if (GetOwningArena() == from.GetOwningArena()
473   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
474         && GetOwningArena() != nullptr
475   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
476     ) {
477       InternalSwap(&from);
478     } else {
479       CopyFrom(from);
480     }
481     return *this;
482   }
483 
default_instance()484   static const GlobalTopologyProto& default_instance() {
485     return *internal_default_instance();
486   }
internal_default_instance()487   static inline const GlobalTopologyProto* internal_default_instance() {
488     return reinterpret_cast<const GlobalTopologyProto*>(
489                &_GlobalTopologyProto_default_instance_);
490   }
491   static constexpr int kIndexInFileMessages =
492     2;
493 
swap(GlobalTopologyProto & a,GlobalTopologyProto & b)494   friend void swap(GlobalTopologyProto& a, GlobalTopologyProto& b) {
495     a.Swap(&b);
496   }
Swap(GlobalTopologyProto * other)497   inline void Swap(GlobalTopologyProto* other) {
498     if (other == this) return;
499   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
500     if (GetOwningArena() != nullptr &&
501         GetOwningArena() == other->GetOwningArena()) {
502    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
503     if (GetOwningArena() == other->GetOwningArena()) {
504   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
505       InternalSwap(other);
506     } else {
507       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
508     }
509   }
510   void UnsafeArenaSwap(GlobalTopologyProto* other) {
511     if (other == this) return;
512     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
513     InternalSwap(other);
514   }
515 
516   // implements Message ----------------------------------------------
517 
518   GlobalTopologyProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
519     return CreateMaybeMessage<GlobalTopologyProto>(arena);
520   }
521   GlobalTopologyProto* New() const {
522     return New(nullptr);
523   }
524   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
525   void CopyFrom(const GlobalTopologyProto& from);
526   void MergeFrom(const GlobalTopologyProto& from);
527   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
528   bool IsInitialized() const final;
529 
530   size_t ByteSizeLong() const final;
531   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
532   ::uint8_t* _InternalSerialize(
533       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
534   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
535 
536   private:
537   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
538   void SharedDtor();
539   void SetCachedSize(int size) const;
540   void InternalSwap(GlobalTopologyProto* other);
541 
542   private:
543   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
544   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
545     return "xla.GlobalTopologyProto";
546   }
547   protected:
548   explicit GlobalTopologyProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
549                        bool is_message_owned = false);
550   public:
551 
552   std::string GetTypeName() const final;
553 
554   // nested types ----------------------------------------------------
555 
556   // accessors -------------------------------------------------------
557 
558   enum : int {
559     kNodesFieldNumber = 1,
560   };
561   // repeated .xla.LocalTopologyProto nodes = 1;
562   int nodes_size() const;
563   private:
564   int _internal_nodes_size() const;
565   public:
566   void clear_nodes();
567   ::xla::LocalTopologyProto* mutable_nodes(int index);
568   ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::LocalTopologyProto >*
569       mutable_nodes();
570   private:
571   const ::xla::LocalTopologyProto& _internal_nodes(int index) const;
572   ::xla::LocalTopologyProto* _internal_add_nodes();
573   public:
574   const ::xla::LocalTopologyProto& nodes(int index) const;
575   ::xla::LocalTopologyProto* add_nodes();
576   const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::LocalTopologyProto >&
577       nodes() const;
578 
579   // @@protoc_insertion_point(class_scope:xla.GlobalTopologyProto)
580  private:
581   class _Internal;
582 
583   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
584   typedef void InternalArenaConstructable_;
585   typedef void DestructorSkippable_;
586   struct Impl_ {
587     ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::LocalTopologyProto > nodes_;
588     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
589   };
590   union { Impl_ _impl_; };
591   friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto;
592 };
593 // -------------------------------------------------------------------
594 
595 class ConnectRequest final :
596     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:xla.ConnectRequest) */ {
597  public:
ConnectRequest()598   inline ConnectRequest() : ConnectRequest(nullptr) {}
599   ~ConnectRequest() override;
600   explicit PROTOBUF_CONSTEXPR ConnectRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
601 
602   ConnectRequest(const ConnectRequest& from);
ConnectRequest(ConnectRequest && from)603   ConnectRequest(ConnectRequest&& from) noexcept
604     : ConnectRequest() {
605     *this = ::std::move(from);
606   }
607 
608   inline ConnectRequest& operator=(const ConnectRequest& from) {
609     if (this == &from) return *this;
610     CopyFrom(from);
611     return *this;
612   }
613   inline ConnectRequest& operator=(ConnectRequest&& from) noexcept {
614     if (this == &from) return *this;
615     if (GetOwningArena() == from.GetOwningArena()
616   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
617         && GetOwningArena() != nullptr
618   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
619     ) {
620       InternalSwap(&from);
621     } else {
622       CopyFrom(from);
623     }
624     return *this;
625   }
626 
default_instance()627   static const ConnectRequest& default_instance() {
628     return *internal_default_instance();
629   }
internal_default_instance()630   static inline const ConnectRequest* internal_default_instance() {
631     return reinterpret_cast<const ConnectRequest*>(
632                &_ConnectRequest_default_instance_);
633   }
634   static constexpr int kIndexInFileMessages =
635     3;
636 
swap(ConnectRequest & a,ConnectRequest & b)637   friend void swap(ConnectRequest& a, ConnectRequest& b) {
638     a.Swap(&b);
639   }
Swap(ConnectRequest * other)640   inline void Swap(ConnectRequest* other) {
641     if (other == this) return;
642   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
643     if (GetOwningArena() != nullptr &&
644         GetOwningArena() == other->GetOwningArena()) {
645    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
646     if (GetOwningArena() == other->GetOwningArena()) {
647   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
648       InternalSwap(other);
649     } else {
650       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
651     }
652   }
653   void UnsafeArenaSwap(ConnectRequest* other) {
654     if (other == this) return;
655     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
656     InternalSwap(other);
657   }
658 
659   // implements Message ----------------------------------------------
660 
661   ConnectRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
662     return CreateMaybeMessage<ConnectRequest>(arena);
663   }
664   ConnectRequest* New() const {
665     return New(nullptr);
666   }
667   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
668   void CopyFrom(const ConnectRequest& from);
669   void MergeFrom(const ConnectRequest& from);
670   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
671   bool IsInitialized() const final;
672 
673   size_t ByteSizeLong() const final;
674   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
675   ::uint8_t* _InternalSerialize(
676       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
677   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
678 
679   private:
680   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
681   void SharedDtor();
682   void SetCachedSize(int size) const;
683   void InternalSwap(ConnectRequest* other);
684 
685   private:
686   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
687   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
688     return "xla.ConnectRequest";
689   }
690   protected:
691   explicit ConnectRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
692                        bool is_message_owned = false);
693   public:
694 
695   std::string GetTypeName() const final;
696 
697   // nested types ----------------------------------------------------
698 
699   // accessors -------------------------------------------------------
700 
701   enum : int {
702     kProtocolVersionFieldNumber = 1,
703     kTimeoutMillisecondsFieldNumber = 2,
704     kClientIdFieldNumber = 4,
705     kNodeIdFieldNumber = 3,
706   };
707   // int32 protocol_version = 1;
708   void clear_protocol_version();
709   ::int32_t protocol_version() const;
710   void set_protocol_version(::int32_t value);
711   private:
712   ::int32_t _internal_protocol_version() const;
713   void _internal_set_protocol_version(::int32_t value);
714   public:
715 
716   // int32 timeout_milliseconds = 2;
717   void clear_timeout_milliseconds();
718   ::int32_t timeout_milliseconds() const;
719   void set_timeout_milliseconds(::int32_t value);
720   private:
721   ::int32_t _internal_timeout_milliseconds() const;
722   void _internal_set_timeout_milliseconds(::int32_t value);
723   public:
724 
725   // uint64 client_id = 4;
726   void clear_client_id();
727   ::uint64_t client_id() const;
728   void set_client_id(::uint64_t value);
729   private:
730   ::uint64_t _internal_client_id() const;
731   void _internal_set_client_id(::uint64_t value);
732   public:
733 
734   // int32 node_id = 3;
735   void clear_node_id();
736   ::int32_t node_id() const;
737   void set_node_id(::int32_t value);
738   private:
739   ::int32_t _internal_node_id() const;
740   void _internal_set_node_id(::int32_t value);
741   public:
742 
743   // @@protoc_insertion_point(class_scope:xla.ConnectRequest)
744  private:
745   class _Internal;
746 
747   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
748   typedef void InternalArenaConstructable_;
749   typedef void DestructorSkippable_;
750   struct Impl_ {
751     ::int32_t protocol_version_;
752     ::int32_t timeout_milliseconds_;
753     ::uint64_t client_id_;
754     ::int32_t node_id_;
755     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
756   };
757   union { Impl_ _impl_; };
758   friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto;
759 };
760 // -------------------------------------------------------------------
761 
762 class ConnectResponse final :
763     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:xla.ConnectResponse) */ {
764  public:
ConnectResponse()765   inline ConnectResponse() : ConnectResponse(nullptr) {}
766   ~ConnectResponse() override;
767   explicit PROTOBUF_CONSTEXPR ConnectResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
768 
769   ConnectResponse(const ConnectResponse& from);
ConnectResponse(ConnectResponse && from)770   ConnectResponse(ConnectResponse&& from) noexcept
771     : ConnectResponse() {
772     *this = ::std::move(from);
773   }
774 
775   inline ConnectResponse& operator=(const ConnectResponse& from) {
776     if (this == &from) return *this;
777     CopyFrom(from);
778     return *this;
779   }
780   inline ConnectResponse& operator=(ConnectResponse&& from) noexcept {
781     if (this == &from) return *this;
782     if (GetOwningArena() == from.GetOwningArena()
783   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
784         && GetOwningArena() != nullptr
785   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
786     ) {
787       InternalSwap(&from);
788     } else {
789       CopyFrom(from);
790     }
791     return *this;
792   }
793 
default_instance()794   static const ConnectResponse& default_instance() {
795     return *internal_default_instance();
796   }
internal_default_instance()797   static inline const ConnectResponse* internal_default_instance() {
798     return reinterpret_cast<const ConnectResponse*>(
799                &_ConnectResponse_default_instance_);
800   }
801   static constexpr int kIndexInFileMessages =
802     4;
803 
swap(ConnectResponse & a,ConnectResponse & b)804   friend void swap(ConnectResponse& a, ConnectResponse& b) {
805     a.Swap(&b);
806   }
Swap(ConnectResponse * other)807   inline void Swap(ConnectResponse* other) {
808     if (other == this) return;
809   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
810     if (GetOwningArena() != nullptr &&
811         GetOwningArena() == other->GetOwningArena()) {
812    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
813     if (GetOwningArena() == other->GetOwningArena()) {
814   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
815       InternalSwap(other);
816     } else {
817       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
818     }
819   }
820   void UnsafeArenaSwap(ConnectResponse* other) {
821     if (other == this) return;
822     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
823     InternalSwap(other);
824   }
825 
826   // implements Message ----------------------------------------------
827 
828   ConnectResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
829     return CreateMaybeMessage<ConnectResponse>(arena);
830   }
831   ConnectResponse* New() const {
832     return New(nullptr);
833   }
834   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
835   void CopyFrom(const ConnectResponse& from);
836   void MergeFrom(const ConnectResponse& from);
837   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
838   bool IsInitialized() const final;
839 
840   size_t ByteSizeLong() const final;
841   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
842   ::uint8_t* _InternalSerialize(
843       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
844   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
845 
846   private:
847   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
848   void SharedDtor();
849   void SetCachedSize(int size) const;
850   void InternalSwap(ConnectResponse* other);
851 
852   private:
853   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
854   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
855     return "xla.ConnectResponse";
856   }
857   protected:
858   explicit ConnectResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
859                        bool is_message_owned = false);
860   public:
861 
862   std::string GetTypeName() const final;
863 
864   // nested types ----------------------------------------------------
865 
866   // accessors -------------------------------------------------------
867 
868   enum : int {
869     kSessionIdFieldNumber = 1,
870   };
871   // uint64 session_id = 1;
872   void clear_session_id();
873   ::uint64_t session_id() const;
874   void set_session_id(::uint64_t value);
875   private:
876   ::uint64_t _internal_session_id() const;
877   void _internal_set_session_id(::uint64_t value);
878   public:
879 
880   // @@protoc_insertion_point(class_scope:xla.ConnectResponse)
881  private:
882   class _Internal;
883 
884   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
885   typedef void InternalArenaConstructable_;
886   typedef void DestructorSkippable_;
887   struct Impl_ {
888     ::uint64_t session_id_;
889     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
890   };
891   union { Impl_ _impl_; };
892   friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto;
893 };
894 // -------------------------------------------------------------------
895 
896 class EnumerateDevicesRequest final :
897     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:xla.EnumerateDevicesRequest) */ {
898  public:
EnumerateDevicesRequest()899   inline EnumerateDevicesRequest() : EnumerateDevicesRequest(nullptr) {}
900   ~EnumerateDevicesRequest() override;
901   explicit PROTOBUF_CONSTEXPR EnumerateDevicesRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
902 
903   EnumerateDevicesRequest(const EnumerateDevicesRequest& from);
EnumerateDevicesRequest(EnumerateDevicesRequest && from)904   EnumerateDevicesRequest(EnumerateDevicesRequest&& from) noexcept
905     : EnumerateDevicesRequest() {
906     *this = ::std::move(from);
907   }
908 
909   inline EnumerateDevicesRequest& operator=(const EnumerateDevicesRequest& from) {
910     if (this == &from) return *this;
911     CopyFrom(from);
912     return *this;
913   }
914   inline EnumerateDevicesRequest& operator=(EnumerateDevicesRequest&& from) noexcept {
915     if (this == &from) return *this;
916     if (GetOwningArena() == from.GetOwningArena()
917   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
918         && GetOwningArena() != nullptr
919   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
920     ) {
921       InternalSwap(&from);
922     } else {
923       CopyFrom(from);
924     }
925     return *this;
926   }
927 
default_instance()928   static const EnumerateDevicesRequest& default_instance() {
929     return *internal_default_instance();
930   }
internal_default_instance()931   static inline const EnumerateDevicesRequest* internal_default_instance() {
932     return reinterpret_cast<const EnumerateDevicesRequest*>(
933                &_EnumerateDevicesRequest_default_instance_);
934   }
935   static constexpr int kIndexInFileMessages =
936     5;
937 
swap(EnumerateDevicesRequest & a,EnumerateDevicesRequest & b)938   friend void swap(EnumerateDevicesRequest& a, EnumerateDevicesRequest& b) {
939     a.Swap(&b);
940   }
Swap(EnumerateDevicesRequest * other)941   inline void Swap(EnumerateDevicesRequest* other) {
942     if (other == this) return;
943   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
944     if (GetOwningArena() != nullptr &&
945         GetOwningArena() == other->GetOwningArena()) {
946    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
947     if (GetOwningArena() == other->GetOwningArena()) {
948   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
949       InternalSwap(other);
950     } else {
951       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
952     }
953   }
954   void UnsafeArenaSwap(EnumerateDevicesRequest* other) {
955     if (other == this) return;
956     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
957     InternalSwap(other);
958   }
959 
960   // implements Message ----------------------------------------------
961 
962   EnumerateDevicesRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
963     return CreateMaybeMessage<EnumerateDevicesRequest>(arena);
964   }
965   EnumerateDevicesRequest* New() const {
966     return New(nullptr);
967   }
968   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
969   void CopyFrom(const EnumerateDevicesRequest& from);
970   void MergeFrom(const EnumerateDevicesRequest& from);
971   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
972   bool IsInitialized() const final;
973 
974   size_t ByteSizeLong() const final;
975   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
976   ::uint8_t* _InternalSerialize(
977       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
978   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
979 
980   private:
981   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
982   void SharedDtor();
983   void SetCachedSize(int size) const;
984   void InternalSwap(EnumerateDevicesRequest* other);
985 
986   private:
987   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
988   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
989     return "xla.EnumerateDevicesRequest";
990   }
991   protected:
992   explicit EnumerateDevicesRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
993                        bool is_message_owned = false);
994   public:
995 
996   std::string GetTypeName() const final;
997 
998   // nested types ----------------------------------------------------
999 
1000   // accessors -------------------------------------------------------
1001 
1002   enum : int {
1003     kLocalTopologyFieldNumber = 3,
1004     kSessionIdFieldNumber = 1,
1005   };
1006   // .xla.LocalTopologyProto local_topology = 3;
1007   bool has_local_topology() const;
1008   private:
1009   bool _internal_has_local_topology() const;
1010   public:
1011   void clear_local_topology();
1012   const ::xla::LocalTopologyProto& local_topology() const;
1013   PROTOBUF_NODISCARD ::xla::LocalTopologyProto* release_local_topology();
1014   ::xla::LocalTopologyProto* mutable_local_topology();
1015   void set_allocated_local_topology(::xla::LocalTopologyProto* local_topology);
1016   private:
1017   const ::xla::LocalTopologyProto& _internal_local_topology() const;
1018   ::xla::LocalTopologyProto* _internal_mutable_local_topology();
1019   public:
1020   void unsafe_arena_set_allocated_local_topology(
1021       ::xla::LocalTopologyProto* local_topology);
1022   ::xla::LocalTopologyProto* unsafe_arena_release_local_topology();
1023 
1024   // uint64 session_id = 1;
1025   void clear_session_id();
1026   ::uint64_t session_id() const;
1027   void set_session_id(::uint64_t value);
1028   private:
1029   ::uint64_t _internal_session_id() const;
1030   void _internal_set_session_id(::uint64_t value);
1031   public:
1032 
1033   // @@protoc_insertion_point(class_scope:xla.EnumerateDevicesRequest)
1034  private:
1035   class _Internal;
1036 
1037   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1038   typedef void InternalArenaConstructable_;
1039   typedef void DestructorSkippable_;
1040   struct Impl_ {
1041     ::xla::LocalTopologyProto* local_topology_;
1042     ::uint64_t session_id_;
1043     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1044   };
1045   union { Impl_ _impl_; };
1046   friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto;
1047 };
1048 // -------------------------------------------------------------------
1049 
1050 class EnumerateDevicesResponse final :
1051     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:xla.EnumerateDevicesResponse) */ {
1052  public:
EnumerateDevicesResponse()1053   inline EnumerateDevicesResponse() : EnumerateDevicesResponse(nullptr) {}
1054   ~EnumerateDevicesResponse() override;
1055   explicit PROTOBUF_CONSTEXPR EnumerateDevicesResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1056 
1057   EnumerateDevicesResponse(const EnumerateDevicesResponse& from);
EnumerateDevicesResponse(EnumerateDevicesResponse && from)1058   EnumerateDevicesResponse(EnumerateDevicesResponse&& from) noexcept
1059     : EnumerateDevicesResponse() {
1060     *this = ::std::move(from);
1061   }
1062 
1063   inline EnumerateDevicesResponse& operator=(const EnumerateDevicesResponse& from) {
1064     if (this == &from) return *this;
1065     CopyFrom(from);
1066     return *this;
1067   }
1068   inline EnumerateDevicesResponse& operator=(EnumerateDevicesResponse&& from) noexcept {
1069     if (this == &from) return *this;
1070     if (GetOwningArena() == from.GetOwningArena()
1071   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1072         && GetOwningArena() != nullptr
1073   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
1074     ) {
1075       InternalSwap(&from);
1076     } else {
1077       CopyFrom(from);
1078     }
1079     return *this;
1080   }
1081 
default_instance()1082   static const EnumerateDevicesResponse& default_instance() {
1083     return *internal_default_instance();
1084   }
internal_default_instance()1085   static inline const EnumerateDevicesResponse* internal_default_instance() {
1086     return reinterpret_cast<const EnumerateDevicesResponse*>(
1087                &_EnumerateDevicesResponse_default_instance_);
1088   }
1089   static constexpr int kIndexInFileMessages =
1090     6;
1091 
swap(EnumerateDevicesResponse & a,EnumerateDevicesResponse & b)1092   friend void swap(EnumerateDevicesResponse& a, EnumerateDevicesResponse& b) {
1093     a.Swap(&b);
1094   }
Swap(EnumerateDevicesResponse * other)1095   inline void Swap(EnumerateDevicesResponse* other) {
1096     if (other == this) return;
1097   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1098     if (GetOwningArena() != nullptr &&
1099         GetOwningArena() == other->GetOwningArena()) {
1100    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
1101     if (GetOwningArena() == other->GetOwningArena()) {
1102   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
1103       InternalSwap(other);
1104     } else {
1105       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1106     }
1107   }
1108   void UnsafeArenaSwap(EnumerateDevicesResponse* other) {
1109     if (other == this) return;
1110     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1111     InternalSwap(other);
1112   }
1113 
1114   // implements Message ----------------------------------------------
1115 
1116   EnumerateDevicesResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1117     return CreateMaybeMessage<EnumerateDevicesResponse>(arena);
1118   }
1119   EnumerateDevicesResponse* New() const {
1120     return New(nullptr);
1121   }
1122   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
1123   void CopyFrom(const EnumerateDevicesResponse& from);
1124   void MergeFrom(const EnumerateDevicesResponse& from);
1125   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1126   bool IsInitialized() const final;
1127 
1128   size_t ByteSizeLong() const final;
1129   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1130   ::uint8_t* _InternalSerialize(
1131       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1132   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1133 
1134   private:
1135   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1136   void SharedDtor();
1137   void SetCachedSize(int size) const;
1138   void InternalSwap(EnumerateDevicesResponse* other);
1139 
1140   private:
1141   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1142   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1143     return "xla.EnumerateDevicesResponse";
1144   }
1145   protected:
1146   explicit EnumerateDevicesResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1147                        bool is_message_owned = false);
1148   public:
1149 
1150   std::string GetTypeName() const final;
1151 
1152   // nested types ----------------------------------------------------
1153 
1154   // accessors -------------------------------------------------------
1155 
1156   enum : int {
1157     kGlobalTopologyFieldNumber = 1,
1158   };
1159   // .xla.GlobalTopologyProto global_topology = 1;
1160   bool has_global_topology() const;
1161   private:
1162   bool _internal_has_global_topology() const;
1163   public:
1164   void clear_global_topology();
1165   const ::xla::GlobalTopologyProto& global_topology() const;
1166   PROTOBUF_NODISCARD ::xla::GlobalTopologyProto* release_global_topology();
1167   ::xla::GlobalTopologyProto* mutable_global_topology();
1168   void set_allocated_global_topology(::xla::GlobalTopologyProto* global_topology);
1169   private:
1170   const ::xla::GlobalTopologyProto& _internal_global_topology() const;
1171   ::xla::GlobalTopologyProto* _internal_mutable_global_topology();
1172   public:
1173   void unsafe_arena_set_allocated_global_topology(
1174       ::xla::GlobalTopologyProto* global_topology);
1175   ::xla::GlobalTopologyProto* unsafe_arena_release_global_topology();
1176 
1177   // @@protoc_insertion_point(class_scope:xla.EnumerateDevicesResponse)
1178  private:
1179   class _Internal;
1180 
1181   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1182   typedef void InternalArenaConstructable_;
1183   typedef void DestructorSkippable_;
1184   struct Impl_ {
1185     ::xla::GlobalTopologyProto* global_topology_;
1186     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1187   };
1188   union { Impl_ _impl_; };
1189   friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto;
1190 };
1191 // -------------------------------------------------------------------
1192 
1193 class KeyValueGetRequest final :
1194     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:xla.KeyValueGetRequest) */ {
1195  public:
KeyValueGetRequest()1196   inline KeyValueGetRequest() : KeyValueGetRequest(nullptr) {}
1197   ~KeyValueGetRequest() override;
1198   explicit PROTOBUF_CONSTEXPR KeyValueGetRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1199 
1200   KeyValueGetRequest(const KeyValueGetRequest& from);
KeyValueGetRequest(KeyValueGetRequest && from)1201   KeyValueGetRequest(KeyValueGetRequest&& from) noexcept
1202     : KeyValueGetRequest() {
1203     *this = ::std::move(from);
1204   }
1205 
1206   inline KeyValueGetRequest& operator=(const KeyValueGetRequest& from) {
1207     if (this == &from) return *this;
1208     CopyFrom(from);
1209     return *this;
1210   }
1211   inline KeyValueGetRequest& operator=(KeyValueGetRequest&& from) noexcept {
1212     if (this == &from) return *this;
1213     if (GetOwningArena() == from.GetOwningArena()
1214   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1215         && GetOwningArena() != nullptr
1216   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
1217     ) {
1218       InternalSwap(&from);
1219     } else {
1220       CopyFrom(from);
1221     }
1222     return *this;
1223   }
1224 
default_instance()1225   static const KeyValueGetRequest& default_instance() {
1226     return *internal_default_instance();
1227   }
internal_default_instance()1228   static inline const KeyValueGetRequest* internal_default_instance() {
1229     return reinterpret_cast<const KeyValueGetRequest*>(
1230                &_KeyValueGetRequest_default_instance_);
1231   }
1232   static constexpr int kIndexInFileMessages =
1233     7;
1234 
swap(KeyValueGetRequest & a,KeyValueGetRequest & b)1235   friend void swap(KeyValueGetRequest& a, KeyValueGetRequest& b) {
1236     a.Swap(&b);
1237   }
Swap(KeyValueGetRequest * other)1238   inline void Swap(KeyValueGetRequest* other) {
1239     if (other == this) return;
1240   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1241     if (GetOwningArena() != nullptr &&
1242         GetOwningArena() == other->GetOwningArena()) {
1243    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
1244     if (GetOwningArena() == other->GetOwningArena()) {
1245   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
1246       InternalSwap(other);
1247     } else {
1248       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1249     }
1250   }
1251   void UnsafeArenaSwap(KeyValueGetRequest* other) {
1252     if (other == this) return;
1253     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1254     InternalSwap(other);
1255   }
1256 
1257   // implements Message ----------------------------------------------
1258 
1259   KeyValueGetRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1260     return CreateMaybeMessage<KeyValueGetRequest>(arena);
1261   }
1262   KeyValueGetRequest* New() const {
1263     return New(nullptr);
1264   }
1265   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
1266   void CopyFrom(const KeyValueGetRequest& from);
1267   void MergeFrom(const KeyValueGetRequest& from);
1268   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1269   bool IsInitialized() const final;
1270 
1271   size_t ByteSizeLong() const final;
1272   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1273   ::uint8_t* _InternalSerialize(
1274       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1275   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1276 
1277   private:
1278   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1279   void SharedDtor();
1280   void SetCachedSize(int size) const;
1281   void InternalSwap(KeyValueGetRequest* other);
1282 
1283   private:
1284   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1285   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1286     return "xla.KeyValueGetRequest";
1287   }
1288   protected:
1289   explicit KeyValueGetRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1290                        bool is_message_owned = false);
1291   public:
1292 
1293   std::string GetTypeName() const final;
1294 
1295   // nested types ----------------------------------------------------
1296 
1297   // accessors -------------------------------------------------------
1298 
1299   enum : int {
1300     kKeyFieldNumber = 2,
1301     kSessionIdFieldNumber = 1,
1302     kTimeoutMillisecondsFieldNumber = 3,
1303   };
1304   // bytes key = 2;
1305   void clear_key();
1306   const std::string& key() const;
1307   template <typename ArgT0 = const std::string&, typename... ArgT>
1308   void set_key(ArgT0&& arg0, ArgT... args);
1309   std::string* mutable_key();
1310   PROTOBUF_NODISCARD std::string* release_key();
1311   void set_allocated_key(std::string* key);
1312   private:
1313   const std::string& _internal_key() const;
1314   inline PROTOBUF_ALWAYS_INLINE void _internal_set_key(const std::string& value);
1315   std::string* _internal_mutable_key();
1316   public:
1317 
1318   // uint64 session_id = 1;
1319   void clear_session_id();
1320   ::uint64_t session_id() const;
1321   void set_session_id(::uint64_t value);
1322   private:
1323   ::uint64_t _internal_session_id() const;
1324   void _internal_set_session_id(::uint64_t value);
1325   public:
1326 
1327   // int32 timeout_milliseconds = 3;
1328   void clear_timeout_milliseconds();
1329   ::int32_t timeout_milliseconds() const;
1330   void set_timeout_milliseconds(::int32_t value);
1331   private:
1332   ::int32_t _internal_timeout_milliseconds() const;
1333   void _internal_set_timeout_milliseconds(::int32_t value);
1334   public:
1335 
1336   // @@protoc_insertion_point(class_scope:xla.KeyValueGetRequest)
1337  private:
1338   class _Internal;
1339 
1340   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1341   typedef void InternalArenaConstructable_;
1342   typedef void DestructorSkippable_;
1343   struct Impl_ {
1344     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_;
1345     ::uint64_t session_id_;
1346     ::int32_t timeout_milliseconds_;
1347     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1348   };
1349   union { Impl_ _impl_; };
1350   friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto;
1351 };
1352 // -------------------------------------------------------------------
1353 
1354 class KeyValueGetResponse final :
1355     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:xla.KeyValueGetResponse) */ {
1356  public:
KeyValueGetResponse()1357   inline KeyValueGetResponse() : KeyValueGetResponse(nullptr) {}
1358   ~KeyValueGetResponse() override;
1359   explicit PROTOBUF_CONSTEXPR KeyValueGetResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1360 
1361   KeyValueGetResponse(const KeyValueGetResponse& from);
KeyValueGetResponse(KeyValueGetResponse && from)1362   KeyValueGetResponse(KeyValueGetResponse&& from) noexcept
1363     : KeyValueGetResponse() {
1364     *this = ::std::move(from);
1365   }
1366 
1367   inline KeyValueGetResponse& operator=(const KeyValueGetResponse& from) {
1368     if (this == &from) return *this;
1369     CopyFrom(from);
1370     return *this;
1371   }
1372   inline KeyValueGetResponse& operator=(KeyValueGetResponse&& from) noexcept {
1373     if (this == &from) return *this;
1374     if (GetOwningArena() == from.GetOwningArena()
1375   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1376         && GetOwningArena() != nullptr
1377   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
1378     ) {
1379       InternalSwap(&from);
1380     } else {
1381       CopyFrom(from);
1382     }
1383     return *this;
1384   }
1385 
default_instance()1386   static const KeyValueGetResponse& default_instance() {
1387     return *internal_default_instance();
1388   }
internal_default_instance()1389   static inline const KeyValueGetResponse* internal_default_instance() {
1390     return reinterpret_cast<const KeyValueGetResponse*>(
1391                &_KeyValueGetResponse_default_instance_);
1392   }
1393   static constexpr int kIndexInFileMessages =
1394     8;
1395 
swap(KeyValueGetResponse & a,KeyValueGetResponse & b)1396   friend void swap(KeyValueGetResponse& a, KeyValueGetResponse& b) {
1397     a.Swap(&b);
1398   }
Swap(KeyValueGetResponse * other)1399   inline void Swap(KeyValueGetResponse* other) {
1400     if (other == this) return;
1401   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1402     if (GetOwningArena() != nullptr &&
1403         GetOwningArena() == other->GetOwningArena()) {
1404    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
1405     if (GetOwningArena() == other->GetOwningArena()) {
1406   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
1407       InternalSwap(other);
1408     } else {
1409       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1410     }
1411   }
1412   void UnsafeArenaSwap(KeyValueGetResponse* other) {
1413     if (other == this) return;
1414     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1415     InternalSwap(other);
1416   }
1417 
1418   // implements Message ----------------------------------------------
1419 
1420   KeyValueGetResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1421     return CreateMaybeMessage<KeyValueGetResponse>(arena);
1422   }
1423   KeyValueGetResponse* New() const {
1424     return New(nullptr);
1425   }
1426   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
1427   void CopyFrom(const KeyValueGetResponse& from);
1428   void MergeFrom(const KeyValueGetResponse& from);
1429   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1430   bool IsInitialized() const final;
1431 
1432   size_t ByteSizeLong() const final;
1433   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1434   ::uint8_t* _InternalSerialize(
1435       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1436   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1437 
1438   private:
1439   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1440   void SharedDtor();
1441   void SetCachedSize(int size) const;
1442   void InternalSwap(KeyValueGetResponse* other);
1443 
1444   private:
1445   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1446   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1447     return "xla.KeyValueGetResponse";
1448   }
1449   protected:
1450   explicit KeyValueGetResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1451                        bool is_message_owned = false);
1452   public:
1453 
1454   std::string GetTypeName() const final;
1455 
1456   // nested types ----------------------------------------------------
1457 
1458   // accessors -------------------------------------------------------
1459 
1460   enum : int {
1461     kValueFieldNumber = 2,
1462     kFoundFieldNumber = 1,
1463   };
1464   // bytes value = 2;
1465   void clear_value();
1466   const std::string& value() const;
1467   template <typename ArgT0 = const std::string&, typename... ArgT>
1468   void set_value(ArgT0&& arg0, ArgT... args);
1469   std::string* mutable_value();
1470   PROTOBUF_NODISCARD std::string* release_value();
1471   void set_allocated_value(std::string* value);
1472   private:
1473   const std::string& _internal_value() const;
1474   inline PROTOBUF_ALWAYS_INLINE void _internal_set_value(const std::string& value);
1475   std::string* _internal_mutable_value();
1476   public:
1477 
1478   // bool found = 1;
1479   void clear_found();
1480   bool found() const;
1481   void set_found(bool value);
1482   private:
1483   bool _internal_found() const;
1484   void _internal_set_found(bool value);
1485   public:
1486 
1487   // @@protoc_insertion_point(class_scope:xla.KeyValueGetResponse)
1488  private:
1489   class _Internal;
1490 
1491   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1492   typedef void InternalArenaConstructable_;
1493   typedef void DestructorSkippable_;
1494   struct Impl_ {
1495     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
1496     bool found_;
1497     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1498   };
1499   union { Impl_ _impl_; };
1500   friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto;
1501 };
1502 // -------------------------------------------------------------------
1503 
1504 class KeyValueSetRequest final :
1505     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:xla.KeyValueSetRequest) */ {
1506  public:
KeyValueSetRequest()1507   inline KeyValueSetRequest() : KeyValueSetRequest(nullptr) {}
1508   ~KeyValueSetRequest() override;
1509   explicit PROTOBUF_CONSTEXPR KeyValueSetRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1510 
1511   KeyValueSetRequest(const KeyValueSetRequest& from);
KeyValueSetRequest(KeyValueSetRequest && from)1512   KeyValueSetRequest(KeyValueSetRequest&& from) noexcept
1513     : KeyValueSetRequest() {
1514     *this = ::std::move(from);
1515   }
1516 
1517   inline KeyValueSetRequest& operator=(const KeyValueSetRequest& from) {
1518     if (this == &from) return *this;
1519     CopyFrom(from);
1520     return *this;
1521   }
1522   inline KeyValueSetRequest& operator=(KeyValueSetRequest&& from) noexcept {
1523     if (this == &from) return *this;
1524     if (GetOwningArena() == from.GetOwningArena()
1525   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1526         && GetOwningArena() != nullptr
1527   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
1528     ) {
1529       InternalSwap(&from);
1530     } else {
1531       CopyFrom(from);
1532     }
1533     return *this;
1534   }
1535 
default_instance()1536   static const KeyValueSetRequest& default_instance() {
1537     return *internal_default_instance();
1538   }
internal_default_instance()1539   static inline const KeyValueSetRequest* internal_default_instance() {
1540     return reinterpret_cast<const KeyValueSetRequest*>(
1541                &_KeyValueSetRequest_default_instance_);
1542   }
1543   static constexpr int kIndexInFileMessages =
1544     9;
1545 
swap(KeyValueSetRequest & a,KeyValueSetRequest & b)1546   friend void swap(KeyValueSetRequest& a, KeyValueSetRequest& b) {
1547     a.Swap(&b);
1548   }
Swap(KeyValueSetRequest * other)1549   inline void Swap(KeyValueSetRequest* other) {
1550     if (other == this) return;
1551   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1552     if (GetOwningArena() != nullptr &&
1553         GetOwningArena() == other->GetOwningArena()) {
1554    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
1555     if (GetOwningArena() == other->GetOwningArena()) {
1556   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
1557       InternalSwap(other);
1558     } else {
1559       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1560     }
1561   }
1562   void UnsafeArenaSwap(KeyValueSetRequest* other) {
1563     if (other == this) return;
1564     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1565     InternalSwap(other);
1566   }
1567 
1568   // implements Message ----------------------------------------------
1569 
1570   KeyValueSetRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1571     return CreateMaybeMessage<KeyValueSetRequest>(arena);
1572   }
1573   KeyValueSetRequest* New() const {
1574     return New(nullptr);
1575   }
1576   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
1577   void CopyFrom(const KeyValueSetRequest& from);
1578   void MergeFrom(const KeyValueSetRequest& from);
1579   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1580   bool IsInitialized() const final;
1581 
1582   size_t ByteSizeLong() const final;
1583   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1584   ::uint8_t* _InternalSerialize(
1585       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1586   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1587 
1588   private:
1589   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1590   void SharedDtor();
1591   void SetCachedSize(int size) const;
1592   void InternalSwap(KeyValueSetRequest* other);
1593 
1594   private:
1595   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1596   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1597     return "xla.KeyValueSetRequest";
1598   }
1599   protected:
1600   explicit KeyValueSetRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1601                        bool is_message_owned = false);
1602   public:
1603 
1604   std::string GetTypeName() const final;
1605 
1606   // nested types ----------------------------------------------------
1607 
1608   // accessors -------------------------------------------------------
1609 
1610   enum : int {
1611     kKeyFieldNumber = 2,
1612     kValueFieldNumber = 3,
1613     kSessionIdFieldNumber = 1,
1614   };
1615   // bytes key = 2;
1616   void clear_key();
1617   const std::string& key() const;
1618   template <typename ArgT0 = const std::string&, typename... ArgT>
1619   void set_key(ArgT0&& arg0, ArgT... args);
1620   std::string* mutable_key();
1621   PROTOBUF_NODISCARD std::string* release_key();
1622   void set_allocated_key(std::string* key);
1623   private:
1624   const std::string& _internal_key() const;
1625   inline PROTOBUF_ALWAYS_INLINE void _internal_set_key(const std::string& value);
1626   std::string* _internal_mutable_key();
1627   public:
1628 
1629   // bytes value = 3;
1630   void clear_value();
1631   const std::string& value() const;
1632   template <typename ArgT0 = const std::string&, typename... ArgT>
1633   void set_value(ArgT0&& arg0, ArgT... args);
1634   std::string* mutable_value();
1635   PROTOBUF_NODISCARD std::string* release_value();
1636   void set_allocated_value(std::string* value);
1637   private:
1638   const std::string& _internal_value() const;
1639   inline PROTOBUF_ALWAYS_INLINE void _internal_set_value(const std::string& value);
1640   std::string* _internal_mutable_value();
1641   public:
1642 
1643   // uint64 session_id = 1;
1644   void clear_session_id();
1645   ::uint64_t session_id() const;
1646   void set_session_id(::uint64_t value);
1647   private:
1648   ::uint64_t _internal_session_id() const;
1649   void _internal_set_session_id(::uint64_t value);
1650   public:
1651 
1652   // @@protoc_insertion_point(class_scope:xla.KeyValueSetRequest)
1653  private:
1654   class _Internal;
1655 
1656   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1657   typedef void InternalArenaConstructable_;
1658   typedef void DestructorSkippable_;
1659   struct Impl_ {
1660     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_;
1661     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
1662     ::uint64_t session_id_;
1663     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1664   };
1665   union { Impl_ _impl_; };
1666   friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto;
1667 };
1668 // -------------------------------------------------------------------
1669 
1670 class KeyValueSetResponse final :
1671     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:xla.KeyValueSetResponse) */ {
1672  public:
KeyValueSetResponse()1673   inline KeyValueSetResponse() : KeyValueSetResponse(nullptr) {}
1674   ~KeyValueSetResponse() override;
1675   explicit PROTOBUF_CONSTEXPR KeyValueSetResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1676 
1677   KeyValueSetResponse(const KeyValueSetResponse& from);
KeyValueSetResponse(KeyValueSetResponse && from)1678   KeyValueSetResponse(KeyValueSetResponse&& from) noexcept
1679     : KeyValueSetResponse() {
1680     *this = ::std::move(from);
1681   }
1682 
1683   inline KeyValueSetResponse& operator=(const KeyValueSetResponse& from) {
1684     if (this == &from) return *this;
1685     CopyFrom(from);
1686     return *this;
1687   }
1688   inline KeyValueSetResponse& operator=(KeyValueSetResponse&& from) noexcept {
1689     if (this == &from) return *this;
1690     if (GetOwningArena() == from.GetOwningArena()
1691   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1692         && GetOwningArena() != nullptr
1693   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
1694     ) {
1695       InternalSwap(&from);
1696     } else {
1697       CopyFrom(from);
1698     }
1699     return *this;
1700   }
1701 
default_instance()1702   static const KeyValueSetResponse& default_instance() {
1703     return *internal_default_instance();
1704   }
internal_default_instance()1705   static inline const KeyValueSetResponse* internal_default_instance() {
1706     return reinterpret_cast<const KeyValueSetResponse*>(
1707                &_KeyValueSetResponse_default_instance_);
1708   }
1709   static constexpr int kIndexInFileMessages =
1710     10;
1711 
swap(KeyValueSetResponse & a,KeyValueSetResponse & b)1712   friend void swap(KeyValueSetResponse& a, KeyValueSetResponse& b) {
1713     a.Swap(&b);
1714   }
Swap(KeyValueSetResponse * other)1715   inline void Swap(KeyValueSetResponse* other) {
1716     if (other == this) return;
1717   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1718     if (GetOwningArena() != nullptr &&
1719         GetOwningArena() == other->GetOwningArena()) {
1720    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
1721     if (GetOwningArena() == other->GetOwningArena()) {
1722   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
1723       InternalSwap(other);
1724     } else {
1725       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1726     }
1727   }
1728   void UnsafeArenaSwap(KeyValueSetResponse* other) {
1729     if (other == this) return;
1730     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1731     InternalSwap(other);
1732   }
1733 
1734   // implements Message ----------------------------------------------
1735 
1736   KeyValueSetResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1737     return CreateMaybeMessage<KeyValueSetResponse>(arena);
1738   }
1739   KeyValueSetResponse* New() const {
1740     return New(nullptr);
1741   }
1742   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
1743   void CopyFrom(const KeyValueSetResponse& from);
1744   void MergeFrom(const KeyValueSetResponse& from);
1745   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1746   bool IsInitialized() const final;
1747 
1748   size_t ByteSizeLong() const final;
1749   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1750   ::uint8_t* _InternalSerialize(
1751       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1752   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1753 
1754   private:
1755   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1756   void SharedDtor();
1757   void SetCachedSize(int size) const;
1758   void InternalSwap(KeyValueSetResponse* other);
1759 
1760   private:
1761   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1762   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1763     return "xla.KeyValueSetResponse";
1764   }
1765   protected:
1766   explicit KeyValueSetResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1767                        bool is_message_owned = false);
1768   public:
1769 
1770   std::string GetTypeName() const final;
1771 
1772   // nested types ----------------------------------------------------
1773 
1774   // accessors -------------------------------------------------------
1775 
1776   // @@protoc_insertion_point(class_scope:xla.KeyValueSetResponse)
1777  private:
1778   class _Internal;
1779 
1780   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1781   typedef void InternalArenaConstructable_;
1782   typedef void DestructorSkippable_;
1783   struct Impl_ {
1784     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1785   };
1786   union { Impl_ _impl_; };
1787   friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto;
1788 };
1789 // -------------------------------------------------------------------
1790 
1791 class WaitAtBarrierRequest final :
1792     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:xla.WaitAtBarrierRequest) */ {
1793  public:
WaitAtBarrierRequest()1794   inline WaitAtBarrierRequest() : WaitAtBarrierRequest(nullptr) {}
1795   ~WaitAtBarrierRequest() override;
1796   explicit PROTOBUF_CONSTEXPR WaitAtBarrierRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1797 
1798   WaitAtBarrierRequest(const WaitAtBarrierRequest& from);
WaitAtBarrierRequest(WaitAtBarrierRequest && from)1799   WaitAtBarrierRequest(WaitAtBarrierRequest&& from) noexcept
1800     : WaitAtBarrierRequest() {
1801     *this = ::std::move(from);
1802   }
1803 
1804   inline WaitAtBarrierRequest& operator=(const WaitAtBarrierRequest& from) {
1805     if (this == &from) return *this;
1806     CopyFrom(from);
1807     return *this;
1808   }
1809   inline WaitAtBarrierRequest& operator=(WaitAtBarrierRequest&& from) noexcept {
1810     if (this == &from) return *this;
1811     if (GetOwningArena() == from.GetOwningArena()
1812   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1813         && GetOwningArena() != nullptr
1814   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
1815     ) {
1816       InternalSwap(&from);
1817     } else {
1818       CopyFrom(from);
1819     }
1820     return *this;
1821   }
1822 
default_instance()1823   static const WaitAtBarrierRequest& default_instance() {
1824     return *internal_default_instance();
1825   }
internal_default_instance()1826   static inline const WaitAtBarrierRequest* internal_default_instance() {
1827     return reinterpret_cast<const WaitAtBarrierRequest*>(
1828                &_WaitAtBarrierRequest_default_instance_);
1829   }
1830   static constexpr int kIndexInFileMessages =
1831     11;
1832 
swap(WaitAtBarrierRequest & a,WaitAtBarrierRequest & b)1833   friend void swap(WaitAtBarrierRequest& a, WaitAtBarrierRequest& b) {
1834     a.Swap(&b);
1835   }
Swap(WaitAtBarrierRequest * other)1836   inline void Swap(WaitAtBarrierRequest* other) {
1837     if (other == this) return;
1838   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1839     if (GetOwningArena() != nullptr &&
1840         GetOwningArena() == other->GetOwningArena()) {
1841    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
1842     if (GetOwningArena() == other->GetOwningArena()) {
1843   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
1844       InternalSwap(other);
1845     } else {
1846       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1847     }
1848   }
1849   void UnsafeArenaSwap(WaitAtBarrierRequest* other) {
1850     if (other == this) return;
1851     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1852     InternalSwap(other);
1853   }
1854 
1855   // implements Message ----------------------------------------------
1856 
1857   WaitAtBarrierRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1858     return CreateMaybeMessage<WaitAtBarrierRequest>(arena);
1859   }
1860   WaitAtBarrierRequest* New() const {
1861     return New(nullptr);
1862   }
1863   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
1864   void CopyFrom(const WaitAtBarrierRequest& from);
1865   void MergeFrom(const WaitAtBarrierRequest& from);
1866   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1867   bool IsInitialized() const final;
1868 
1869   size_t ByteSizeLong() const final;
1870   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1871   ::uint8_t* _InternalSerialize(
1872       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1873   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1874 
1875   private:
1876   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1877   void SharedDtor();
1878   void SetCachedSize(int size) const;
1879   void InternalSwap(WaitAtBarrierRequest* other);
1880 
1881   private:
1882   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1883   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1884     return "xla.WaitAtBarrierRequest";
1885   }
1886   protected:
1887   explicit WaitAtBarrierRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1888                        bool is_message_owned = false);
1889   public:
1890 
1891   std::string GetTypeName() const final;
1892 
1893   // nested types ----------------------------------------------------
1894 
1895   // accessors -------------------------------------------------------
1896 
1897   enum : int {
1898     kBarrierIdFieldNumber = 2,
1899     kSessionIdFieldNumber = 1,
1900     kNodeIdFieldNumber = 3,
1901     kTimeoutMillisecondsFieldNumber = 4,
1902   };
1903   // bytes barrier_id = 2;
1904   void clear_barrier_id();
1905   const std::string& barrier_id() const;
1906   template <typename ArgT0 = const std::string&, typename... ArgT>
1907   void set_barrier_id(ArgT0&& arg0, ArgT... args);
1908   std::string* mutable_barrier_id();
1909   PROTOBUF_NODISCARD std::string* release_barrier_id();
1910   void set_allocated_barrier_id(std::string* barrier_id);
1911   private:
1912   const std::string& _internal_barrier_id() const;
1913   inline PROTOBUF_ALWAYS_INLINE void _internal_set_barrier_id(const std::string& value);
1914   std::string* _internal_mutable_barrier_id();
1915   public:
1916 
1917   // uint64 session_id = 1;
1918   void clear_session_id();
1919   ::uint64_t session_id() const;
1920   void set_session_id(::uint64_t value);
1921   private:
1922   ::uint64_t _internal_session_id() const;
1923   void _internal_set_session_id(::uint64_t value);
1924   public:
1925 
1926   // int32 node_id = 3;
1927   void clear_node_id();
1928   ::int32_t node_id() const;
1929   void set_node_id(::int32_t value);
1930   private:
1931   ::int32_t _internal_node_id() const;
1932   void _internal_set_node_id(::int32_t value);
1933   public:
1934 
1935   // int32 timeout_milliseconds = 4;
1936   void clear_timeout_milliseconds();
1937   ::int32_t timeout_milliseconds() const;
1938   void set_timeout_milliseconds(::int32_t value);
1939   private:
1940   ::int32_t _internal_timeout_milliseconds() const;
1941   void _internal_set_timeout_milliseconds(::int32_t value);
1942   public:
1943 
1944   // @@protoc_insertion_point(class_scope:xla.WaitAtBarrierRequest)
1945  private:
1946   class _Internal;
1947 
1948   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1949   typedef void InternalArenaConstructable_;
1950   typedef void DestructorSkippable_;
1951   struct Impl_ {
1952     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr barrier_id_;
1953     ::uint64_t session_id_;
1954     ::int32_t node_id_;
1955     ::int32_t timeout_milliseconds_;
1956     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1957   };
1958   union { Impl_ _impl_; };
1959   friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto;
1960 };
1961 // -------------------------------------------------------------------
1962 
1963 class WaitAtBarrierResponse final :
1964     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:xla.WaitAtBarrierResponse) */ {
1965  public:
WaitAtBarrierResponse()1966   inline WaitAtBarrierResponse() : WaitAtBarrierResponse(nullptr) {}
1967   ~WaitAtBarrierResponse() override;
1968   explicit PROTOBUF_CONSTEXPR WaitAtBarrierResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1969 
1970   WaitAtBarrierResponse(const WaitAtBarrierResponse& from);
WaitAtBarrierResponse(WaitAtBarrierResponse && from)1971   WaitAtBarrierResponse(WaitAtBarrierResponse&& from) noexcept
1972     : WaitAtBarrierResponse() {
1973     *this = ::std::move(from);
1974   }
1975 
1976   inline WaitAtBarrierResponse& operator=(const WaitAtBarrierResponse& from) {
1977     if (this == &from) return *this;
1978     CopyFrom(from);
1979     return *this;
1980   }
1981   inline WaitAtBarrierResponse& operator=(WaitAtBarrierResponse&& from) noexcept {
1982     if (this == &from) return *this;
1983     if (GetOwningArena() == from.GetOwningArena()
1984   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1985         && GetOwningArena() != nullptr
1986   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
1987     ) {
1988       InternalSwap(&from);
1989     } else {
1990       CopyFrom(from);
1991     }
1992     return *this;
1993   }
1994 
default_instance()1995   static const WaitAtBarrierResponse& default_instance() {
1996     return *internal_default_instance();
1997   }
internal_default_instance()1998   static inline const WaitAtBarrierResponse* internal_default_instance() {
1999     return reinterpret_cast<const WaitAtBarrierResponse*>(
2000                &_WaitAtBarrierResponse_default_instance_);
2001   }
2002   static constexpr int kIndexInFileMessages =
2003     12;
2004 
swap(WaitAtBarrierResponse & a,WaitAtBarrierResponse & b)2005   friend void swap(WaitAtBarrierResponse& a, WaitAtBarrierResponse& b) {
2006     a.Swap(&b);
2007   }
Swap(WaitAtBarrierResponse * other)2008   inline void Swap(WaitAtBarrierResponse* other) {
2009     if (other == this) return;
2010   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2011     if (GetOwningArena() != nullptr &&
2012         GetOwningArena() == other->GetOwningArena()) {
2013    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
2014     if (GetOwningArena() == other->GetOwningArena()) {
2015   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
2016       InternalSwap(other);
2017     } else {
2018       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2019     }
2020   }
2021   void UnsafeArenaSwap(WaitAtBarrierResponse* other) {
2022     if (other == this) return;
2023     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
2024     InternalSwap(other);
2025   }
2026 
2027   // implements Message ----------------------------------------------
2028 
2029   WaitAtBarrierResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2030     return CreateMaybeMessage<WaitAtBarrierResponse>(arena);
2031   }
2032   WaitAtBarrierResponse* New() const {
2033     return New(nullptr);
2034   }
2035   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
2036   void CopyFrom(const WaitAtBarrierResponse& from);
2037   void MergeFrom(const WaitAtBarrierResponse& from);
2038   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2039   bool IsInitialized() const final;
2040 
2041   size_t ByteSizeLong() const final;
2042   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2043   ::uint8_t* _InternalSerialize(
2044       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2045   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
2046 
2047   private:
2048   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
2049   void SharedDtor();
2050   void SetCachedSize(int size) const;
2051   void InternalSwap(WaitAtBarrierResponse* other);
2052 
2053   private:
2054   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2055   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2056     return "xla.WaitAtBarrierResponse";
2057   }
2058   protected:
2059   explicit WaitAtBarrierResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2060                        bool is_message_owned = false);
2061   public:
2062 
2063   std::string GetTypeName() const final;
2064 
2065   // nested types ----------------------------------------------------
2066 
2067   // accessors -------------------------------------------------------
2068 
2069   // @@protoc_insertion_point(class_scope:xla.WaitAtBarrierResponse)
2070  private:
2071   class _Internal;
2072 
2073   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2074   typedef void InternalArenaConstructable_;
2075   typedef void DestructorSkippable_;
2076   struct Impl_ {
2077     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2078   };
2079   union { Impl_ _impl_; };
2080   friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto;
2081 };
2082 // -------------------------------------------------------------------
2083 
2084 class HeartbeatRequest final :
2085     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:xla.HeartbeatRequest) */ {
2086  public:
HeartbeatRequest()2087   inline HeartbeatRequest() : HeartbeatRequest(nullptr) {}
2088   ~HeartbeatRequest() override;
2089   explicit PROTOBUF_CONSTEXPR HeartbeatRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2090 
2091   HeartbeatRequest(const HeartbeatRequest& from);
HeartbeatRequest(HeartbeatRequest && from)2092   HeartbeatRequest(HeartbeatRequest&& from) noexcept
2093     : HeartbeatRequest() {
2094     *this = ::std::move(from);
2095   }
2096 
2097   inline HeartbeatRequest& operator=(const HeartbeatRequest& from) {
2098     if (this == &from) return *this;
2099     CopyFrom(from);
2100     return *this;
2101   }
2102   inline HeartbeatRequest& operator=(HeartbeatRequest&& from) noexcept {
2103     if (this == &from) return *this;
2104     if (GetOwningArena() == from.GetOwningArena()
2105   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2106         && GetOwningArena() != nullptr
2107   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
2108     ) {
2109       InternalSwap(&from);
2110     } else {
2111       CopyFrom(from);
2112     }
2113     return *this;
2114   }
2115 
default_instance()2116   static const HeartbeatRequest& default_instance() {
2117     return *internal_default_instance();
2118   }
internal_default_instance()2119   static inline const HeartbeatRequest* internal_default_instance() {
2120     return reinterpret_cast<const HeartbeatRequest*>(
2121                &_HeartbeatRequest_default_instance_);
2122   }
2123   static constexpr int kIndexInFileMessages =
2124     13;
2125 
swap(HeartbeatRequest & a,HeartbeatRequest & b)2126   friend void swap(HeartbeatRequest& a, HeartbeatRequest& b) {
2127     a.Swap(&b);
2128   }
Swap(HeartbeatRequest * other)2129   inline void Swap(HeartbeatRequest* other) {
2130     if (other == this) return;
2131   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2132     if (GetOwningArena() != nullptr &&
2133         GetOwningArena() == other->GetOwningArena()) {
2134    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
2135     if (GetOwningArena() == other->GetOwningArena()) {
2136   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
2137       InternalSwap(other);
2138     } else {
2139       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2140     }
2141   }
2142   void UnsafeArenaSwap(HeartbeatRequest* other) {
2143     if (other == this) return;
2144     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
2145     InternalSwap(other);
2146   }
2147 
2148   // implements Message ----------------------------------------------
2149 
2150   HeartbeatRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2151     return CreateMaybeMessage<HeartbeatRequest>(arena);
2152   }
2153   HeartbeatRequest* New() const {
2154     return New(nullptr);
2155   }
2156   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
2157   void CopyFrom(const HeartbeatRequest& from);
2158   void MergeFrom(const HeartbeatRequest& from);
2159   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2160   bool IsInitialized() const final;
2161 
2162   size_t ByteSizeLong() const final;
2163   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2164   ::uint8_t* _InternalSerialize(
2165       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2166   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
2167 
2168   private:
2169   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
2170   void SharedDtor();
2171   void SetCachedSize(int size) const;
2172   void InternalSwap(HeartbeatRequest* other);
2173 
2174   private:
2175   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2176   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2177     return "xla.HeartbeatRequest";
2178   }
2179   protected:
2180   explicit HeartbeatRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2181                        bool is_message_owned = false);
2182   public:
2183 
2184   std::string GetTypeName() const final;
2185 
2186   // nested types ----------------------------------------------------
2187 
2188   // accessors -------------------------------------------------------
2189 
2190   enum : int {
2191     kSessionIdFieldNumber = 1,
2192     kNodeIdFieldNumber = 2,
2193   };
2194   // uint64 session_id = 1;
2195   void clear_session_id();
2196   ::uint64_t session_id() const;
2197   void set_session_id(::uint64_t value);
2198   private:
2199   ::uint64_t _internal_session_id() const;
2200   void _internal_set_session_id(::uint64_t value);
2201   public:
2202 
2203   // int32 node_id = 2;
2204   void clear_node_id();
2205   ::int32_t node_id() const;
2206   void set_node_id(::int32_t value);
2207   private:
2208   ::int32_t _internal_node_id() const;
2209   void _internal_set_node_id(::int32_t value);
2210   public:
2211 
2212   // @@protoc_insertion_point(class_scope:xla.HeartbeatRequest)
2213  private:
2214   class _Internal;
2215 
2216   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2217   typedef void InternalArenaConstructable_;
2218   typedef void DestructorSkippable_;
2219   struct Impl_ {
2220     ::uint64_t session_id_;
2221     ::int32_t node_id_;
2222     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2223   };
2224   union { Impl_ _impl_; };
2225   friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto;
2226 };
2227 // -------------------------------------------------------------------
2228 
2229 class HeartbeatResponse final :
2230     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:xla.HeartbeatResponse) */ {
2231  public:
HeartbeatResponse()2232   inline HeartbeatResponse() : HeartbeatResponse(nullptr) {}
2233   ~HeartbeatResponse() override;
2234   explicit PROTOBUF_CONSTEXPR HeartbeatResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2235 
2236   HeartbeatResponse(const HeartbeatResponse& from);
HeartbeatResponse(HeartbeatResponse && from)2237   HeartbeatResponse(HeartbeatResponse&& from) noexcept
2238     : HeartbeatResponse() {
2239     *this = ::std::move(from);
2240   }
2241 
2242   inline HeartbeatResponse& operator=(const HeartbeatResponse& from) {
2243     if (this == &from) return *this;
2244     CopyFrom(from);
2245     return *this;
2246   }
2247   inline HeartbeatResponse& operator=(HeartbeatResponse&& from) noexcept {
2248     if (this == &from) return *this;
2249     if (GetOwningArena() == from.GetOwningArena()
2250   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2251         && GetOwningArena() != nullptr
2252   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
2253     ) {
2254       InternalSwap(&from);
2255     } else {
2256       CopyFrom(from);
2257     }
2258     return *this;
2259   }
2260 
default_instance()2261   static const HeartbeatResponse& default_instance() {
2262     return *internal_default_instance();
2263   }
internal_default_instance()2264   static inline const HeartbeatResponse* internal_default_instance() {
2265     return reinterpret_cast<const HeartbeatResponse*>(
2266                &_HeartbeatResponse_default_instance_);
2267   }
2268   static constexpr int kIndexInFileMessages =
2269     14;
2270 
swap(HeartbeatResponse & a,HeartbeatResponse & b)2271   friend void swap(HeartbeatResponse& a, HeartbeatResponse& b) {
2272     a.Swap(&b);
2273   }
Swap(HeartbeatResponse * other)2274   inline void Swap(HeartbeatResponse* other) {
2275     if (other == this) return;
2276   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2277     if (GetOwningArena() != nullptr &&
2278         GetOwningArena() == other->GetOwningArena()) {
2279    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
2280     if (GetOwningArena() == other->GetOwningArena()) {
2281   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
2282       InternalSwap(other);
2283     } else {
2284       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2285     }
2286   }
2287   void UnsafeArenaSwap(HeartbeatResponse* other) {
2288     if (other == this) return;
2289     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
2290     InternalSwap(other);
2291   }
2292 
2293   // implements Message ----------------------------------------------
2294 
2295   HeartbeatResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2296     return CreateMaybeMessage<HeartbeatResponse>(arena);
2297   }
2298   HeartbeatResponse* New() const {
2299     return New(nullptr);
2300   }
2301   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
2302   void CopyFrom(const HeartbeatResponse& from);
2303   void MergeFrom(const HeartbeatResponse& from);
2304   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2305   bool IsInitialized() const final;
2306 
2307   size_t ByteSizeLong() const final;
2308   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2309   ::uint8_t* _InternalSerialize(
2310       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2311   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
2312 
2313   private:
2314   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
2315   void SharedDtor();
2316   void SetCachedSize(int size) const;
2317   void InternalSwap(HeartbeatResponse* other);
2318 
2319   private:
2320   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2321   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2322     return "xla.HeartbeatResponse";
2323   }
2324   protected:
2325   explicit HeartbeatResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2326                        bool is_message_owned = false);
2327   public:
2328 
2329   std::string GetTypeName() const final;
2330 
2331   // nested types ----------------------------------------------------
2332 
2333   // accessors -------------------------------------------------------
2334 
2335   // @@protoc_insertion_point(class_scope:xla.HeartbeatResponse)
2336  private:
2337   class _Internal;
2338 
2339   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2340   typedef void InternalArenaConstructable_;
2341   typedef void DestructorSkippable_;
2342   struct Impl_ {
2343     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2344   };
2345   union { Impl_ _impl_; };
2346   friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto;
2347 };
2348 // -------------------------------------------------------------------
2349 
2350 class ShutdownRequest final :
2351     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:xla.ShutdownRequest) */ {
2352  public:
ShutdownRequest()2353   inline ShutdownRequest() : ShutdownRequest(nullptr) {}
2354   ~ShutdownRequest() override;
2355   explicit PROTOBUF_CONSTEXPR ShutdownRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2356 
2357   ShutdownRequest(const ShutdownRequest& from);
ShutdownRequest(ShutdownRequest && from)2358   ShutdownRequest(ShutdownRequest&& from) noexcept
2359     : ShutdownRequest() {
2360     *this = ::std::move(from);
2361   }
2362 
2363   inline ShutdownRequest& operator=(const ShutdownRequest& from) {
2364     if (this == &from) return *this;
2365     CopyFrom(from);
2366     return *this;
2367   }
2368   inline ShutdownRequest& operator=(ShutdownRequest&& from) noexcept {
2369     if (this == &from) return *this;
2370     if (GetOwningArena() == from.GetOwningArena()
2371   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2372         && GetOwningArena() != nullptr
2373   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
2374     ) {
2375       InternalSwap(&from);
2376     } else {
2377       CopyFrom(from);
2378     }
2379     return *this;
2380   }
2381 
default_instance()2382   static const ShutdownRequest& default_instance() {
2383     return *internal_default_instance();
2384   }
internal_default_instance()2385   static inline const ShutdownRequest* internal_default_instance() {
2386     return reinterpret_cast<const ShutdownRequest*>(
2387                &_ShutdownRequest_default_instance_);
2388   }
2389   static constexpr int kIndexInFileMessages =
2390     15;
2391 
swap(ShutdownRequest & a,ShutdownRequest & b)2392   friend void swap(ShutdownRequest& a, ShutdownRequest& b) {
2393     a.Swap(&b);
2394   }
Swap(ShutdownRequest * other)2395   inline void Swap(ShutdownRequest* other) {
2396     if (other == this) return;
2397   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2398     if (GetOwningArena() != nullptr &&
2399         GetOwningArena() == other->GetOwningArena()) {
2400    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
2401     if (GetOwningArena() == other->GetOwningArena()) {
2402   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
2403       InternalSwap(other);
2404     } else {
2405       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2406     }
2407   }
2408   void UnsafeArenaSwap(ShutdownRequest* other) {
2409     if (other == this) return;
2410     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
2411     InternalSwap(other);
2412   }
2413 
2414   // implements Message ----------------------------------------------
2415 
2416   ShutdownRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2417     return CreateMaybeMessage<ShutdownRequest>(arena);
2418   }
2419   ShutdownRequest* New() const {
2420     return New(nullptr);
2421   }
2422   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
2423   void CopyFrom(const ShutdownRequest& from);
2424   void MergeFrom(const ShutdownRequest& from);
2425   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2426   bool IsInitialized() const final;
2427 
2428   size_t ByteSizeLong() const final;
2429   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2430   ::uint8_t* _InternalSerialize(
2431       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2432   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
2433 
2434   private:
2435   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
2436   void SharedDtor();
2437   void SetCachedSize(int size) const;
2438   void InternalSwap(ShutdownRequest* other);
2439 
2440   private:
2441   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2442   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2443     return "xla.ShutdownRequest";
2444   }
2445   protected:
2446   explicit ShutdownRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2447                        bool is_message_owned = false);
2448   public:
2449 
2450   std::string GetTypeName() const final;
2451 
2452   // nested types ----------------------------------------------------
2453 
2454   // accessors -------------------------------------------------------
2455 
2456   enum : int {
2457     kSessionIdFieldNumber = 1,
2458     kNodeIdFieldNumber = 2,
2459   };
2460   // uint64 session_id = 1;
2461   void clear_session_id();
2462   ::uint64_t session_id() const;
2463   void set_session_id(::uint64_t value);
2464   private:
2465   ::uint64_t _internal_session_id() const;
2466   void _internal_set_session_id(::uint64_t value);
2467   public:
2468 
2469   // int32 node_id = 2;
2470   void clear_node_id();
2471   ::int32_t node_id() const;
2472   void set_node_id(::int32_t value);
2473   private:
2474   ::int32_t _internal_node_id() const;
2475   void _internal_set_node_id(::int32_t value);
2476   public:
2477 
2478   // @@protoc_insertion_point(class_scope:xla.ShutdownRequest)
2479  private:
2480   class _Internal;
2481 
2482   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2483   typedef void InternalArenaConstructable_;
2484   typedef void DestructorSkippable_;
2485   struct Impl_ {
2486     ::uint64_t session_id_;
2487     ::int32_t node_id_;
2488     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2489   };
2490   union { Impl_ _impl_; };
2491   friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto;
2492 };
2493 // -------------------------------------------------------------------
2494 
2495 class ShutdownResponse final :
2496     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:xla.ShutdownResponse) */ {
2497  public:
ShutdownResponse()2498   inline ShutdownResponse() : ShutdownResponse(nullptr) {}
2499   ~ShutdownResponse() override;
2500   explicit PROTOBUF_CONSTEXPR ShutdownResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2501 
2502   ShutdownResponse(const ShutdownResponse& from);
ShutdownResponse(ShutdownResponse && from)2503   ShutdownResponse(ShutdownResponse&& from) noexcept
2504     : ShutdownResponse() {
2505     *this = ::std::move(from);
2506   }
2507 
2508   inline ShutdownResponse& operator=(const ShutdownResponse& from) {
2509     if (this == &from) return *this;
2510     CopyFrom(from);
2511     return *this;
2512   }
2513   inline ShutdownResponse& operator=(ShutdownResponse&& from) noexcept {
2514     if (this == &from) return *this;
2515     if (GetOwningArena() == from.GetOwningArena()
2516   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2517         && GetOwningArena() != nullptr
2518   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
2519     ) {
2520       InternalSwap(&from);
2521     } else {
2522       CopyFrom(from);
2523     }
2524     return *this;
2525   }
2526 
default_instance()2527   static const ShutdownResponse& default_instance() {
2528     return *internal_default_instance();
2529   }
internal_default_instance()2530   static inline const ShutdownResponse* internal_default_instance() {
2531     return reinterpret_cast<const ShutdownResponse*>(
2532                &_ShutdownResponse_default_instance_);
2533   }
2534   static constexpr int kIndexInFileMessages =
2535     16;
2536 
swap(ShutdownResponse & a,ShutdownResponse & b)2537   friend void swap(ShutdownResponse& a, ShutdownResponse& b) {
2538     a.Swap(&b);
2539   }
Swap(ShutdownResponse * other)2540   inline void Swap(ShutdownResponse* other) {
2541     if (other == this) return;
2542   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2543     if (GetOwningArena() != nullptr &&
2544         GetOwningArena() == other->GetOwningArena()) {
2545    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
2546     if (GetOwningArena() == other->GetOwningArena()) {
2547   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
2548       InternalSwap(other);
2549     } else {
2550       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2551     }
2552   }
2553   void UnsafeArenaSwap(ShutdownResponse* other) {
2554     if (other == this) return;
2555     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
2556     InternalSwap(other);
2557   }
2558 
2559   // implements Message ----------------------------------------------
2560 
2561   ShutdownResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2562     return CreateMaybeMessage<ShutdownResponse>(arena);
2563   }
2564   ShutdownResponse* New() const {
2565     return New(nullptr);
2566   }
2567   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
2568   void CopyFrom(const ShutdownResponse& from);
2569   void MergeFrom(const ShutdownResponse& from);
2570   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2571   bool IsInitialized() const final;
2572 
2573   size_t ByteSizeLong() const final;
2574   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2575   ::uint8_t* _InternalSerialize(
2576       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2577   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
2578 
2579   private:
2580   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
2581   void SharedDtor();
2582   void SetCachedSize(int size) const;
2583   void InternalSwap(ShutdownResponse* other);
2584 
2585   private:
2586   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2587   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2588     return "xla.ShutdownResponse";
2589   }
2590   protected:
2591   explicit ShutdownResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2592                        bool is_message_owned = false);
2593   public:
2594 
2595   std::string GetTypeName() const final;
2596 
2597   // nested types ----------------------------------------------------
2598 
2599   // accessors -------------------------------------------------------
2600 
2601   // @@protoc_insertion_point(class_scope:xla.ShutdownResponse)
2602  private:
2603   class _Internal;
2604 
2605   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2606   typedef void InternalArenaConstructable_;
2607   typedef void DestructorSkippable_;
2608   struct Impl_ {
2609     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2610   };
2611   union { Impl_ _impl_; };
2612   friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto;
2613 };
2614 // ===================================================================
2615 
2616 
2617 // ===================================================================
2618 
2619 #ifdef __GNUC__
2620   #pragma GCC diagnostic push
2621   #pragma GCC diagnostic ignored "-Wstrict-aliasing"
2622 #endif  // __GNUC__
2623 // DeviceProto
2624 
2625 // int32 local_device_ordinal = 1;
clear_local_device_ordinal()2626 inline void DeviceProto::clear_local_device_ordinal() {
2627   _impl_.local_device_ordinal_ = 0;
2628 }
_internal_local_device_ordinal()2629 inline ::int32_t DeviceProto::_internal_local_device_ordinal() const {
2630   return _impl_.local_device_ordinal_;
2631 }
local_device_ordinal()2632 inline ::int32_t DeviceProto::local_device_ordinal() const {
2633   // @@protoc_insertion_point(field_get:xla.DeviceProto.local_device_ordinal)
2634   return _internal_local_device_ordinal();
2635 }
_internal_set_local_device_ordinal(::int32_t value)2636 inline void DeviceProto::_internal_set_local_device_ordinal(::int32_t value) {
2637 
2638   _impl_.local_device_ordinal_ = value;
2639 }
set_local_device_ordinal(::int32_t value)2640 inline void DeviceProto::set_local_device_ordinal(::int32_t value) {
2641   _internal_set_local_device_ordinal(value);
2642   // @@protoc_insertion_point(field_set:xla.DeviceProto.local_device_ordinal)
2643 }
2644 
2645 // string name = 2;
clear_name()2646 inline void DeviceProto::clear_name() {
2647   _impl_.name_.ClearToEmpty();
2648 }
name()2649 inline const std::string& DeviceProto::name() const {
2650   // @@protoc_insertion_point(field_get:xla.DeviceProto.name)
2651   return _internal_name();
2652 }
2653 template <typename ArgT0, typename... ArgT>
2654 inline PROTOBUF_ALWAYS_INLINE
set_name(ArgT0 && arg0,ArgT...args)2655 void DeviceProto::set_name(ArgT0&& arg0, ArgT... args) {
2656 
2657  _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
2658   // @@protoc_insertion_point(field_set:xla.DeviceProto.name)
2659 }
mutable_name()2660 inline std::string* DeviceProto::mutable_name() {
2661   std::string* _s = _internal_mutable_name();
2662   // @@protoc_insertion_point(field_mutable:xla.DeviceProto.name)
2663   return _s;
2664 }
_internal_name()2665 inline const std::string& DeviceProto::_internal_name() const {
2666   return _impl_.name_.Get();
2667 }
_internal_set_name(const std::string & value)2668 inline void DeviceProto::_internal_set_name(const std::string& value) {
2669 
2670   _impl_.name_.Set(value, GetArenaForAllocation());
2671 }
_internal_mutable_name()2672 inline std::string* DeviceProto::_internal_mutable_name() {
2673 
2674   return _impl_.name_.Mutable(GetArenaForAllocation());
2675 }
release_name()2676 inline std::string* DeviceProto::release_name() {
2677   // @@protoc_insertion_point(field_release:xla.DeviceProto.name)
2678   return _impl_.name_.Release();
2679 }
set_allocated_name(std::string * name)2680 inline void DeviceProto::set_allocated_name(std::string* name) {
2681   _impl_.name_.SetAllocated(name, GetArenaForAllocation());
2682 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2683   if (_impl_.name_.IsDefault()) {
2684     _impl_.name_.Set("", GetArenaForAllocation());
2685   }
2686 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2687   // @@protoc_insertion_point(field_set_allocated:xla.DeviceProto.name)
2688 }
2689 
2690 // string vendor = 3;
clear_vendor()2691 inline void DeviceProto::clear_vendor() {
2692   _impl_.vendor_.ClearToEmpty();
2693 }
vendor()2694 inline const std::string& DeviceProto::vendor() const {
2695   // @@protoc_insertion_point(field_get:xla.DeviceProto.vendor)
2696   return _internal_vendor();
2697 }
2698 template <typename ArgT0, typename... ArgT>
2699 inline PROTOBUF_ALWAYS_INLINE
set_vendor(ArgT0 && arg0,ArgT...args)2700 void DeviceProto::set_vendor(ArgT0&& arg0, ArgT... args) {
2701 
2702  _impl_.vendor_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
2703   // @@protoc_insertion_point(field_set:xla.DeviceProto.vendor)
2704 }
mutable_vendor()2705 inline std::string* DeviceProto::mutable_vendor() {
2706   std::string* _s = _internal_mutable_vendor();
2707   // @@protoc_insertion_point(field_mutable:xla.DeviceProto.vendor)
2708   return _s;
2709 }
_internal_vendor()2710 inline const std::string& DeviceProto::_internal_vendor() const {
2711   return _impl_.vendor_.Get();
2712 }
_internal_set_vendor(const std::string & value)2713 inline void DeviceProto::_internal_set_vendor(const std::string& value) {
2714 
2715   _impl_.vendor_.Set(value, GetArenaForAllocation());
2716 }
_internal_mutable_vendor()2717 inline std::string* DeviceProto::_internal_mutable_vendor() {
2718 
2719   return _impl_.vendor_.Mutable(GetArenaForAllocation());
2720 }
release_vendor()2721 inline std::string* DeviceProto::release_vendor() {
2722   // @@protoc_insertion_point(field_release:xla.DeviceProto.vendor)
2723   return _impl_.vendor_.Release();
2724 }
set_allocated_vendor(std::string * vendor)2725 inline void DeviceProto::set_allocated_vendor(std::string* vendor) {
2726   _impl_.vendor_.SetAllocated(vendor, GetArenaForAllocation());
2727 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2728   if (_impl_.vendor_.IsDefault()) {
2729     _impl_.vendor_.Set("", GetArenaForAllocation());
2730   }
2731 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2732   // @@protoc_insertion_point(field_set_allocated:xla.DeviceProto.vendor)
2733 }
2734 
2735 // int32 global_device_id = 4;
clear_global_device_id()2736 inline void DeviceProto::clear_global_device_id() {
2737   _impl_.global_device_id_ = 0;
2738 }
_internal_global_device_id()2739 inline ::int32_t DeviceProto::_internal_global_device_id() const {
2740   return _impl_.global_device_id_;
2741 }
global_device_id()2742 inline ::int32_t DeviceProto::global_device_id() const {
2743   // @@protoc_insertion_point(field_get:xla.DeviceProto.global_device_id)
2744   return _internal_global_device_id();
2745 }
_internal_set_global_device_id(::int32_t value)2746 inline void DeviceProto::_internal_set_global_device_id(::int32_t value) {
2747 
2748   _impl_.global_device_id_ = value;
2749 }
set_global_device_id(::int32_t value)2750 inline void DeviceProto::set_global_device_id(::int32_t value) {
2751   _internal_set_global_device_id(value);
2752   // @@protoc_insertion_point(field_set:xla.DeviceProto.global_device_id)
2753 }
2754 
2755 // -------------------------------------------------------------------
2756 
2757 // LocalTopologyProto
2758 
2759 // int32 node_id = 1;
clear_node_id()2760 inline void LocalTopologyProto::clear_node_id() {
2761   _impl_.node_id_ = 0;
2762 }
_internal_node_id()2763 inline ::int32_t LocalTopologyProto::_internal_node_id() const {
2764   return _impl_.node_id_;
2765 }
node_id()2766 inline ::int32_t LocalTopologyProto::node_id() const {
2767   // @@protoc_insertion_point(field_get:xla.LocalTopologyProto.node_id)
2768   return _internal_node_id();
2769 }
_internal_set_node_id(::int32_t value)2770 inline void LocalTopologyProto::_internal_set_node_id(::int32_t value) {
2771 
2772   _impl_.node_id_ = value;
2773 }
set_node_id(::int32_t value)2774 inline void LocalTopologyProto::set_node_id(::int32_t value) {
2775   _internal_set_node_id(value);
2776   // @@protoc_insertion_point(field_set:xla.LocalTopologyProto.node_id)
2777 }
2778 
2779 // repeated .xla.DeviceProto devices = 2;
_internal_devices_size()2780 inline int LocalTopologyProto::_internal_devices_size() const {
2781   return _impl_.devices_.size();
2782 }
devices_size()2783 inline int LocalTopologyProto::devices_size() const {
2784   return _internal_devices_size();
2785 }
clear_devices()2786 inline void LocalTopologyProto::clear_devices() {
2787   _impl_.devices_.Clear();
2788 }
mutable_devices(int index)2789 inline ::xla::DeviceProto* LocalTopologyProto::mutable_devices(int index) {
2790   // @@protoc_insertion_point(field_mutable:xla.LocalTopologyProto.devices)
2791   return _impl_.devices_.Mutable(index);
2792 }
2793 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::DeviceProto >*
mutable_devices()2794 LocalTopologyProto::mutable_devices() {
2795   // @@protoc_insertion_point(field_mutable_list:xla.LocalTopologyProto.devices)
2796   return &_impl_.devices_;
2797 }
_internal_devices(int index)2798 inline const ::xla::DeviceProto& LocalTopologyProto::_internal_devices(int index) const {
2799   return _impl_.devices_.Get(index);
2800 }
devices(int index)2801 inline const ::xla::DeviceProto& LocalTopologyProto::devices(int index) const {
2802   // @@protoc_insertion_point(field_get:xla.LocalTopologyProto.devices)
2803   return _internal_devices(index);
2804 }
_internal_add_devices()2805 inline ::xla::DeviceProto* LocalTopologyProto::_internal_add_devices() {
2806   return _impl_.devices_.Add();
2807 }
add_devices()2808 inline ::xla::DeviceProto* LocalTopologyProto::add_devices() {
2809   ::xla::DeviceProto* _add = _internal_add_devices();
2810   // @@protoc_insertion_point(field_add:xla.LocalTopologyProto.devices)
2811   return _add;
2812 }
2813 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::DeviceProto >&
devices()2814 LocalTopologyProto::devices() const {
2815   // @@protoc_insertion_point(field_list:xla.LocalTopologyProto.devices)
2816   return _impl_.devices_;
2817 }
2818 
2819 // -------------------------------------------------------------------
2820 
2821 // GlobalTopologyProto
2822 
2823 // repeated .xla.LocalTopologyProto nodes = 1;
_internal_nodes_size()2824 inline int GlobalTopologyProto::_internal_nodes_size() const {
2825   return _impl_.nodes_.size();
2826 }
nodes_size()2827 inline int GlobalTopologyProto::nodes_size() const {
2828   return _internal_nodes_size();
2829 }
clear_nodes()2830 inline void GlobalTopologyProto::clear_nodes() {
2831   _impl_.nodes_.Clear();
2832 }
mutable_nodes(int index)2833 inline ::xla::LocalTopologyProto* GlobalTopologyProto::mutable_nodes(int index) {
2834   // @@protoc_insertion_point(field_mutable:xla.GlobalTopologyProto.nodes)
2835   return _impl_.nodes_.Mutable(index);
2836 }
2837 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::LocalTopologyProto >*
mutable_nodes()2838 GlobalTopologyProto::mutable_nodes() {
2839   // @@protoc_insertion_point(field_mutable_list:xla.GlobalTopologyProto.nodes)
2840   return &_impl_.nodes_;
2841 }
_internal_nodes(int index)2842 inline const ::xla::LocalTopologyProto& GlobalTopologyProto::_internal_nodes(int index) const {
2843   return _impl_.nodes_.Get(index);
2844 }
nodes(int index)2845 inline const ::xla::LocalTopologyProto& GlobalTopologyProto::nodes(int index) const {
2846   // @@protoc_insertion_point(field_get:xla.GlobalTopologyProto.nodes)
2847   return _internal_nodes(index);
2848 }
_internal_add_nodes()2849 inline ::xla::LocalTopologyProto* GlobalTopologyProto::_internal_add_nodes() {
2850   return _impl_.nodes_.Add();
2851 }
add_nodes()2852 inline ::xla::LocalTopologyProto* GlobalTopologyProto::add_nodes() {
2853   ::xla::LocalTopologyProto* _add = _internal_add_nodes();
2854   // @@protoc_insertion_point(field_add:xla.GlobalTopologyProto.nodes)
2855   return _add;
2856 }
2857 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::LocalTopologyProto >&
nodes()2858 GlobalTopologyProto::nodes() const {
2859   // @@protoc_insertion_point(field_list:xla.GlobalTopologyProto.nodes)
2860   return _impl_.nodes_;
2861 }
2862 
2863 // -------------------------------------------------------------------
2864 
2865 // ConnectRequest
2866 
2867 // int32 protocol_version = 1;
clear_protocol_version()2868 inline void ConnectRequest::clear_protocol_version() {
2869   _impl_.protocol_version_ = 0;
2870 }
_internal_protocol_version()2871 inline ::int32_t ConnectRequest::_internal_protocol_version() const {
2872   return _impl_.protocol_version_;
2873 }
protocol_version()2874 inline ::int32_t ConnectRequest::protocol_version() const {
2875   // @@protoc_insertion_point(field_get:xla.ConnectRequest.protocol_version)
2876   return _internal_protocol_version();
2877 }
_internal_set_protocol_version(::int32_t value)2878 inline void ConnectRequest::_internal_set_protocol_version(::int32_t value) {
2879 
2880   _impl_.protocol_version_ = value;
2881 }
set_protocol_version(::int32_t value)2882 inline void ConnectRequest::set_protocol_version(::int32_t value) {
2883   _internal_set_protocol_version(value);
2884   // @@protoc_insertion_point(field_set:xla.ConnectRequest.protocol_version)
2885 }
2886 
2887 // int32 timeout_milliseconds = 2;
clear_timeout_milliseconds()2888 inline void ConnectRequest::clear_timeout_milliseconds() {
2889   _impl_.timeout_milliseconds_ = 0;
2890 }
_internal_timeout_milliseconds()2891 inline ::int32_t ConnectRequest::_internal_timeout_milliseconds() const {
2892   return _impl_.timeout_milliseconds_;
2893 }
timeout_milliseconds()2894 inline ::int32_t ConnectRequest::timeout_milliseconds() const {
2895   // @@protoc_insertion_point(field_get:xla.ConnectRequest.timeout_milliseconds)
2896   return _internal_timeout_milliseconds();
2897 }
_internal_set_timeout_milliseconds(::int32_t value)2898 inline void ConnectRequest::_internal_set_timeout_milliseconds(::int32_t value) {
2899 
2900   _impl_.timeout_milliseconds_ = value;
2901 }
set_timeout_milliseconds(::int32_t value)2902 inline void ConnectRequest::set_timeout_milliseconds(::int32_t value) {
2903   _internal_set_timeout_milliseconds(value);
2904   // @@protoc_insertion_point(field_set:xla.ConnectRequest.timeout_milliseconds)
2905 }
2906 
2907 // int32 node_id = 3;
clear_node_id()2908 inline void ConnectRequest::clear_node_id() {
2909   _impl_.node_id_ = 0;
2910 }
_internal_node_id()2911 inline ::int32_t ConnectRequest::_internal_node_id() const {
2912   return _impl_.node_id_;
2913 }
node_id()2914 inline ::int32_t ConnectRequest::node_id() const {
2915   // @@protoc_insertion_point(field_get:xla.ConnectRequest.node_id)
2916   return _internal_node_id();
2917 }
_internal_set_node_id(::int32_t value)2918 inline void ConnectRequest::_internal_set_node_id(::int32_t value) {
2919 
2920   _impl_.node_id_ = value;
2921 }
set_node_id(::int32_t value)2922 inline void ConnectRequest::set_node_id(::int32_t value) {
2923   _internal_set_node_id(value);
2924   // @@protoc_insertion_point(field_set:xla.ConnectRequest.node_id)
2925 }
2926 
2927 // uint64 client_id = 4;
clear_client_id()2928 inline void ConnectRequest::clear_client_id() {
2929   _impl_.client_id_ = ::uint64_t{0u};
2930 }
_internal_client_id()2931 inline ::uint64_t ConnectRequest::_internal_client_id() const {
2932   return _impl_.client_id_;
2933 }
client_id()2934 inline ::uint64_t ConnectRequest::client_id() const {
2935   // @@protoc_insertion_point(field_get:xla.ConnectRequest.client_id)
2936   return _internal_client_id();
2937 }
_internal_set_client_id(::uint64_t value)2938 inline void ConnectRequest::_internal_set_client_id(::uint64_t value) {
2939 
2940   _impl_.client_id_ = value;
2941 }
set_client_id(::uint64_t value)2942 inline void ConnectRequest::set_client_id(::uint64_t value) {
2943   _internal_set_client_id(value);
2944   // @@protoc_insertion_point(field_set:xla.ConnectRequest.client_id)
2945 }
2946 
2947 // -------------------------------------------------------------------
2948 
2949 // ConnectResponse
2950 
2951 // uint64 session_id = 1;
clear_session_id()2952 inline void ConnectResponse::clear_session_id() {
2953   _impl_.session_id_ = ::uint64_t{0u};
2954 }
_internal_session_id()2955 inline ::uint64_t ConnectResponse::_internal_session_id() const {
2956   return _impl_.session_id_;
2957 }
session_id()2958 inline ::uint64_t ConnectResponse::session_id() const {
2959   // @@protoc_insertion_point(field_get:xla.ConnectResponse.session_id)
2960   return _internal_session_id();
2961 }
_internal_set_session_id(::uint64_t value)2962 inline void ConnectResponse::_internal_set_session_id(::uint64_t value) {
2963 
2964   _impl_.session_id_ = value;
2965 }
set_session_id(::uint64_t value)2966 inline void ConnectResponse::set_session_id(::uint64_t value) {
2967   _internal_set_session_id(value);
2968   // @@protoc_insertion_point(field_set:xla.ConnectResponse.session_id)
2969 }
2970 
2971 // -------------------------------------------------------------------
2972 
2973 // EnumerateDevicesRequest
2974 
2975 // uint64 session_id = 1;
clear_session_id()2976 inline void EnumerateDevicesRequest::clear_session_id() {
2977   _impl_.session_id_ = ::uint64_t{0u};
2978 }
_internal_session_id()2979 inline ::uint64_t EnumerateDevicesRequest::_internal_session_id() const {
2980   return _impl_.session_id_;
2981 }
session_id()2982 inline ::uint64_t EnumerateDevicesRequest::session_id() const {
2983   // @@protoc_insertion_point(field_get:xla.EnumerateDevicesRequest.session_id)
2984   return _internal_session_id();
2985 }
_internal_set_session_id(::uint64_t value)2986 inline void EnumerateDevicesRequest::_internal_set_session_id(::uint64_t value) {
2987 
2988   _impl_.session_id_ = value;
2989 }
set_session_id(::uint64_t value)2990 inline void EnumerateDevicesRequest::set_session_id(::uint64_t value) {
2991   _internal_set_session_id(value);
2992   // @@protoc_insertion_point(field_set:xla.EnumerateDevicesRequest.session_id)
2993 }
2994 
2995 // .xla.LocalTopologyProto local_topology = 3;
_internal_has_local_topology()2996 inline bool EnumerateDevicesRequest::_internal_has_local_topology() const {
2997   return this != internal_default_instance() && _impl_.local_topology_ != nullptr;
2998 }
has_local_topology()2999 inline bool EnumerateDevicesRequest::has_local_topology() const {
3000   return _internal_has_local_topology();
3001 }
clear_local_topology()3002 inline void EnumerateDevicesRequest::clear_local_topology() {
3003   if (GetArenaForAllocation() == nullptr && _impl_.local_topology_ != nullptr) {
3004     delete _impl_.local_topology_;
3005   }
3006   _impl_.local_topology_ = nullptr;
3007 }
_internal_local_topology()3008 inline const ::xla::LocalTopologyProto& EnumerateDevicesRequest::_internal_local_topology() const {
3009   const ::xla::LocalTopologyProto* p = _impl_.local_topology_;
3010   return p != nullptr ? *p : reinterpret_cast<const ::xla::LocalTopologyProto&>(
3011       ::xla::_LocalTopologyProto_default_instance_);
3012 }
local_topology()3013 inline const ::xla::LocalTopologyProto& EnumerateDevicesRequest::local_topology() const {
3014   // @@protoc_insertion_point(field_get:xla.EnumerateDevicesRequest.local_topology)
3015   return _internal_local_topology();
3016 }
unsafe_arena_set_allocated_local_topology(::xla::LocalTopologyProto * local_topology)3017 inline void EnumerateDevicesRequest::unsafe_arena_set_allocated_local_topology(
3018     ::xla::LocalTopologyProto* local_topology) {
3019   if (GetArenaForAllocation() == nullptr) {
3020     delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.local_topology_);
3021   }
3022   _impl_.local_topology_ = local_topology;
3023   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.EnumerateDevicesRequest.local_topology)
3024 }
release_local_topology()3025 inline ::xla::LocalTopologyProto* EnumerateDevicesRequest::release_local_topology() {
3026 
3027   ::xla::LocalTopologyProto* temp = _impl_.local_topology_;
3028   _impl_.local_topology_ = nullptr;
3029 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
3030   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
3031   temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3032   if (GetArenaForAllocation() == nullptr) { delete old; }
3033 #else  // PROTOBUF_FORCE_COPY_IN_RELEASE
3034   if (GetArenaForAllocation() != nullptr) {
3035     temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3036   }
3037 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
3038   return temp;
3039 }
unsafe_arena_release_local_topology()3040 inline ::xla::LocalTopologyProto* EnumerateDevicesRequest::unsafe_arena_release_local_topology() {
3041   // @@protoc_insertion_point(field_release:xla.EnumerateDevicesRequest.local_topology)
3042 
3043   ::xla::LocalTopologyProto* temp = _impl_.local_topology_;
3044   _impl_.local_topology_ = nullptr;
3045   return temp;
3046 }
_internal_mutable_local_topology()3047 inline ::xla::LocalTopologyProto* EnumerateDevicesRequest::_internal_mutable_local_topology() {
3048 
3049   if (_impl_.local_topology_ == nullptr) {
3050     auto* p = CreateMaybeMessage<::xla::LocalTopologyProto>(GetArenaForAllocation());
3051     _impl_.local_topology_ = p;
3052   }
3053   return _impl_.local_topology_;
3054 }
mutable_local_topology()3055 inline ::xla::LocalTopologyProto* EnumerateDevicesRequest::mutable_local_topology() {
3056   ::xla::LocalTopologyProto* _msg = _internal_mutable_local_topology();
3057   // @@protoc_insertion_point(field_mutable:xla.EnumerateDevicesRequest.local_topology)
3058   return _msg;
3059 }
set_allocated_local_topology(::xla::LocalTopologyProto * local_topology)3060 inline void EnumerateDevicesRequest::set_allocated_local_topology(::xla::LocalTopologyProto* local_topology) {
3061   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
3062   if (message_arena == nullptr) {
3063     delete _impl_.local_topology_;
3064   }
3065   if (local_topology) {
3066     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
3067         ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(local_topology);
3068     if (message_arena != submessage_arena) {
3069       local_topology = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
3070           message_arena, local_topology, submessage_arena);
3071     }
3072 
3073   } else {
3074 
3075   }
3076   _impl_.local_topology_ = local_topology;
3077   // @@protoc_insertion_point(field_set_allocated:xla.EnumerateDevicesRequest.local_topology)
3078 }
3079 
3080 // -------------------------------------------------------------------
3081 
3082 // EnumerateDevicesResponse
3083 
3084 // .xla.GlobalTopologyProto global_topology = 1;
_internal_has_global_topology()3085 inline bool EnumerateDevicesResponse::_internal_has_global_topology() const {
3086   return this != internal_default_instance() && _impl_.global_topology_ != nullptr;
3087 }
has_global_topology()3088 inline bool EnumerateDevicesResponse::has_global_topology() const {
3089   return _internal_has_global_topology();
3090 }
clear_global_topology()3091 inline void EnumerateDevicesResponse::clear_global_topology() {
3092   if (GetArenaForAllocation() == nullptr && _impl_.global_topology_ != nullptr) {
3093     delete _impl_.global_topology_;
3094   }
3095   _impl_.global_topology_ = nullptr;
3096 }
_internal_global_topology()3097 inline const ::xla::GlobalTopologyProto& EnumerateDevicesResponse::_internal_global_topology() const {
3098   const ::xla::GlobalTopologyProto* p = _impl_.global_topology_;
3099   return p != nullptr ? *p : reinterpret_cast<const ::xla::GlobalTopologyProto&>(
3100       ::xla::_GlobalTopologyProto_default_instance_);
3101 }
global_topology()3102 inline const ::xla::GlobalTopologyProto& EnumerateDevicesResponse::global_topology() const {
3103   // @@protoc_insertion_point(field_get:xla.EnumerateDevicesResponse.global_topology)
3104   return _internal_global_topology();
3105 }
unsafe_arena_set_allocated_global_topology(::xla::GlobalTopologyProto * global_topology)3106 inline void EnumerateDevicesResponse::unsafe_arena_set_allocated_global_topology(
3107     ::xla::GlobalTopologyProto* global_topology) {
3108   if (GetArenaForAllocation() == nullptr) {
3109     delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.global_topology_);
3110   }
3111   _impl_.global_topology_ = global_topology;
3112   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.EnumerateDevicesResponse.global_topology)
3113 }
release_global_topology()3114 inline ::xla::GlobalTopologyProto* EnumerateDevicesResponse::release_global_topology() {
3115 
3116   ::xla::GlobalTopologyProto* temp = _impl_.global_topology_;
3117   _impl_.global_topology_ = nullptr;
3118 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
3119   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
3120   temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3121   if (GetArenaForAllocation() == nullptr) { delete old; }
3122 #else  // PROTOBUF_FORCE_COPY_IN_RELEASE
3123   if (GetArenaForAllocation() != nullptr) {
3124     temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3125   }
3126 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
3127   return temp;
3128 }
unsafe_arena_release_global_topology()3129 inline ::xla::GlobalTopologyProto* EnumerateDevicesResponse::unsafe_arena_release_global_topology() {
3130   // @@protoc_insertion_point(field_release:xla.EnumerateDevicesResponse.global_topology)
3131 
3132   ::xla::GlobalTopologyProto* temp = _impl_.global_topology_;
3133   _impl_.global_topology_ = nullptr;
3134   return temp;
3135 }
_internal_mutable_global_topology()3136 inline ::xla::GlobalTopologyProto* EnumerateDevicesResponse::_internal_mutable_global_topology() {
3137 
3138   if (_impl_.global_topology_ == nullptr) {
3139     auto* p = CreateMaybeMessage<::xla::GlobalTopologyProto>(GetArenaForAllocation());
3140     _impl_.global_topology_ = p;
3141   }
3142   return _impl_.global_topology_;
3143 }
mutable_global_topology()3144 inline ::xla::GlobalTopologyProto* EnumerateDevicesResponse::mutable_global_topology() {
3145   ::xla::GlobalTopologyProto* _msg = _internal_mutable_global_topology();
3146   // @@protoc_insertion_point(field_mutable:xla.EnumerateDevicesResponse.global_topology)
3147   return _msg;
3148 }
set_allocated_global_topology(::xla::GlobalTopologyProto * global_topology)3149 inline void EnumerateDevicesResponse::set_allocated_global_topology(::xla::GlobalTopologyProto* global_topology) {
3150   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
3151   if (message_arena == nullptr) {
3152     delete _impl_.global_topology_;
3153   }
3154   if (global_topology) {
3155     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
3156         ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(global_topology);
3157     if (message_arena != submessage_arena) {
3158       global_topology = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
3159           message_arena, global_topology, submessage_arena);
3160     }
3161 
3162   } else {
3163 
3164   }
3165   _impl_.global_topology_ = global_topology;
3166   // @@protoc_insertion_point(field_set_allocated:xla.EnumerateDevicesResponse.global_topology)
3167 }
3168 
3169 // -------------------------------------------------------------------
3170 
3171 // KeyValueGetRequest
3172 
3173 // uint64 session_id = 1;
clear_session_id()3174 inline void KeyValueGetRequest::clear_session_id() {
3175   _impl_.session_id_ = ::uint64_t{0u};
3176 }
_internal_session_id()3177 inline ::uint64_t KeyValueGetRequest::_internal_session_id() const {
3178   return _impl_.session_id_;
3179 }
session_id()3180 inline ::uint64_t KeyValueGetRequest::session_id() const {
3181   // @@protoc_insertion_point(field_get:xla.KeyValueGetRequest.session_id)
3182   return _internal_session_id();
3183 }
_internal_set_session_id(::uint64_t value)3184 inline void KeyValueGetRequest::_internal_set_session_id(::uint64_t value) {
3185 
3186   _impl_.session_id_ = value;
3187 }
set_session_id(::uint64_t value)3188 inline void KeyValueGetRequest::set_session_id(::uint64_t value) {
3189   _internal_set_session_id(value);
3190   // @@protoc_insertion_point(field_set:xla.KeyValueGetRequest.session_id)
3191 }
3192 
3193 // bytes key = 2;
clear_key()3194 inline void KeyValueGetRequest::clear_key() {
3195   _impl_.key_.ClearToEmpty();
3196 }
key()3197 inline const std::string& KeyValueGetRequest::key() const {
3198   // @@protoc_insertion_point(field_get:xla.KeyValueGetRequest.key)
3199   return _internal_key();
3200 }
3201 template <typename ArgT0, typename... ArgT>
3202 inline PROTOBUF_ALWAYS_INLINE
set_key(ArgT0 && arg0,ArgT...args)3203 void KeyValueGetRequest::set_key(ArgT0&& arg0, ArgT... args) {
3204 
3205  _impl_.key_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3206   // @@protoc_insertion_point(field_set:xla.KeyValueGetRequest.key)
3207 }
mutable_key()3208 inline std::string* KeyValueGetRequest::mutable_key() {
3209   std::string* _s = _internal_mutable_key();
3210   // @@protoc_insertion_point(field_mutable:xla.KeyValueGetRequest.key)
3211   return _s;
3212 }
_internal_key()3213 inline const std::string& KeyValueGetRequest::_internal_key() const {
3214   return _impl_.key_.Get();
3215 }
_internal_set_key(const std::string & value)3216 inline void KeyValueGetRequest::_internal_set_key(const std::string& value) {
3217 
3218   _impl_.key_.Set(value, GetArenaForAllocation());
3219 }
_internal_mutable_key()3220 inline std::string* KeyValueGetRequest::_internal_mutable_key() {
3221 
3222   return _impl_.key_.Mutable(GetArenaForAllocation());
3223 }
release_key()3224 inline std::string* KeyValueGetRequest::release_key() {
3225   // @@protoc_insertion_point(field_release:xla.KeyValueGetRequest.key)
3226   return _impl_.key_.Release();
3227 }
set_allocated_key(std::string * key)3228 inline void KeyValueGetRequest::set_allocated_key(std::string* key) {
3229   _impl_.key_.SetAllocated(key, GetArenaForAllocation());
3230 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3231   if (_impl_.key_.IsDefault()) {
3232     _impl_.key_.Set("", GetArenaForAllocation());
3233   }
3234 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3235   // @@protoc_insertion_point(field_set_allocated:xla.KeyValueGetRequest.key)
3236 }
3237 
3238 // int32 timeout_milliseconds = 3;
clear_timeout_milliseconds()3239 inline void KeyValueGetRequest::clear_timeout_milliseconds() {
3240   _impl_.timeout_milliseconds_ = 0;
3241 }
_internal_timeout_milliseconds()3242 inline ::int32_t KeyValueGetRequest::_internal_timeout_milliseconds() const {
3243   return _impl_.timeout_milliseconds_;
3244 }
timeout_milliseconds()3245 inline ::int32_t KeyValueGetRequest::timeout_milliseconds() const {
3246   // @@protoc_insertion_point(field_get:xla.KeyValueGetRequest.timeout_milliseconds)
3247   return _internal_timeout_milliseconds();
3248 }
_internal_set_timeout_milliseconds(::int32_t value)3249 inline void KeyValueGetRequest::_internal_set_timeout_milliseconds(::int32_t value) {
3250 
3251   _impl_.timeout_milliseconds_ = value;
3252 }
set_timeout_milliseconds(::int32_t value)3253 inline void KeyValueGetRequest::set_timeout_milliseconds(::int32_t value) {
3254   _internal_set_timeout_milliseconds(value);
3255   // @@protoc_insertion_point(field_set:xla.KeyValueGetRequest.timeout_milliseconds)
3256 }
3257 
3258 // -------------------------------------------------------------------
3259 
3260 // KeyValueGetResponse
3261 
3262 // bool found = 1;
clear_found()3263 inline void KeyValueGetResponse::clear_found() {
3264   _impl_.found_ = false;
3265 }
_internal_found()3266 inline bool KeyValueGetResponse::_internal_found() const {
3267   return _impl_.found_;
3268 }
found()3269 inline bool KeyValueGetResponse::found() const {
3270   // @@protoc_insertion_point(field_get:xla.KeyValueGetResponse.found)
3271   return _internal_found();
3272 }
_internal_set_found(bool value)3273 inline void KeyValueGetResponse::_internal_set_found(bool value) {
3274 
3275   _impl_.found_ = value;
3276 }
set_found(bool value)3277 inline void KeyValueGetResponse::set_found(bool value) {
3278   _internal_set_found(value);
3279   // @@protoc_insertion_point(field_set:xla.KeyValueGetResponse.found)
3280 }
3281 
3282 // bytes value = 2;
clear_value()3283 inline void KeyValueGetResponse::clear_value() {
3284   _impl_.value_.ClearToEmpty();
3285 }
value()3286 inline const std::string& KeyValueGetResponse::value() const {
3287   // @@protoc_insertion_point(field_get:xla.KeyValueGetResponse.value)
3288   return _internal_value();
3289 }
3290 template <typename ArgT0, typename... ArgT>
3291 inline PROTOBUF_ALWAYS_INLINE
set_value(ArgT0 && arg0,ArgT...args)3292 void KeyValueGetResponse::set_value(ArgT0&& arg0, ArgT... args) {
3293 
3294  _impl_.value_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3295   // @@protoc_insertion_point(field_set:xla.KeyValueGetResponse.value)
3296 }
mutable_value()3297 inline std::string* KeyValueGetResponse::mutable_value() {
3298   std::string* _s = _internal_mutable_value();
3299   // @@protoc_insertion_point(field_mutable:xla.KeyValueGetResponse.value)
3300   return _s;
3301 }
_internal_value()3302 inline const std::string& KeyValueGetResponse::_internal_value() const {
3303   return _impl_.value_.Get();
3304 }
_internal_set_value(const std::string & value)3305 inline void KeyValueGetResponse::_internal_set_value(const std::string& value) {
3306 
3307   _impl_.value_.Set(value, GetArenaForAllocation());
3308 }
_internal_mutable_value()3309 inline std::string* KeyValueGetResponse::_internal_mutable_value() {
3310 
3311   return _impl_.value_.Mutable(GetArenaForAllocation());
3312 }
release_value()3313 inline std::string* KeyValueGetResponse::release_value() {
3314   // @@protoc_insertion_point(field_release:xla.KeyValueGetResponse.value)
3315   return _impl_.value_.Release();
3316 }
set_allocated_value(std::string * value)3317 inline void KeyValueGetResponse::set_allocated_value(std::string* value) {
3318   _impl_.value_.SetAllocated(value, GetArenaForAllocation());
3319 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3320   if (_impl_.value_.IsDefault()) {
3321     _impl_.value_.Set("", GetArenaForAllocation());
3322   }
3323 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3324   // @@protoc_insertion_point(field_set_allocated:xla.KeyValueGetResponse.value)
3325 }
3326 
3327 // -------------------------------------------------------------------
3328 
3329 // KeyValueSetRequest
3330 
3331 // uint64 session_id = 1;
clear_session_id()3332 inline void KeyValueSetRequest::clear_session_id() {
3333   _impl_.session_id_ = ::uint64_t{0u};
3334 }
_internal_session_id()3335 inline ::uint64_t KeyValueSetRequest::_internal_session_id() const {
3336   return _impl_.session_id_;
3337 }
session_id()3338 inline ::uint64_t KeyValueSetRequest::session_id() const {
3339   // @@protoc_insertion_point(field_get:xla.KeyValueSetRequest.session_id)
3340   return _internal_session_id();
3341 }
_internal_set_session_id(::uint64_t value)3342 inline void KeyValueSetRequest::_internal_set_session_id(::uint64_t value) {
3343 
3344   _impl_.session_id_ = value;
3345 }
set_session_id(::uint64_t value)3346 inline void KeyValueSetRequest::set_session_id(::uint64_t value) {
3347   _internal_set_session_id(value);
3348   // @@protoc_insertion_point(field_set:xla.KeyValueSetRequest.session_id)
3349 }
3350 
3351 // bytes key = 2;
clear_key()3352 inline void KeyValueSetRequest::clear_key() {
3353   _impl_.key_.ClearToEmpty();
3354 }
key()3355 inline const std::string& KeyValueSetRequest::key() const {
3356   // @@protoc_insertion_point(field_get:xla.KeyValueSetRequest.key)
3357   return _internal_key();
3358 }
3359 template <typename ArgT0, typename... ArgT>
3360 inline PROTOBUF_ALWAYS_INLINE
set_key(ArgT0 && arg0,ArgT...args)3361 void KeyValueSetRequest::set_key(ArgT0&& arg0, ArgT... args) {
3362 
3363  _impl_.key_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3364   // @@protoc_insertion_point(field_set:xla.KeyValueSetRequest.key)
3365 }
mutable_key()3366 inline std::string* KeyValueSetRequest::mutable_key() {
3367   std::string* _s = _internal_mutable_key();
3368   // @@protoc_insertion_point(field_mutable:xla.KeyValueSetRequest.key)
3369   return _s;
3370 }
_internal_key()3371 inline const std::string& KeyValueSetRequest::_internal_key() const {
3372   return _impl_.key_.Get();
3373 }
_internal_set_key(const std::string & value)3374 inline void KeyValueSetRequest::_internal_set_key(const std::string& value) {
3375 
3376   _impl_.key_.Set(value, GetArenaForAllocation());
3377 }
_internal_mutable_key()3378 inline std::string* KeyValueSetRequest::_internal_mutable_key() {
3379 
3380   return _impl_.key_.Mutable(GetArenaForAllocation());
3381 }
release_key()3382 inline std::string* KeyValueSetRequest::release_key() {
3383   // @@protoc_insertion_point(field_release:xla.KeyValueSetRequest.key)
3384   return _impl_.key_.Release();
3385 }
set_allocated_key(std::string * key)3386 inline void KeyValueSetRequest::set_allocated_key(std::string* key) {
3387   _impl_.key_.SetAllocated(key, GetArenaForAllocation());
3388 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3389   if (_impl_.key_.IsDefault()) {
3390     _impl_.key_.Set("", GetArenaForAllocation());
3391   }
3392 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3393   // @@protoc_insertion_point(field_set_allocated:xla.KeyValueSetRequest.key)
3394 }
3395 
3396 // bytes value = 3;
clear_value()3397 inline void KeyValueSetRequest::clear_value() {
3398   _impl_.value_.ClearToEmpty();
3399 }
value()3400 inline const std::string& KeyValueSetRequest::value() const {
3401   // @@protoc_insertion_point(field_get:xla.KeyValueSetRequest.value)
3402   return _internal_value();
3403 }
3404 template <typename ArgT0, typename... ArgT>
3405 inline PROTOBUF_ALWAYS_INLINE
set_value(ArgT0 && arg0,ArgT...args)3406 void KeyValueSetRequest::set_value(ArgT0&& arg0, ArgT... args) {
3407 
3408  _impl_.value_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3409   // @@protoc_insertion_point(field_set:xla.KeyValueSetRequest.value)
3410 }
mutable_value()3411 inline std::string* KeyValueSetRequest::mutable_value() {
3412   std::string* _s = _internal_mutable_value();
3413   // @@protoc_insertion_point(field_mutable:xla.KeyValueSetRequest.value)
3414   return _s;
3415 }
_internal_value()3416 inline const std::string& KeyValueSetRequest::_internal_value() const {
3417   return _impl_.value_.Get();
3418 }
_internal_set_value(const std::string & value)3419 inline void KeyValueSetRequest::_internal_set_value(const std::string& value) {
3420 
3421   _impl_.value_.Set(value, GetArenaForAllocation());
3422 }
_internal_mutable_value()3423 inline std::string* KeyValueSetRequest::_internal_mutable_value() {
3424 
3425   return _impl_.value_.Mutable(GetArenaForAllocation());
3426 }
release_value()3427 inline std::string* KeyValueSetRequest::release_value() {
3428   // @@protoc_insertion_point(field_release:xla.KeyValueSetRequest.value)
3429   return _impl_.value_.Release();
3430 }
set_allocated_value(std::string * value)3431 inline void KeyValueSetRequest::set_allocated_value(std::string* value) {
3432   _impl_.value_.SetAllocated(value, GetArenaForAllocation());
3433 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3434   if (_impl_.value_.IsDefault()) {
3435     _impl_.value_.Set("", GetArenaForAllocation());
3436   }
3437 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3438   // @@protoc_insertion_point(field_set_allocated:xla.KeyValueSetRequest.value)
3439 }
3440 
3441 // -------------------------------------------------------------------
3442 
3443 // KeyValueSetResponse
3444 
3445 // -------------------------------------------------------------------
3446 
3447 // WaitAtBarrierRequest
3448 
3449 // uint64 session_id = 1;
clear_session_id()3450 inline void WaitAtBarrierRequest::clear_session_id() {
3451   _impl_.session_id_ = ::uint64_t{0u};
3452 }
_internal_session_id()3453 inline ::uint64_t WaitAtBarrierRequest::_internal_session_id() const {
3454   return _impl_.session_id_;
3455 }
session_id()3456 inline ::uint64_t WaitAtBarrierRequest::session_id() const {
3457   // @@protoc_insertion_point(field_get:xla.WaitAtBarrierRequest.session_id)
3458   return _internal_session_id();
3459 }
_internal_set_session_id(::uint64_t value)3460 inline void WaitAtBarrierRequest::_internal_set_session_id(::uint64_t value) {
3461 
3462   _impl_.session_id_ = value;
3463 }
set_session_id(::uint64_t value)3464 inline void WaitAtBarrierRequest::set_session_id(::uint64_t value) {
3465   _internal_set_session_id(value);
3466   // @@protoc_insertion_point(field_set:xla.WaitAtBarrierRequest.session_id)
3467 }
3468 
3469 // bytes barrier_id = 2;
clear_barrier_id()3470 inline void WaitAtBarrierRequest::clear_barrier_id() {
3471   _impl_.barrier_id_.ClearToEmpty();
3472 }
barrier_id()3473 inline const std::string& WaitAtBarrierRequest::barrier_id() const {
3474   // @@protoc_insertion_point(field_get:xla.WaitAtBarrierRequest.barrier_id)
3475   return _internal_barrier_id();
3476 }
3477 template <typename ArgT0, typename... ArgT>
3478 inline PROTOBUF_ALWAYS_INLINE
set_barrier_id(ArgT0 && arg0,ArgT...args)3479 void WaitAtBarrierRequest::set_barrier_id(ArgT0&& arg0, ArgT... args) {
3480 
3481  _impl_.barrier_id_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3482   // @@protoc_insertion_point(field_set:xla.WaitAtBarrierRequest.barrier_id)
3483 }
mutable_barrier_id()3484 inline std::string* WaitAtBarrierRequest::mutable_barrier_id() {
3485   std::string* _s = _internal_mutable_barrier_id();
3486   // @@protoc_insertion_point(field_mutable:xla.WaitAtBarrierRequest.barrier_id)
3487   return _s;
3488 }
_internal_barrier_id()3489 inline const std::string& WaitAtBarrierRequest::_internal_barrier_id() const {
3490   return _impl_.barrier_id_.Get();
3491 }
_internal_set_barrier_id(const std::string & value)3492 inline void WaitAtBarrierRequest::_internal_set_barrier_id(const std::string& value) {
3493 
3494   _impl_.barrier_id_.Set(value, GetArenaForAllocation());
3495 }
_internal_mutable_barrier_id()3496 inline std::string* WaitAtBarrierRequest::_internal_mutable_barrier_id() {
3497 
3498   return _impl_.barrier_id_.Mutable(GetArenaForAllocation());
3499 }
release_barrier_id()3500 inline std::string* WaitAtBarrierRequest::release_barrier_id() {
3501   // @@protoc_insertion_point(field_release:xla.WaitAtBarrierRequest.barrier_id)
3502   return _impl_.barrier_id_.Release();
3503 }
set_allocated_barrier_id(std::string * barrier_id)3504 inline void WaitAtBarrierRequest::set_allocated_barrier_id(std::string* barrier_id) {
3505   _impl_.barrier_id_.SetAllocated(barrier_id, GetArenaForAllocation());
3506 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3507   if (_impl_.barrier_id_.IsDefault()) {
3508     _impl_.barrier_id_.Set("", GetArenaForAllocation());
3509   }
3510 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3511   // @@protoc_insertion_point(field_set_allocated:xla.WaitAtBarrierRequest.barrier_id)
3512 }
3513 
3514 // int32 node_id = 3;
clear_node_id()3515 inline void WaitAtBarrierRequest::clear_node_id() {
3516   _impl_.node_id_ = 0;
3517 }
_internal_node_id()3518 inline ::int32_t WaitAtBarrierRequest::_internal_node_id() const {
3519   return _impl_.node_id_;
3520 }
node_id()3521 inline ::int32_t WaitAtBarrierRequest::node_id() const {
3522   // @@protoc_insertion_point(field_get:xla.WaitAtBarrierRequest.node_id)
3523   return _internal_node_id();
3524 }
_internal_set_node_id(::int32_t value)3525 inline void WaitAtBarrierRequest::_internal_set_node_id(::int32_t value) {
3526 
3527   _impl_.node_id_ = value;
3528 }
set_node_id(::int32_t value)3529 inline void WaitAtBarrierRequest::set_node_id(::int32_t value) {
3530   _internal_set_node_id(value);
3531   // @@protoc_insertion_point(field_set:xla.WaitAtBarrierRequest.node_id)
3532 }
3533 
3534 // int32 timeout_milliseconds = 4;
clear_timeout_milliseconds()3535 inline void WaitAtBarrierRequest::clear_timeout_milliseconds() {
3536   _impl_.timeout_milliseconds_ = 0;
3537 }
_internal_timeout_milliseconds()3538 inline ::int32_t WaitAtBarrierRequest::_internal_timeout_milliseconds() const {
3539   return _impl_.timeout_milliseconds_;
3540 }
timeout_milliseconds()3541 inline ::int32_t WaitAtBarrierRequest::timeout_milliseconds() const {
3542   // @@protoc_insertion_point(field_get:xla.WaitAtBarrierRequest.timeout_milliseconds)
3543   return _internal_timeout_milliseconds();
3544 }
_internal_set_timeout_milliseconds(::int32_t value)3545 inline void WaitAtBarrierRequest::_internal_set_timeout_milliseconds(::int32_t value) {
3546 
3547   _impl_.timeout_milliseconds_ = value;
3548 }
set_timeout_milliseconds(::int32_t value)3549 inline void WaitAtBarrierRequest::set_timeout_milliseconds(::int32_t value) {
3550   _internal_set_timeout_milliseconds(value);
3551   // @@protoc_insertion_point(field_set:xla.WaitAtBarrierRequest.timeout_milliseconds)
3552 }
3553 
3554 // -------------------------------------------------------------------
3555 
3556 // WaitAtBarrierResponse
3557 
3558 // -------------------------------------------------------------------
3559 
3560 // HeartbeatRequest
3561 
3562 // uint64 session_id = 1;
clear_session_id()3563 inline void HeartbeatRequest::clear_session_id() {
3564   _impl_.session_id_ = ::uint64_t{0u};
3565 }
_internal_session_id()3566 inline ::uint64_t HeartbeatRequest::_internal_session_id() const {
3567   return _impl_.session_id_;
3568 }
session_id()3569 inline ::uint64_t HeartbeatRequest::session_id() const {
3570   // @@protoc_insertion_point(field_get:xla.HeartbeatRequest.session_id)
3571   return _internal_session_id();
3572 }
_internal_set_session_id(::uint64_t value)3573 inline void HeartbeatRequest::_internal_set_session_id(::uint64_t value) {
3574 
3575   _impl_.session_id_ = value;
3576 }
set_session_id(::uint64_t value)3577 inline void HeartbeatRequest::set_session_id(::uint64_t value) {
3578   _internal_set_session_id(value);
3579   // @@protoc_insertion_point(field_set:xla.HeartbeatRequest.session_id)
3580 }
3581 
3582 // int32 node_id = 2;
clear_node_id()3583 inline void HeartbeatRequest::clear_node_id() {
3584   _impl_.node_id_ = 0;
3585 }
_internal_node_id()3586 inline ::int32_t HeartbeatRequest::_internal_node_id() const {
3587   return _impl_.node_id_;
3588 }
node_id()3589 inline ::int32_t HeartbeatRequest::node_id() const {
3590   // @@protoc_insertion_point(field_get:xla.HeartbeatRequest.node_id)
3591   return _internal_node_id();
3592 }
_internal_set_node_id(::int32_t value)3593 inline void HeartbeatRequest::_internal_set_node_id(::int32_t value) {
3594 
3595   _impl_.node_id_ = value;
3596 }
set_node_id(::int32_t value)3597 inline void HeartbeatRequest::set_node_id(::int32_t value) {
3598   _internal_set_node_id(value);
3599   // @@protoc_insertion_point(field_set:xla.HeartbeatRequest.node_id)
3600 }
3601 
3602 // -------------------------------------------------------------------
3603 
3604 // HeartbeatResponse
3605 
3606 // -------------------------------------------------------------------
3607 
3608 // ShutdownRequest
3609 
3610 // uint64 session_id = 1;
clear_session_id()3611 inline void ShutdownRequest::clear_session_id() {
3612   _impl_.session_id_ = ::uint64_t{0u};
3613 }
_internal_session_id()3614 inline ::uint64_t ShutdownRequest::_internal_session_id() const {
3615   return _impl_.session_id_;
3616 }
session_id()3617 inline ::uint64_t ShutdownRequest::session_id() const {
3618   // @@protoc_insertion_point(field_get:xla.ShutdownRequest.session_id)
3619   return _internal_session_id();
3620 }
_internal_set_session_id(::uint64_t value)3621 inline void ShutdownRequest::_internal_set_session_id(::uint64_t value) {
3622 
3623   _impl_.session_id_ = value;
3624 }
set_session_id(::uint64_t value)3625 inline void ShutdownRequest::set_session_id(::uint64_t value) {
3626   _internal_set_session_id(value);
3627   // @@protoc_insertion_point(field_set:xla.ShutdownRequest.session_id)
3628 }
3629 
3630 // int32 node_id = 2;
clear_node_id()3631 inline void ShutdownRequest::clear_node_id() {
3632   _impl_.node_id_ = 0;
3633 }
_internal_node_id()3634 inline ::int32_t ShutdownRequest::_internal_node_id() const {
3635   return _impl_.node_id_;
3636 }
node_id()3637 inline ::int32_t ShutdownRequest::node_id() const {
3638   // @@protoc_insertion_point(field_get:xla.ShutdownRequest.node_id)
3639   return _internal_node_id();
3640 }
_internal_set_node_id(::int32_t value)3641 inline void ShutdownRequest::_internal_set_node_id(::int32_t value) {
3642 
3643   _impl_.node_id_ = value;
3644 }
set_node_id(::int32_t value)3645 inline void ShutdownRequest::set_node_id(::int32_t value) {
3646   _internal_set_node_id(value);
3647   // @@protoc_insertion_point(field_set:xla.ShutdownRequest.node_id)
3648 }
3649 
3650 // -------------------------------------------------------------------
3651 
3652 // ShutdownResponse
3653 
3654 #ifdef __GNUC__
3655   #pragma GCC diagnostic pop
3656 #endif  // __GNUC__
3657 // -------------------------------------------------------------------
3658 
3659 // -------------------------------------------------------------------
3660 
3661 // -------------------------------------------------------------------
3662 
3663 // -------------------------------------------------------------------
3664 
3665 // -------------------------------------------------------------------
3666 
3667 // -------------------------------------------------------------------
3668 
3669 // -------------------------------------------------------------------
3670 
3671 // -------------------------------------------------------------------
3672 
3673 // -------------------------------------------------------------------
3674 
3675 // -------------------------------------------------------------------
3676 
3677 // -------------------------------------------------------------------
3678 
3679 // -------------------------------------------------------------------
3680 
3681 // -------------------------------------------------------------------
3682 
3683 // -------------------------------------------------------------------
3684 
3685 // -------------------------------------------------------------------
3686 
3687 // -------------------------------------------------------------------
3688 
3689 
3690 // @@protoc_insertion_point(namespace_scope)
3691 
3692 }  // namespace xla
3693 
3694 // @@protoc_insertion_point(global_scope)
3695 
3696 #include <google/protobuf/port_undef.inc>
3697 #endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcompiler_2fxla_2fpjrt_2fdistributed_2fprotocol_2eproto
3698