1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: tensorflow/core/framework/device_attributes.proto
3
4 #ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fdevice_5fattributes_2eproto
5 #define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fdevice_5fattributes_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_2fcore_2fframework_2fdevice_5fattributes_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_2fcore_2fframework_2fdevice_5fattributes_2eproto {
43 static const ::uint32_t offsets[];
44 };
45 namespace tensorflow {
46 class DeviceAttributes;
47 struct DeviceAttributesDefaultTypeInternal;
48 extern DeviceAttributesDefaultTypeInternal _DeviceAttributes_default_instance_;
49 class DeviceLocality;
50 struct DeviceLocalityDefaultTypeInternal;
51 extern DeviceLocalityDefaultTypeInternal _DeviceLocality_default_instance_;
52 class InterconnectLink;
53 struct InterconnectLinkDefaultTypeInternal;
54 extern InterconnectLinkDefaultTypeInternal _InterconnectLink_default_instance_;
55 class LocalLinks;
56 struct LocalLinksDefaultTypeInternal;
57 extern LocalLinksDefaultTypeInternal _LocalLinks_default_instance_;
58 } // namespace tensorflow
59 PROTOBUF_NAMESPACE_OPEN
60 template<> ::tensorflow::DeviceAttributes* Arena::CreateMaybeMessage<::tensorflow::DeviceAttributes>(Arena*);
61 template<> ::tensorflow::DeviceLocality* Arena::CreateMaybeMessage<::tensorflow::DeviceLocality>(Arena*);
62 template<> ::tensorflow::InterconnectLink* Arena::CreateMaybeMessage<::tensorflow::InterconnectLink>(Arena*);
63 template<> ::tensorflow::LocalLinks* Arena::CreateMaybeMessage<::tensorflow::LocalLinks>(Arena*);
64 PROTOBUF_NAMESPACE_CLOSE
65 namespace tensorflow {
66
67 // ===================================================================
68
69 class InterconnectLink final :
70 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.InterconnectLink) */ {
71 public:
InterconnectLink()72 inline InterconnectLink() : InterconnectLink(nullptr) {}
73 ~InterconnectLink() override;
74 explicit PROTOBUF_CONSTEXPR InterconnectLink(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
75
76 InterconnectLink(const InterconnectLink& from);
InterconnectLink(InterconnectLink && from)77 InterconnectLink(InterconnectLink&& from) noexcept
78 : InterconnectLink() {
79 *this = ::std::move(from);
80 }
81
82 inline InterconnectLink& operator=(const InterconnectLink& from) {
83 if (this == &from) return *this;
84 CopyFrom(from);
85 return *this;
86 }
87 inline InterconnectLink& operator=(InterconnectLink&& from) noexcept {
88 if (this == &from) return *this;
89 if (GetOwningArena() == from.GetOwningArena()
90 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
91 && GetOwningArena() != nullptr
92 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
93 ) {
94 InternalSwap(&from);
95 } else {
96 CopyFrom(from);
97 }
98 return *this;
99 }
100
default_instance()101 static const InterconnectLink& default_instance() {
102 return *internal_default_instance();
103 }
internal_default_instance()104 static inline const InterconnectLink* internal_default_instance() {
105 return reinterpret_cast<const InterconnectLink*>(
106 &_InterconnectLink_default_instance_);
107 }
108 static constexpr int kIndexInFileMessages =
109 0;
110
swap(InterconnectLink & a,InterconnectLink & b)111 friend void swap(InterconnectLink& a, InterconnectLink& b) {
112 a.Swap(&b);
113 }
Swap(InterconnectLink * other)114 inline void Swap(InterconnectLink* other) {
115 if (other == this) return;
116 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
117 if (GetOwningArena() != nullptr &&
118 GetOwningArena() == other->GetOwningArena()) {
119 #else // PROTOBUF_FORCE_COPY_IN_SWAP
120 if (GetOwningArena() == other->GetOwningArena()) {
121 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
122 InternalSwap(other);
123 } else {
124 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
125 }
126 }
127 void UnsafeArenaSwap(InterconnectLink* other) {
128 if (other == this) return;
129 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
130 InternalSwap(other);
131 }
132
133 // implements Message ----------------------------------------------
134
135 InterconnectLink* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
136 return CreateMaybeMessage<InterconnectLink>(arena);
137 }
138 InterconnectLink* New() const {
139 return New(nullptr);
140 }
141 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
142 void CopyFrom(const InterconnectLink& from);
143 void MergeFrom(const InterconnectLink& from);
144 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
145 bool IsInitialized() const final;
146
147 size_t ByteSizeLong() const final;
148 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
149 ::uint8_t* _InternalSerialize(
150 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
151 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
152
153 private:
154 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
155 void SharedDtor();
156 void SetCachedSize(int size) const;
157 void InternalSwap(InterconnectLink* other);
158
159 private:
160 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
161 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
162 return "tensorflow.InterconnectLink";
163 }
164 protected:
165 explicit InterconnectLink(::PROTOBUF_NAMESPACE_ID::Arena* arena,
166 bool is_message_owned = false);
167 public:
168
169 std::string GetTypeName() const final;
170
171 // nested types ----------------------------------------------------
172
173 // accessors -------------------------------------------------------
174
175 enum : int {
176 kTypeFieldNumber = 2,
177 kDeviceIdFieldNumber = 1,
178 kStrengthFieldNumber = 3,
179 };
180 // string type = 2;
181 void clear_type();
182 const std::string& type() const;
183 template <typename ArgT0 = const std::string&, typename... ArgT>
184 void set_type(ArgT0&& arg0, ArgT... args);
185 std::string* mutable_type();
186 PROTOBUF_NODISCARD std::string* release_type();
187 void set_allocated_type(std::string* type);
188 private:
189 const std::string& _internal_type() const;
190 inline PROTOBUF_ALWAYS_INLINE void _internal_set_type(const std::string& value);
191 std::string* _internal_mutable_type();
192 public:
193
194 // int32 device_id = 1;
195 void clear_device_id();
196 ::int32_t device_id() const;
197 void set_device_id(::int32_t value);
198 private:
199 ::int32_t _internal_device_id() const;
200 void _internal_set_device_id(::int32_t value);
201 public:
202
203 // int32 strength = 3;
204 void clear_strength();
205 ::int32_t strength() const;
206 void set_strength(::int32_t value);
207 private:
208 ::int32_t _internal_strength() const;
209 void _internal_set_strength(::int32_t value);
210 public:
211
212 // @@protoc_insertion_point(class_scope:tensorflow.InterconnectLink)
213 private:
214 class _Internal;
215
216 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
217 typedef void InternalArenaConstructable_;
218 typedef void DestructorSkippable_;
219 struct Impl_ {
220 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_;
221 ::int32_t device_id_;
222 ::int32_t strength_;
223 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
224 };
225 union { Impl_ _impl_; };
226 friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fdevice_5fattributes_2eproto;
227 };
228 // -------------------------------------------------------------------
229
230 class LocalLinks final :
231 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.LocalLinks) */ {
232 public:
LocalLinks()233 inline LocalLinks() : LocalLinks(nullptr) {}
234 ~LocalLinks() override;
235 explicit PROTOBUF_CONSTEXPR LocalLinks(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
236
237 LocalLinks(const LocalLinks& from);
LocalLinks(LocalLinks && from)238 LocalLinks(LocalLinks&& from) noexcept
239 : LocalLinks() {
240 *this = ::std::move(from);
241 }
242
243 inline LocalLinks& operator=(const LocalLinks& from) {
244 if (this == &from) return *this;
245 CopyFrom(from);
246 return *this;
247 }
248 inline LocalLinks& operator=(LocalLinks&& from) noexcept {
249 if (this == &from) return *this;
250 if (GetOwningArena() == from.GetOwningArena()
251 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
252 && GetOwningArena() != nullptr
253 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
254 ) {
255 InternalSwap(&from);
256 } else {
257 CopyFrom(from);
258 }
259 return *this;
260 }
261
default_instance()262 static const LocalLinks& default_instance() {
263 return *internal_default_instance();
264 }
internal_default_instance()265 static inline const LocalLinks* internal_default_instance() {
266 return reinterpret_cast<const LocalLinks*>(
267 &_LocalLinks_default_instance_);
268 }
269 static constexpr int kIndexInFileMessages =
270 1;
271
swap(LocalLinks & a,LocalLinks & b)272 friend void swap(LocalLinks& a, LocalLinks& b) {
273 a.Swap(&b);
274 }
Swap(LocalLinks * other)275 inline void Swap(LocalLinks* other) {
276 if (other == this) return;
277 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
278 if (GetOwningArena() != nullptr &&
279 GetOwningArena() == other->GetOwningArena()) {
280 #else // PROTOBUF_FORCE_COPY_IN_SWAP
281 if (GetOwningArena() == other->GetOwningArena()) {
282 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
283 InternalSwap(other);
284 } else {
285 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
286 }
287 }
288 void UnsafeArenaSwap(LocalLinks* other) {
289 if (other == this) return;
290 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
291 InternalSwap(other);
292 }
293
294 // implements Message ----------------------------------------------
295
296 LocalLinks* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
297 return CreateMaybeMessage<LocalLinks>(arena);
298 }
299 LocalLinks* New() const {
300 return New(nullptr);
301 }
302 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
303 void CopyFrom(const LocalLinks& from);
304 void MergeFrom(const LocalLinks& from);
305 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
306 bool IsInitialized() const final;
307
308 size_t ByteSizeLong() const final;
309 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
310 ::uint8_t* _InternalSerialize(
311 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
312 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
313
314 private:
315 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
316 void SharedDtor();
317 void SetCachedSize(int size) const;
318 void InternalSwap(LocalLinks* other);
319
320 private:
321 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
322 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
323 return "tensorflow.LocalLinks";
324 }
325 protected:
326 explicit LocalLinks(::PROTOBUF_NAMESPACE_ID::Arena* arena,
327 bool is_message_owned = false);
328 public:
329
330 std::string GetTypeName() const final;
331
332 // nested types ----------------------------------------------------
333
334 // accessors -------------------------------------------------------
335
336 enum : int {
337 kLinkFieldNumber = 1,
338 };
339 // repeated .tensorflow.InterconnectLink link = 1;
340 int link_size() const;
341 private:
342 int _internal_link_size() const;
343 public:
344 void clear_link();
345 ::tensorflow::InterconnectLink* mutable_link(int index);
346 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::InterconnectLink >*
347 mutable_link();
348 private:
349 const ::tensorflow::InterconnectLink& _internal_link(int index) const;
350 ::tensorflow::InterconnectLink* _internal_add_link();
351 public:
352 const ::tensorflow::InterconnectLink& link(int index) const;
353 ::tensorflow::InterconnectLink* add_link();
354 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::InterconnectLink >&
355 link() const;
356
357 // @@protoc_insertion_point(class_scope:tensorflow.LocalLinks)
358 private:
359 class _Internal;
360
361 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
362 typedef void InternalArenaConstructable_;
363 typedef void DestructorSkippable_;
364 struct Impl_ {
365 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::InterconnectLink > link_;
366 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
367 };
368 union { Impl_ _impl_; };
369 friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fdevice_5fattributes_2eproto;
370 };
371 // -------------------------------------------------------------------
372
373 class DeviceLocality final :
374 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.DeviceLocality) */ {
375 public:
DeviceLocality()376 inline DeviceLocality() : DeviceLocality(nullptr) {}
377 ~DeviceLocality() override;
378 explicit PROTOBUF_CONSTEXPR DeviceLocality(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
379
380 DeviceLocality(const DeviceLocality& from);
DeviceLocality(DeviceLocality && from)381 DeviceLocality(DeviceLocality&& from) noexcept
382 : DeviceLocality() {
383 *this = ::std::move(from);
384 }
385
386 inline DeviceLocality& operator=(const DeviceLocality& from) {
387 if (this == &from) return *this;
388 CopyFrom(from);
389 return *this;
390 }
391 inline DeviceLocality& operator=(DeviceLocality&& from) noexcept {
392 if (this == &from) return *this;
393 if (GetOwningArena() == from.GetOwningArena()
394 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
395 && GetOwningArena() != nullptr
396 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
397 ) {
398 InternalSwap(&from);
399 } else {
400 CopyFrom(from);
401 }
402 return *this;
403 }
404
default_instance()405 static const DeviceLocality& default_instance() {
406 return *internal_default_instance();
407 }
internal_default_instance()408 static inline const DeviceLocality* internal_default_instance() {
409 return reinterpret_cast<const DeviceLocality*>(
410 &_DeviceLocality_default_instance_);
411 }
412 static constexpr int kIndexInFileMessages =
413 2;
414
swap(DeviceLocality & a,DeviceLocality & b)415 friend void swap(DeviceLocality& a, DeviceLocality& b) {
416 a.Swap(&b);
417 }
Swap(DeviceLocality * other)418 inline void Swap(DeviceLocality* other) {
419 if (other == this) return;
420 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
421 if (GetOwningArena() != nullptr &&
422 GetOwningArena() == other->GetOwningArena()) {
423 #else // PROTOBUF_FORCE_COPY_IN_SWAP
424 if (GetOwningArena() == other->GetOwningArena()) {
425 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
426 InternalSwap(other);
427 } else {
428 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
429 }
430 }
431 void UnsafeArenaSwap(DeviceLocality* other) {
432 if (other == this) return;
433 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
434 InternalSwap(other);
435 }
436
437 // implements Message ----------------------------------------------
438
439 DeviceLocality* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
440 return CreateMaybeMessage<DeviceLocality>(arena);
441 }
442 DeviceLocality* New() const {
443 return New(nullptr);
444 }
445 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
446 void CopyFrom(const DeviceLocality& from);
447 void MergeFrom(const DeviceLocality& from);
448 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
449 bool IsInitialized() const final;
450
451 size_t ByteSizeLong() const final;
452 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
453 ::uint8_t* _InternalSerialize(
454 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
455 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
456
457 private:
458 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
459 void SharedDtor();
460 void SetCachedSize(int size) const;
461 void InternalSwap(DeviceLocality* other);
462
463 private:
464 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
465 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
466 return "tensorflow.DeviceLocality";
467 }
468 protected:
469 explicit DeviceLocality(::PROTOBUF_NAMESPACE_ID::Arena* arena,
470 bool is_message_owned = false);
471 public:
472
473 std::string GetTypeName() const final;
474
475 // nested types ----------------------------------------------------
476
477 // accessors -------------------------------------------------------
478
479 enum : int {
480 kLinksFieldNumber = 3,
481 kBusIdFieldNumber = 1,
482 kNumaNodeFieldNumber = 2,
483 };
484 // .tensorflow.LocalLinks links = 3;
485 bool has_links() const;
486 private:
487 bool _internal_has_links() const;
488 public:
489 void clear_links();
490 const ::tensorflow::LocalLinks& links() const;
491 PROTOBUF_NODISCARD ::tensorflow::LocalLinks* release_links();
492 ::tensorflow::LocalLinks* mutable_links();
493 void set_allocated_links(::tensorflow::LocalLinks* links);
494 private:
495 const ::tensorflow::LocalLinks& _internal_links() const;
496 ::tensorflow::LocalLinks* _internal_mutable_links();
497 public:
498 void unsafe_arena_set_allocated_links(
499 ::tensorflow::LocalLinks* links);
500 ::tensorflow::LocalLinks* unsafe_arena_release_links();
501
502 // int32 bus_id = 1;
503 void clear_bus_id();
504 ::int32_t bus_id() const;
505 void set_bus_id(::int32_t value);
506 private:
507 ::int32_t _internal_bus_id() const;
508 void _internal_set_bus_id(::int32_t value);
509 public:
510
511 // int32 numa_node = 2;
512 void clear_numa_node();
513 ::int32_t numa_node() const;
514 void set_numa_node(::int32_t value);
515 private:
516 ::int32_t _internal_numa_node() const;
517 void _internal_set_numa_node(::int32_t value);
518 public:
519
520 // @@protoc_insertion_point(class_scope:tensorflow.DeviceLocality)
521 private:
522 class _Internal;
523
524 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
525 typedef void InternalArenaConstructable_;
526 typedef void DestructorSkippable_;
527 struct Impl_ {
528 ::tensorflow::LocalLinks* links_;
529 ::int32_t bus_id_;
530 ::int32_t numa_node_;
531 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
532 };
533 union { Impl_ _impl_; };
534 friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fdevice_5fattributes_2eproto;
535 };
536 // -------------------------------------------------------------------
537
538 class DeviceAttributes final :
539 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.DeviceAttributes) */ {
540 public:
DeviceAttributes()541 inline DeviceAttributes() : DeviceAttributes(nullptr) {}
542 ~DeviceAttributes() override;
543 explicit PROTOBUF_CONSTEXPR DeviceAttributes(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
544
545 DeviceAttributes(const DeviceAttributes& from);
DeviceAttributes(DeviceAttributes && from)546 DeviceAttributes(DeviceAttributes&& from) noexcept
547 : DeviceAttributes() {
548 *this = ::std::move(from);
549 }
550
551 inline DeviceAttributes& operator=(const DeviceAttributes& from) {
552 if (this == &from) return *this;
553 CopyFrom(from);
554 return *this;
555 }
556 inline DeviceAttributes& operator=(DeviceAttributes&& from) noexcept {
557 if (this == &from) return *this;
558 if (GetOwningArena() == from.GetOwningArena()
559 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
560 && GetOwningArena() != nullptr
561 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
562 ) {
563 InternalSwap(&from);
564 } else {
565 CopyFrom(from);
566 }
567 return *this;
568 }
569
default_instance()570 static const DeviceAttributes& default_instance() {
571 return *internal_default_instance();
572 }
internal_default_instance()573 static inline const DeviceAttributes* internal_default_instance() {
574 return reinterpret_cast<const DeviceAttributes*>(
575 &_DeviceAttributes_default_instance_);
576 }
577 static constexpr int kIndexInFileMessages =
578 3;
579
swap(DeviceAttributes & a,DeviceAttributes & b)580 friend void swap(DeviceAttributes& a, DeviceAttributes& b) {
581 a.Swap(&b);
582 }
Swap(DeviceAttributes * other)583 inline void Swap(DeviceAttributes* other) {
584 if (other == this) return;
585 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
586 if (GetOwningArena() != nullptr &&
587 GetOwningArena() == other->GetOwningArena()) {
588 #else // PROTOBUF_FORCE_COPY_IN_SWAP
589 if (GetOwningArena() == other->GetOwningArena()) {
590 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
591 InternalSwap(other);
592 } else {
593 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
594 }
595 }
596 void UnsafeArenaSwap(DeviceAttributes* other) {
597 if (other == this) return;
598 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
599 InternalSwap(other);
600 }
601
602 // implements Message ----------------------------------------------
603
604 DeviceAttributes* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
605 return CreateMaybeMessage<DeviceAttributes>(arena);
606 }
607 DeviceAttributes* New() const {
608 return New(nullptr);
609 }
610 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
611 void CopyFrom(const DeviceAttributes& from);
612 void MergeFrom(const DeviceAttributes& from);
613 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
614 bool IsInitialized() const final;
615
616 size_t ByteSizeLong() const final;
617 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
618 ::uint8_t* _InternalSerialize(
619 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
620 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
621
622 private:
623 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
624 void SharedDtor();
625 void SetCachedSize(int size) const;
626 void InternalSwap(DeviceAttributes* other);
627
628 private:
629 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
630 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
631 return "tensorflow.DeviceAttributes";
632 }
633 protected:
634 explicit DeviceAttributes(::PROTOBUF_NAMESPACE_ID::Arena* arena,
635 bool is_message_owned = false);
636 public:
637
638 std::string GetTypeName() const final;
639
640 // nested types ----------------------------------------------------
641
642 // accessors -------------------------------------------------------
643
644 enum : int {
645 kNameFieldNumber = 1,
646 kDeviceTypeFieldNumber = 2,
647 kPhysicalDeviceDescFieldNumber = 7,
648 kLocalityFieldNumber = 5,
649 kMemoryLimitFieldNumber = 4,
650 kIncarnationFieldNumber = 6,
651 kXlaGlobalIdFieldNumber = 8,
652 };
653 // string name = 1;
654 void clear_name();
655 const std::string& name() const;
656 template <typename ArgT0 = const std::string&, typename... ArgT>
657 void set_name(ArgT0&& arg0, ArgT... args);
658 std::string* mutable_name();
659 PROTOBUF_NODISCARD std::string* release_name();
660 void set_allocated_name(std::string* name);
661 private:
662 const std::string& _internal_name() const;
663 inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
664 std::string* _internal_mutable_name();
665 public:
666
667 // string device_type = 2;
668 void clear_device_type();
669 const std::string& device_type() const;
670 template <typename ArgT0 = const std::string&, typename... ArgT>
671 void set_device_type(ArgT0&& arg0, ArgT... args);
672 std::string* mutable_device_type();
673 PROTOBUF_NODISCARD std::string* release_device_type();
674 void set_allocated_device_type(std::string* device_type);
675 private:
676 const std::string& _internal_device_type() const;
677 inline PROTOBUF_ALWAYS_INLINE void _internal_set_device_type(const std::string& value);
678 std::string* _internal_mutable_device_type();
679 public:
680
681 // string physical_device_desc = 7;
682 void clear_physical_device_desc();
683 const std::string& physical_device_desc() const;
684 template <typename ArgT0 = const std::string&, typename... ArgT>
685 void set_physical_device_desc(ArgT0&& arg0, ArgT... args);
686 std::string* mutable_physical_device_desc();
687 PROTOBUF_NODISCARD std::string* release_physical_device_desc();
688 void set_allocated_physical_device_desc(std::string* physical_device_desc);
689 private:
690 const std::string& _internal_physical_device_desc() const;
691 inline PROTOBUF_ALWAYS_INLINE void _internal_set_physical_device_desc(const std::string& value);
692 std::string* _internal_mutable_physical_device_desc();
693 public:
694
695 // .tensorflow.DeviceLocality locality = 5;
696 bool has_locality() const;
697 private:
698 bool _internal_has_locality() const;
699 public:
700 void clear_locality();
701 const ::tensorflow::DeviceLocality& locality() const;
702 PROTOBUF_NODISCARD ::tensorflow::DeviceLocality* release_locality();
703 ::tensorflow::DeviceLocality* mutable_locality();
704 void set_allocated_locality(::tensorflow::DeviceLocality* locality);
705 private:
706 const ::tensorflow::DeviceLocality& _internal_locality() const;
707 ::tensorflow::DeviceLocality* _internal_mutable_locality();
708 public:
709 void unsafe_arena_set_allocated_locality(
710 ::tensorflow::DeviceLocality* locality);
711 ::tensorflow::DeviceLocality* unsafe_arena_release_locality();
712
713 // int64 memory_limit = 4;
714 void clear_memory_limit();
715 ::int64_t memory_limit() const;
716 void set_memory_limit(::int64_t value);
717 private:
718 ::int64_t _internal_memory_limit() const;
719 void _internal_set_memory_limit(::int64_t value);
720 public:
721
722 // fixed64 incarnation = 6;
723 void clear_incarnation();
724 ::uint64_t incarnation() const;
725 void set_incarnation(::uint64_t value);
726 private:
727 ::uint64_t _internal_incarnation() const;
728 void _internal_set_incarnation(::uint64_t value);
729 public:
730
731 // int64 xla_global_id = 8;
732 void clear_xla_global_id();
733 ::int64_t xla_global_id() const;
734 void set_xla_global_id(::int64_t value);
735 private:
736 ::int64_t _internal_xla_global_id() const;
737 void _internal_set_xla_global_id(::int64_t value);
738 public:
739
740 // @@protoc_insertion_point(class_scope:tensorflow.DeviceAttributes)
741 private:
742 class _Internal;
743
744 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
745 typedef void InternalArenaConstructable_;
746 typedef void DestructorSkippable_;
747 struct Impl_ {
748 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
749 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_type_;
750 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr physical_device_desc_;
751 ::tensorflow::DeviceLocality* locality_;
752 ::int64_t memory_limit_;
753 ::uint64_t incarnation_;
754 ::int64_t xla_global_id_;
755 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
756 };
757 union { Impl_ _impl_; };
758 friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fdevice_5fattributes_2eproto;
759 };
760 // ===================================================================
761
762
763 // ===================================================================
764
765 #ifdef __GNUC__
766 #pragma GCC diagnostic push
767 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
768 #endif // __GNUC__
769 // InterconnectLink
770
771 // int32 device_id = 1;
clear_device_id()772 inline void InterconnectLink::clear_device_id() {
773 _impl_.device_id_ = 0;
774 }
_internal_device_id()775 inline ::int32_t InterconnectLink::_internal_device_id() const {
776 return _impl_.device_id_;
777 }
device_id()778 inline ::int32_t InterconnectLink::device_id() const {
779 // @@protoc_insertion_point(field_get:tensorflow.InterconnectLink.device_id)
780 return _internal_device_id();
781 }
_internal_set_device_id(::int32_t value)782 inline void InterconnectLink::_internal_set_device_id(::int32_t value) {
783
784 _impl_.device_id_ = value;
785 }
set_device_id(::int32_t value)786 inline void InterconnectLink::set_device_id(::int32_t value) {
787 _internal_set_device_id(value);
788 // @@protoc_insertion_point(field_set:tensorflow.InterconnectLink.device_id)
789 }
790
791 // string type = 2;
clear_type()792 inline void InterconnectLink::clear_type() {
793 _impl_.type_.ClearToEmpty();
794 }
type()795 inline const std::string& InterconnectLink::type() const {
796 // @@protoc_insertion_point(field_get:tensorflow.InterconnectLink.type)
797 return _internal_type();
798 }
799 template <typename ArgT0, typename... ArgT>
800 inline PROTOBUF_ALWAYS_INLINE
set_type(ArgT0 && arg0,ArgT...args)801 void InterconnectLink::set_type(ArgT0&& arg0, ArgT... args) {
802
803 _impl_.type_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
804 // @@protoc_insertion_point(field_set:tensorflow.InterconnectLink.type)
805 }
mutable_type()806 inline std::string* InterconnectLink::mutable_type() {
807 std::string* _s = _internal_mutable_type();
808 // @@protoc_insertion_point(field_mutable:tensorflow.InterconnectLink.type)
809 return _s;
810 }
_internal_type()811 inline const std::string& InterconnectLink::_internal_type() const {
812 return _impl_.type_.Get();
813 }
_internal_set_type(const std::string & value)814 inline void InterconnectLink::_internal_set_type(const std::string& value) {
815
816 _impl_.type_.Set(value, GetArenaForAllocation());
817 }
_internal_mutable_type()818 inline std::string* InterconnectLink::_internal_mutable_type() {
819
820 return _impl_.type_.Mutable(GetArenaForAllocation());
821 }
release_type()822 inline std::string* InterconnectLink::release_type() {
823 // @@protoc_insertion_point(field_release:tensorflow.InterconnectLink.type)
824 return _impl_.type_.Release();
825 }
set_allocated_type(std::string * type)826 inline void InterconnectLink::set_allocated_type(std::string* type) {
827 _impl_.type_.SetAllocated(type, GetArenaForAllocation());
828 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
829 if (_impl_.type_.IsDefault()) {
830 _impl_.type_.Set("", GetArenaForAllocation());
831 }
832 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
833 // @@protoc_insertion_point(field_set_allocated:tensorflow.InterconnectLink.type)
834 }
835
836 // int32 strength = 3;
clear_strength()837 inline void InterconnectLink::clear_strength() {
838 _impl_.strength_ = 0;
839 }
_internal_strength()840 inline ::int32_t InterconnectLink::_internal_strength() const {
841 return _impl_.strength_;
842 }
strength()843 inline ::int32_t InterconnectLink::strength() const {
844 // @@protoc_insertion_point(field_get:tensorflow.InterconnectLink.strength)
845 return _internal_strength();
846 }
_internal_set_strength(::int32_t value)847 inline void InterconnectLink::_internal_set_strength(::int32_t value) {
848
849 _impl_.strength_ = value;
850 }
set_strength(::int32_t value)851 inline void InterconnectLink::set_strength(::int32_t value) {
852 _internal_set_strength(value);
853 // @@protoc_insertion_point(field_set:tensorflow.InterconnectLink.strength)
854 }
855
856 // -------------------------------------------------------------------
857
858 // LocalLinks
859
860 // repeated .tensorflow.InterconnectLink link = 1;
_internal_link_size()861 inline int LocalLinks::_internal_link_size() const {
862 return _impl_.link_.size();
863 }
link_size()864 inline int LocalLinks::link_size() const {
865 return _internal_link_size();
866 }
clear_link()867 inline void LocalLinks::clear_link() {
868 _impl_.link_.Clear();
869 }
mutable_link(int index)870 inline ::tensorflow::InterconnectLink* LocalLinks::mutable_link(int index) {
871 // @@protoc_insertion_point(field_mutable:tensorflow.LocalLinks.link)
872 return _impl_.link_.Mutable(index);
873 }
874 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::InterconnectLink >*
mutable_link()875 LocalLinks::mutable_link() {
876 // @@protoc_insertion_point(field_mutable_list:tensorflow.LocalLinks.link)
877 return &_impl_.link_;
878 }
_internal_link(int index)879 inline const ::tensorflow::InterconnectLink& LocalLinks::_internal_link(int index) const {
880 return _impl_.link_.Get(index);
881 }
link(int index)882 inline const ::tensorflow::InterconnectLink& LocalLinks::link(int index) const {
883 // @@protoc_insertion_point(field_get:tensorflow.LocalLinks.link)
884 return _internal_link(index);
885 }
_internal_add_link()886 inline ::tensorflow::InterconnectLink* LocalLinks::_internal_add_link() {
887 return _impl_.link_.Add();
888 }
add_link()889 inline ::tensorflow::InterconnectLink* LocalLinks::add_link() {
890 ::tensorflow::InterconnectLink* _add = _internal_add_link();
891 // @@protoc_insertion_point(field_add:tensorflow.LocalLinks.link)
892 return _add;
893 }
894 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::InterconnectLink >&
link()895 LocalLinks::link() const {
896 // @@protoc_insertion_point(field_list:tensorflow.LocalLinks.link)
897 return _impl_.link_;
898 }
899
900 // -------------------------------------------------------------------
901
902 // DeviceLocality
903
904 // int32 bus_id = 1;
clear_bus_id()905 inline void DeviceLocality::clear_bus_id() {
906 _impl_.bus_id_ = 0;
907 }
_internal_bus_id()908 inline ::int32_t DeviceLocality::_internal_bus_id() const {
909 return _impl_.bus_id_;
910 }
bus_id()911 inline ::int32_t DeviceLocality::bus_id() const {
912 // @@protoc_insertion_point(field_get:tensorflow.DeviceLocality.bus_id)
913 return _internal_bus_id();
914 }
_internal_set_bus_id(::int32_t value)915 inline void DeviceLocality::_internal_set_bus_id(::int32_t value) {
916
917 _impl_.bus_id_ = value;
918 }
set_bus_id(::int32_t value)919 inline void DeviceLocality::set_bus_id(::int32_t value) {
920 _internal_set_bus_id(value);
921 // @@protoc_insertion_point(field_set:tensorflow.DeviceLocality.bus_id)
922 }
923
924 // int32 numa_node = 2;
clear_numa_node()925 inline void DeviceLocality::clear_numa_node() {
926 _impl_.numa_node_ = 0;
927 }
_internal_numa_node()928 inline ::int32_t DeviceLocality::_internal_numa_node() const {
929 return _impl_.numa_node_;
930 }
numa_node()931 inline ::int32_t DeviceLocality::numa_node() const {
932 // @@protoc_insertion_point(field_get:tensorflow.DeviceLocality.numa_node)
933 return _internal_numa_node();
934 }
_internal_set_numa_node(::int32_t value)935 inline void DeviceLocality::_internal_set_numa_node(::int32_t value) {
936
937 _impl_.numa_node_ = value;
938 }
set_numa_node(::int32_t value)939 inline void DeviceLocality::set_numa_node(::int32_t value) {
940 _internal_set_numa_node(value);
941 // @@protoc_insertion_point(field_set:tensorflow.DeviceLocality.numa_node)
942 }
943
944 // .tensorflow.LocalLinks links = 3;
_internal_has_links()945 inline bool DeviceLocality::_internal_has_links() const {
946 return this != internal_default_instance() && _impl_.links_ != nullptr;
947 }
has_links()948 inline bool DeviceLocality::has_links() const {
949 return _internal_has_links();
950 }
clear_links()951 inline void DeviceLocality::clear_links() {
952 if (GetArenaForAllocation() == nullptr && _impl_.links_ != nullptr) {
953 delete _impl_.links_;
954 }
955 _impl_.links_ = nullptr;
956 }
_internal_links()957 inline const ::tensorflow::LocalLinks& DeviceLocality::_internal_links() const {
958 const ::tensorflow::LocalLinks* p = _impl_.links_;
959 return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::LocalLinks&>(
960 ::tensorflow::_LocalLinks_default_instance_);
961 }
links()962 inline const ::tensorflow::LocalLinks& DeviceLocality::links() const {
963 // @@protoc_insertion_point(field_get:tensorflow.DeviceLocality.links)
964 return _internal_links();
965 }
unsafe_arena_set_allocated_links(::tensorflow::LocalLinks * links)966 inline void DeviceLocality::unsafe_arena_set_allocated_links(
967 ::tensorflow::LocalLinks* links) {
968 if (GetArenaForAllocation() == nullptr) {
969 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.links_);
970 }
971 _impl_.links_ = links;
972 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.DeviceLocality.links)
973 }
release_links()974 inline ::tensorflow::LocalLinks* DeviceLocality::release_links() {
975
976 ::tensorflow::LocalLinks* temp = _impl_.links_;
977 _impl_.links_ = nullptr;
978 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
979 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
980 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
981 if (GetArenaForAllocation() == nullptr) { delete old; }
982 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
983 if (GetArenaForAllocation() != nullptr) {
984 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
985 }
986 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
987 return temp;
988 }
unsafe_arena_release_links()989 inline ::tensorflow::LocalLinks* DeviceLocality::unsafe_arena_release_links() {
990 // @@protoc_insertion_point(field_release:tensorflow.DeviceLocality.links)
991
992 ::tensorflow::LocalLinks* temp = _impl_.links_;
993 _impl_.links_ = nullptr;
994 return temp;
995 }
_internal_mutable_links()996 inline ::tensorflow::LocalLinks* DeviceLocality::_internal_mutable_links() {
997
998 if (_impl_.links_ == nullptr) {
999 auto* p = CreateMaybeMessage<::tensorflow::LocalLinks>(GetArenaForAllocation());
1000 _impl_.links_ = p;
1001 }
1002 return _impl_.links_;
1003 }
mutable_links()1004 inline ::tensorflow::LocalLinks* DeviceLocality::mutable_links() {
1005 ::tensorflow::LocalLinks* _msg = _internal_mutable_links();
1006 // @@protoc_insertion_point(field_mutable:tensorflow.DeviceLocality.links)
1007 return _msg;
1008 }
set_allocated_links(::tensorflow::LocalLinks * links)1009 inline void DeviceLocality::set_allocated_links(::tensorflow::LocalLinks* links) {
1010 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
1011 if (message_arena == nullptr) {
1012 delete _impl_.links_;
1013 }
1014 if (links) {
1015 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
1016 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(links);
1017 if (message_arena != submessage_arena) {
1018 links = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
1019 message_arena, links, submessage_arena);
1020 }
1021
1022 } else {
1023
1024 }
1025 _impl_.links_ = links;
1026 // @@protoc_insertion_point(field_set_allocated:tensorflow.DeviceLocality.links)
1027 }
1028
1029 // -------------------------------------------------------------------
1030
1031 // DeviceAttributes
1032
1033 // string name = 1;
clear_name()1034 inline void DeviceAttributes::clear_name() {
1035 _impl_.name_.ClearToEmpty();
1036 }
name()1037 inline const std::string& DeviceAttributes::name() const {
1038 // @@protoc_insertion_point(field_get:tensorflow.DeviceAttributes.name)
1039 return _internal_name();
1040 }
1041 template <typename ArgT0, typename... ArgT>
1042 inline PROTOBUF_ALWAYS_INLINE
set_name(ArgT0 && arg0,ArgT...args)1043 void DeviceAttributes::set_name(ArgT0&& arg0, ArgT... args) {
1044
1045 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1046 // @@protoc_insertion_point(field_set:tensorflow.DeviceAttributes.name)
1047 }
mutable_name()1048 inline std::string* DeviceAttributes::mutable_name() {
1049 std::string* _s = _internal_mutable_name();
1050 // @@protoc_insertion_point(field_mutable:tensorflow.DeviceAttributes.name)
1051 return _s;
1052 }
_internal_name()1053 inline const std::string& DeviceAttributes::_internal_name() const {
1054 return _impl_.name_.Get();
1055 }
_internal_set_name(const std::string & value)1056 inline void DeviceAttributes::_internal_set_name(const std::string& value) {
1057
1058 _impl_.name_.Set(value, GetArenaForAllocation());
1059 }
_internal_mutable_name()1060 inline std::string* DeviceAttributes::_internal_mutable_name() {
1061
1062 return _impl_.name_.Mutable(GetArenaForAllocation());
1063 }
release_name()1064 inline std::string* DeviceAttributes::release_name() {
1065 // @@protoc_insertion_point(field_release:tensorflow.DeviceAttributes.name)
1066 return _impl_.name_.Release();
1067 }
set_allocated_name(std::string * name)1068 inline void DeviceAttributes::set_allocated_name(std::string* name) {
1069 _impl_.name_.SetAllocated(name, GetArenaForAllocation());
1070 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1071 if (_impl_.name_.IsDefault()) {
1072 _impl_.name_.Set("", GetArenaForAllocation());
1073 }
1074 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1075 // @@protoc_insertion_point(field_set_allocated:tensorflow.DeviceAttributes.name)
1076 }
1077
1078 // string device_type = 2;
clear_device_type()1079 inline void DeviceAttributes::clear_device_type() {
1080 _impl_.device_type_.ClearToEmpty();
1081 }
device_type()1082 inline const std::string& DeviceAttributes::device_type() const {
1083 // @@protoc_insertion_point(field_get:tensorflow.DeviceAttributes.device_type)
1084 return _internal_device_type();
1085 }
1086 template <typename ArgT0, typename... ArgT>
1087 inline PROTOBUF_ALWAYS_INLINE
set_device_type(ArgT0 && arg0,ArgT...args)1088 void DeviceAttributes::set_device_type(ArgT0&& arg0, ArgT... args) {
1089
1090 _impl_.device_type_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1091 // @@protoc_insertion_point(field_set:tensorflow.DeviceAttributes.device_type)
1092 }
mutable_device_type()1093 inline std::string* DeviceAttributes::mutable_device_type() {
1094 std::string* _s = _internal_mutable_device_type();
1095 // @@protoc_insertion_point(field_mutable:tensorflow.DeviceAttributes.device_type)
1096 return _s;
1097 }
_internal_device_type()1098 inline const std::string& DeviceAttributes::_internal_device_type() const {
1099 return _impl_.device_type_.Get();
1100 }
_internal_set_device_type(const std::string & value)1101 inline void DeviceAttributes::_internal_set_device_type(const std::string& value) {
1102
1103 _impl_.device_type_.Set(value, GetArenaForAllocation());
1104 }
_internal_mutable_device_type()1105 inline std::string* DeviceAttributes::_internal_mutable_device_type() {
1106
1107 return _impl_.device_type_.Mutable(GetArenaForAllocation());
1108 }
release_device_type()1109 inline std::string* DeviceAttributes::release_device_type() {
1110 // @@protoc_insertion_point(field_release:tensorflow.DeviceAttributes.device_type)
1111 return _impl_.device_type_.Release();
1112 }
set_allocated_device_type(std::string * device_type)1113 inline void DeviceAttributes::set_allocated_device_type(std::string* device_type) {
1114 _impl_.device_type_.SetAllocated(device_type, GetArenaForAllocation());
1115 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1116 if (_impl_.device_type_.IsDefault()) {
1117 _impl_.device_type_.Set("", GetArenaForAllocation());
1118 }
1119 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1120 // @@protoc_insertion_point(field_set_allocated:tensorflow.DeviceAttributes.device_type)
1121 }
1122
1123 // int64 memory_limit = 4;
clear_memory_limit()1124 inline void DeviceAttributes::clear_memory_limit() {
1125 _impl_.memory_limit_ = ::int64_t{0};
1126 }
_internal_memory_limit()1127 inline ::int64_t DeviceAttributes::_internal_memory_limit() const {
1128 return _impl_.memory_limit_;
1129 }
memory_limit()1130 inline ::int64_t DeviceAttributes::memory_limit() const {
1131 // @@protoc_insertion_point(field_get:tensorflow.DeviceAttributes.memory_limit)
1132 return _internal_memory_limit();
1133 }
_internal_set_memory_limit(::int64_t value)1134 inline void DeviceAttributes::_internal_set_memory_limit(::int64_t value) {
1135
1136 _impl_.memory_limit_ = value;
1137 }
set_memory_limit(::int64_t value)1138 inline void DeviceAttributes::set_memory_limit(::int64_t value) {
1139 _internal_set_memory_limit(value);
1140 // @@protoc_insertion_point(field_set:tensorflow.DeviceAttributes.memory_limit)
1141 }
1142
1143 // .tensorflow.DeviceLocality locality = 5;
_internal_has_locality()1144 inline bool DeviceAttributes::_internal_has_locality() const {
1145 return this != internal_default_instance() && _impl_.locality_ != nullptr;
1146 }
has_locality()1147 inline bool DeviceAttributes::has_locality() const {
1148 return _internal_has_locality();
1149 }
clear_locality()1150 inline void DeviceAttributes::clear_locality() {
1151 if (GetArenaForAllocation() == nullptr && _impl_.locality_ != nullptr) {
1152 delete _impl_.locality_;
1153 }
1154 _impl_.locality_ = nullptr;
1155 }
_internal_locality()1156 inline const ::tensorflow::DeviceLocality& DeviceAttributes::_internal_locality() const {
1157 const ::tensorflow::DeviceLocality* p = _impl_.locality_;
1158 return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::DeviceLocality&>(
1159 ::tensorflow::_DeviceLocality_default_instance_);
1160 }
locality()1161 inline const ::tensorflow::DeviceLocality& DeviceAttributes::locality() const {
1162 // @@protoc_insertion_point(field_get:tensorflow.DeviceAttributes.locality)
1163 return _internal_locality();
1164 }
unsafe_arena_set_allocated_locality(::tensorflow::DeviceLocality * locality)1165 inline void DeviceAttributes::unsafe_arena_set_allocated_locality(
1166 ::tensorflow::DeviceLocality* locality) {
1167 if (GetArenaForAllocation() == nullptr) {
1168 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.locality_);
1169 }
1170 _impl_.locality_ = locality;
1171 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.DeviceAttributes.locality)
1172 }
release_locality()1173 inline ::tensorflow::DeviceLocality* DeviceAttributes::release_locality() {
1174
1175 ::tensorflow::DeviceLocality* temp = _impl_.locality_;
1176 _impl_.locality_ = nullptr;
1177 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
1178 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
1179 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1180 if (GetArenaForAllocation() == nullptr) { delete old; }
1181 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
1182 if (GetArenaForAllocation() != nullptr) {
1183 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1184 }
1185 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
1186 return temp;
1187 }
unsafe_arena_release_locality()1188 inline ::tensorflow::DeviceLocality* DeviceAttributes::unsafe_arena_release_locality() {
1189 // @@protoc_insertion_point(field_release:tensorflow.DeviceAttributes.locality)
1190
1191 ::tensorflow::DeviceLocality* temp = _impl_.locality_;
1192 _impl_.locality_ = nullptr;
1193 return temp;
1194 }
_internal_mutable_locality()1195 inline ::tensorflow::DeviceLocality* DeviceAttributes::_internal_mutable_locality() {
1196
1197 if (_impl_.locality_ == nullptr) {
1198 auto* p = CreateMaybeMessage<::tensorflow::DeviceLocality>(GetArenaForAllocation());
1199 _impl_.locality_ = p;
1200 }
1201 return _impl_.locality_;
1202 }
mutable_locality()1203 inline ::tensorflow::DeviceLocality* DeviceAttributes::mutable_locality() {
1204 ::tensorflow::DeviceLocality* _msg = _internal_mutable_locality();
1205 // @@protoc_insertion_point(field_mutable:tensorflow.DeviceAttributes.locality)
1206 return _msg;
1207 }
set_allocated_locality(::tensorflow::DeviceLocality * locality)1208 inline void DeviceAttributes::set_allocated_locality(::tensorflow::DeviceLocality* locality) {
1209 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
1210 if (message_arena == nullptr) {
1211 delete _impl_.locality_;
1212 }
1213 if (locality) {
1214 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
1215 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(locality);
1216 if (message_arena != submessage_arena) {
1217 locality = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
1218 message_arena, locality, submessage_arena);
1219 }
1220
1221 } else {
1222
1223 }
1224 _impl_.locality_ = locality;
1225 // @@protoc_insertion_point(field_set_allocated:tensorflow.DeviceAttributes.locality)
1226 }
1227
1228 // fixed64 incarnation = 6;
clear_incarnation()1229 inline void DeviceAttributes::clear_incarnation() {
1230 _impl_.incarnation_ = ::uint64_t{0u};
1231 }
_internal_incarnation()1232 inline ::uint64_t DeviceAttributes::_internal_incarnation() const {
1233 return _impl_.incarnation_;
1234 }
incarnation()1235 inline ::uint64_t DeviceAttributes::incarnation() const {
1236 // @@protoc_insertion_point(field_get:tensorflow.DeviceAttributes.incarnation)
1237 return _internal_incarnation();
1238 }
_internal_set_incarnation(::uint64_t value)1239 inline void DeviceAttributes::_internal_set_incarnation(::uint64_t value) {
1240
1241 _impl_.incarnation_ = value;
1242 }
set_incarnation(::uint64_t value)1243 inline void DeviceAttributes::set_incarnation(::uint64_t value) {
1244 _internal_set_incarnation(value);
1245 // @@protoc_insertion_point(field_set:tensorflow.DeviceAttributes.incarnation)
1246 }
1247
1248 // string physical_device_desc = 7;
clear_physical_device_desc()1249 inline void DeviceAttributes::clear_physical_device_desc() {
1250 _impl_.physical_device_desc_.ClearToEmpty();
1251 }
physical_device_desc()1252 inline const std::string& DeviceAttributes::physical_device_desc() const {
1253 // @@protoc_insertion_point(field_get:tensorflow.DeviceAttributes.physical_device_desc)
1254 return _internal_physical_device_desc();
1255 }
1256 template <typename ArgT0, typename... ArgT>
1257 inline PROTOBUF_ALWAYS_INLINE
set_physical_device_desc(ArgT0 && arg0,ArgT...args)1258 void DeviceAttributes::set_physical_device_desc(ArgT0&& arg0, ArgT... args) {
1259
1260 _impl_.physical_device_desc_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1261 // @@protoc_insertion_point(field_set:tensorflow.DeviceAttributes.physical_device_desc)
1262 }
mutable_physical_device_desc()1263 inline std::string* DeviceAttributes::mutable_physical_device_desc() {
1264 std::string* _s = _internal_mutable_physical_device_desc();
1265 // @@protoc_insertion_point(field_mutable:tensorflow.DeviceAttributes.physical_device_desc)
1266 return _s;
1267 }
_internal_physical_device_desc()1268 inline const std::string& DeviceAttributes::_internal_physical_device_desc() const {
1269 return _impl_.physical_device_desc_.Get();
1270 }
_internal_set_physical_device_desc(const std::string & value)1271 inline void DeviceAttributes::_internal_set_physical_device_desc(const std::string& value) {
1272
1273 _impl_.physical_device_desc_.Set(value, GetArenaForAllocation());
1274 }
_internal_mutable_physical_device_desc()1275 inline std::string* DeviceAttributes::_internal_mutable_physical_device_desc() {
1276
1277 return _impl_.physical_device_desc_.Mutable(GetArenaForAllocation());
1278 }
release_physical_device_desc()1279 inline std::string* DeviceAttributes::release_physical_device_desc() {
1280 // @@protoc_insertion_point(field_release:tensorflow.DeviceAttributes.physical_device_desc)
1281 return _impl_.physical_device_desc_.Release();
1282 }
set_allocated_physical_device_desc(std::string * physical_device_desc)1283 inline void DeviceAttributes::set_allocated_physical_device_desc(std::string* physical_device_desc) {
1284 _impl_.physical_device_desc_.SetAllocated(physical_device_desc, GetArenaForAllocation());
1285 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1286 if (_impl_.physical_device_desc_.IsDefault()) {
1287 _impl_.physical_device_desc_.Set("", GetArenaForAllocation());
1288 }
1289 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1290 // @@protoc_insertion_point(field_set_allocated:tensorflow.DeviceAttributes.physical_device_desc)
1291 }
1292
1293 // int64 xla_global_id = 8;
clear_xla_global_id()1294 inline void DeviceAttributes::clear_xla_global_id() {
1295 _impl_.xla_global_id_ = ::int64_t{0};
1296 }
_internal_xla_global_id()1297 inline ::int64_t DeviceAttributes::_internal_xla_global_id() const {
1298 return _impl_.xla_global_id_;
1299 }
xla_global_id()1300 inline ::int64_t DeviceAttributes::xla_global_id() const {
1301 // @@protoc_insertion_point(field_get:tensorflow.DeviceAttributes.xla_global_id)
1302 return _internal_xla_global_id();
1303 }
_internal_set_xla_global_id(::int64_t value)1304 inline void DeviceAttributes::_internal_set_xla_global_id(::int64_t value) {
1305
1306 _impl_.xla_global_id_ = value;
1307 }
set_xla_global_id(::int64_t value)1308 inline void DeviceAttributes::set_xla_global_id(::int64_t value) {
1309 _internal_set_xla_global_id(value);
1310 // @@protoc_insertion_point(field_set:tensorflow.DeviceAttributes.xla_global_id)
1311 }
1312
1313 #ifdef __GNUC__
1314 #pragma GCC diagnostic pop
1315 #endif // __GNUC__
1316 // -------------------------------------------------------------------
1317
1318 // -------------------------------------------------------------------
1319
1320 // -------------------------------------------------------------------
1321
1322
1323 // @@protoc_insertion_point(namespace_scope)
1324
1325 } // namespace tensorflow
1326
1327 // @@protoc_insertion_point(global_scope)
1328
1329 #include <google/protobuf/port_undef.inc>
1330 #endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fdevice_5fattributes_2eproto
1331