1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: tensorflow/core/protobuf/bfc_memory_map.proto
3
4 #ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fprotobuf_2fbfc_5fmemory_5fmap_2eproto
5 #define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fprotobuf_2fbfc_5fmemory_5fmap_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_2fprotobuf_2fbfc_5fmemory_5fmap_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_2fprotobuf_2fbfc_5fmemory_5fmap_2eproto {
43 static const ::uint32_t offsets[];
44 };
45 namespace tensorflow {
46 class BinSummary;
47 struct BinSummaryDefaultTypeInternal;
48 extern BinSummaryDefaultTypeInternal _BinSummary_default_instance_;
49 class MemAllocatorStats;
50 struct MemAllocatorStatsDefaultTypeInternal;
51 extern MemAllocatorStatsDefaultTypeInternal _MemAllocatorStats_default_instance_;
52 class MemChunk;
53 struct MemChunkDefaultTypeInternal;
54 extern MemChunkDefaultTypeInternal _MemChunk_default_instance_;
55 class MemoryDump;
56 struct MemoryDumpDefaultTypeInternal;
57 extern MemoryDumpDefaultTypeInternal _MemoryDump_default_instance_;
58 class SnapShot;
59 struct SnapShotDefaultTypeInternal;
60 extern SnapShotDefaultTypeInternal _SnapShot_default_instance_;
61 } // namespace tensorflow
62 PROTOBUF_NAMESPACE_OPEN
63 template<> ::tensorflow::BinSummary* Arena::CreateMaybeMessage<::tensorflow::BinSummary>(Arena*);
64 template<> ::tensorflow::MemAllocatorStats* Arena::CreateMaybeMessage<::tensorflow::MemAllocatorStats>(Arena*);
65 template<> ::tensorflow::MemChunk* Arena::CreateMaybeMessage<::tensorflow::MemChunk>(Arena*);
66 template<> ::tensorflow::MemoryDump* Arena::CreateMaybeMessage<::tensorflow::MemoryDump>(Arena*);
67 template<> ::tensorflow::SnapShot* Arena::CreateMaybeMessage<::tensorflow::SnapShot>(Arena*);
68 PROTOBUF_NAMESPACE_CLOSE
69 namespace tensorflow {
70
71 // ===================================================================
72
73 class MemAllocatorStats final :
74 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.MemAllocatorStats) */ {
75 public:
MemAllocatorStats()76 inline MemAllocatorStats() : MemAllocatorStats(nullptr) {}
77 ~MemAllocatorStats() override;
78 explicit PROTOBUF_CONSTEXPR MemAllocatorStats(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
79
80 MemAllocatorStats(const MemAllocatorStats& from);
MemAllocatorStats(MemAllocatorStats && from)81 MemAllocatorStats(MemAllocatorStats&& from) noexcept
82 : MemAllocatorStats() {
83 *this = ::std::move(from);
84 }
85
86 inline MemAllocatorStats& operator=(const MemAllocatorStats& from) {
87 if (this == &from) return *this;
88 CopyFrom(from);
89 return *this;
90 }
91 inline MemAllocatorStats& operator=(MemAllocatorStats&& from) noexcept {
92 if (this == &from) return *this;
93 if (GetOwningArena() == from.GetOwningArena()
94 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
95 && GetOwningArena() != nullptr
96 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
97 ) {
98 InternalSwap(&from);
99 } else {
100 CopyFrom(from);
101 }
102 return *this;
103 }
104
default_instance()105 static const MemAllocatorStats& default_instance() {
106 return *internal_default_instance();
107 }
internal_default_instance()108 static inline const MemAllocatorStats* internal_default_instance() {
109 return reinterpret_cast<const MemAllocatorStats*>(
110 &_MemAllocatorStats_default_instance_);
111 }
112 static constexpr int kIndexInFileMessages =
113 0;
114
swap(MemAllocatorStats & a,MemAllocatorStats & b)115 friend void swap(MemAllocatorStats& a, MemAllocatorStats& b) {
116 a.Swap(&b);
117 }
Swap(MemAllocatorStats * other)118 inline void Swap(MemAllocatorStats* other) {
119 if (other == this) return;
120 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
121 if (GetOwningArena() != nullptr &&
122 GetOwningArena() == other->GetOwningArena()) {
123 #else // PROTOBUF_FORCE_COPY_IN_SWAP
124 if (GetOwningArena() == other->GetOwningArena()) {
125 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
126 InternalSwap(other);
127 } else {
128 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
129 }
130 }
131 void UnsafeArenaSwap(MemAllocatorStats* other) {
132 if (other == this) return;
133 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
134 InternalSwap(other);
135 }
136
137 // implements Message ----------------------------------------------
138
139 MemAllocatorStats* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
140 return CreateMaybeMessage<MemAllocatorStats>(arena);
141 }
142 MemAllocatorStats* New() const {
143 return New(nullptr);
144 }
145 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
146 void CopyFrom(const MemAllocatorStats& from);
147 void MergeFrom(const MemAllocatorStats& from);
148 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
149 bool IsInitialized() const final;
150
151 size_t ByteSizeLong() const final;
152 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
153 ::uint8_t* _InternalSerialize(
154 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
155 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
156
157 private:
158 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
159 void SharedDtor();
160 void SetCachedSize(int size) const;
161 void InternalSwap(MemAllocatorStats* other);
162
163 private:
164 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
165 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
166 return "tensorflow.MemAllocatorStats";
167 }
168 protected:
169 explicit MemAllocatorStats(::PROTOBUF_NAMESPACE_ID::Arena* arena,
170 bool is_message_owned = false);
171 public:
172
173 std::string GetTypeName() const final;
174
175 // nested types ----------------------------------------------------
176
177 // accessors -------------------------------------------------------
178
179 enum : int {
180 kNumAllocsFieldNumber = 1,
181 kBytesInUseFieldNumber = 2,
182 kPeakBytesInUseFieldNumber = 3,
183 kLargestAllocSizeFieldNumber = 4,
184 kFragmentationMetricFieldNumber = 5,
185 };
186 // int64 num_allocs = 1;
187 void clear_num_allocs();
188 ::int64_t num_allocs() const;
189 void set_num_allocs(::int64_t value);
190 private:
191 ::int64_t _internal_num_allocs() const;
192 void _internal_set_num_allocs(::int64_t value);
193 public:
194
195 // int64 bytes_in_use = 2;
196 void clear_bytes_in_use();
197 ::int64_t bytes_in_use() const;
198 void set_bytes_in_use(::int64_t value);
199 private:
200 ::int64_t _internal_bytes_in_use() const;
201 void _internal_set_bytes_in_use(::int64_t value);
202 public:
203
204 // int64 peak_bytes_in_use = 3;
205 void clear_peak_bytes_in_use();
206 ::int64_t peak_bytes_in_use() const;
207 void set_peak_bytes_in_use(::int64_t value);
208 private:
209 ::int64_t _internal_peak_bytes_in_use() const;
210 void _internal_set_peak_bytes_in_use(::int64_t value);
211 public:
212
213 // int64 largest_alloc_size = 4;
214 void clear_largest_alloc_size();
215 ::int64_t largest_alloc_size() const;
216 void set_largest_alloc_size(::int64_t value);
217 private:
218 ::int64_t _internal_largest_alloc_size() const;
219 void _internal_set_largest_alloc_size(::int64_t value);
220 public:
221
222 // float fragmentation_metric = 5;
223 void clear_fragmentation_metric();
224 float fragmentation_metric() const;
225 void set_fragmentation_metric(float value);
226 private:
227 float _internal_fragmentation_metric() const;
228 void _internal_set_fragmentation_metric(float value);
229 public:
230
231 // @@protoc_insertion_point(class_scope:tensorflow.MemAllocatorStats)
232 private:
233 class _Internal;
234
235 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
236 typedef void InternalArenaConstructable_;
237 typedef void DestructorSkippable_;
238 struct Impl_ {
239 ::int64_t num_allocs_;
240 ::int64_t bytes_in_use_;
241 ::int64_t peak_bytes_in_use_;
242 ::int64_t largest_alloc_size_;
243 float fragmentation_metric_;
244 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
245 };
246 union { Impl_ _impl_; };
247 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fbfc_5fmemory_5fmap_2eproto;
248 };
249 // -------------------------------------------------------------------
250
251 class MemChunk final :
252 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.MemChunk) */ {
253 public:
MemChunk()254 inline MemChunk() : MemChunk(nullptr) {}
255 ~MemChunk() override;
256 explicit PROTOBUF_CONSTEXPR MemChunk(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
257
258 MemChunk(const MemChunk& from);
MemChunk(MemChunk && from)259 MemChunk(MemChunk&& from) noexcept
260 : MemChunk() {
261 *this = ::std::move(from);
262 }
263
264 inline MemChunk& operator=(const MemChunk& from) {
265 if (this == &from) return *this;
266 CopyFrom(from);
267 return *this;
268 }
269 inline MemChunk& operator=(MemChunk&& from) noexcept {
270 if (this == &from) return *this;
271 if (GetOwningArena() == from.GetOwningArena()
272 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
273 && GetOwningArena() != nullptr
274 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
275 ) {
276 InternalSwap(&from);
277 } else {
278 CopyFrom(from);
279 }
280 return *this;
281 }
282
default_instance()283 static const MemChunk& default_instance() {
284 return *internal_default_instance();
285 }
internal_default_instance()286 static inline const MemChunk* internal_default_instance() {
287 return reinterpret_cast<const MemChunk*>(
288 &_MemChunk_default_instance_);
289 }
290 static constexpr int kIndexInFileMessages =
291 1;
292
swap(MemChunk & a,MemChunk & b)293 friend void swap(MemChunk& a, MemChunk& b) {
294 a.Swap(&b);
295 }
Swap(MemChunk * other)296 inline void Swap(MemChunk* other) {
297 if (other == this) return;
298 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
299 if (GetOwningArena() != nullptr &&
300 GetOwningArena() == other->GetOwningArena()) {
301 #else // PROTOBUF_FORCE_COPY_IN_SWAP
302 if (GetOwningArena() == other->GetOwningArena()) {
303 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
304 InternalSwap(other);
305 } else {
306 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
307 }
308 }
309 void UnsafeArenaSwap(MemChunk* other) {
310 if (other == this) return;
311 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
312 InternalSwap(other);
313 }
314
315 // implements Message ----------------------------------------------
316
317 MemChunk* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
318 return CreateMaybeMessage<MemChunk>(arena);
319 }
320 MemChunk* New() const {
321 return New(nullptr);
322 }
323 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
324 void CopyFrom(const MemChunk& from);
325 void MergeFrom(const MemChunk& from);
326 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
327 bool IsInitialized() const final;
328
329 size_t ByteSizeLong() const final;
330 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
331 ::uint8_t* _InternalSerialize(
332 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
333 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
334
335 private:
336 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
337 void SharedDtor();
338 void SetCachedSize(int size) const;
339 void InternalSwap(MemChunk* other);
340
341 private:
342 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
343 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
344 return "tensorflow.MemChunk";
345 }
346 protected:
347 explicit MemChunk(::PROTOBUF_NAMESPACE_ID::Arena* arena,
348 bool is_message_owned = false);
349 public:
350
351 std::string GetTypeName() const final;
352
353 // nested types ----------------------------------------------------
354
355 // accessors -------------------------------------------------------
356
357 enum : int {
358 kOpNameFieldNumber = 5,
359 kAddressFieldNumber = 1,
360 kSizeFieldNumber = 2,
361 kRequestedSizeFieldNumber = 3,
362 kFreedAtCountFieldNumber = 6,
363 kBinFieldNumber = 4,
364 kInUseFieldNumber = 8,
365 kActionCountFieldNumber = 7,
366 kStepIdFieldNumber = 9,
367 };
368 // string op_name = 5;
369 void clear_op_name();
370 const std::string& op_name() const;
371 template <typename ArgT0 = const std::string&, typename... ArgT>
372 void set_op_name(ArgT0&& arg0, ArgT... args);
373 std::string* mutable_op_name();
374 PROTOBUF_NODISCARD std::string* release_op_name();
375 void set_allocated_op_name(std::string* op_name);
376 private:
377 const std::string& _internal_op_name() const;
378 inline PROTOBUF_ALWAYS_INLINE void _internal_set_op_name(const std::string& value);
379 std::string* _internal_mutable_op_name();
380 public:
381
382 // uint64 address = 1;
383 void clear_address();
384 ::uint64_t address() const;
385 void set_address(::uint64_t value);
386 private:
387 ::uint64_t _internal_address() const;
388 void _internal_set_address(::uint64_t value);
389 public:
390
391 // int64 size = 2;
392 void clear_size();
393 ::int64_t size() const;
394 void set_size(::int64_t value);
395 private:
396 ::int64_t _internal_size() const;
397 void _internal_set_size(::int64_t value);
398 public:
399
400 // int64 requested_size = 3;
401 void clear_requested_size();
402 ::int64_t requested_size() const;
403 void set_requested_size(::int64_t value);
404 private:
405 ::int64_t _internal_requested_size() const;
406 void _internal_set_requested_size(::int64_t value);
407 public:
408
409 // uint64 freed_at_count = 6;
410 void clear_freed_at_count();
411 ::uint64_t freed_at_count() const;
412 void set_freed_at_count(::uint64_t value);
413 private:
414 ::uint64_t _internal_freed_at_count() const;
415 void _internal_set_freed_at_count(::uint64_t value);
416 public:
417
418 // int32 bin = 4;
419 void clear_bin();
420 ::int32_t bin() const;
421 void set_bin(::int32_t value);
422 private:
423 ::int32_t _internal_bin() const;
424 void _internal_set_bin(::int32_t value);
425 public:
426
427 // bool in_use = 8;
428 void clear_in_use();
429 bool in_use() const;
430 void set_in_use(bool value);
431 private:
432 bool _internal_in_use() const;
433 void _internal_set_in_use(bool value);
434 public:
435
436 // uint64 action_count = 7;
437 void clear_action_count();
438 ::uint64_t action_count() const;
439 void set_action_count(::uint64_t value);
440 private:
441 ::uint64_t _internal_action_count() const;
442 void _internal_set_action_count(::uint64_t value);
443 public:
444
445 // uint64 step_id = 9;
446 void clear_step_id();
447 ::uint64_t step_id() const;
448 void set_step_id(::uint64_t value);
449 private:
450 ::uint64_t _internal_step_id() const;
451 void _internal_set_step_id(::uint64_t value);
452 public:
453
454 // @@protoc_insertion_point(class_scope:tensorflow.MemChunk)
455 private:
456 class _Internal;
457
458 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
459 typedef void InternalArenaConstructable_;
460 typedef void DestructorSkippable_;
461 struct Impl_ {
462 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr op_name_;
463 ::uint64_t address_;
464 ::int64_t size_;
465 ::int64_t requested_size_;
466 ::uint64_t freed_at_count_;
467 ::int32_t bin_;
468 bool in_use_;
469 ::uint64_t action_count_;
470 ::uint64_t step_id_;
471 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
472 };
473 union { Impl_ _impl_; };
474 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fbfc_5fmemory_5fmap_2eproto;
475 };
476 // -------------------------------------------------------------------
477
478 class BinSummary final :
479 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.BinSummary) */ {
480 public:
BinSummary()481 inline BinSummary() : BinSummary(nullptr) {}
482 ~BinSummary() override;
483 explicit PROTOBUF_CONSTEXPR BinSummary(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
484
485 BinSummary(const BinSummary& from);
BinSummary(BinSummary && from)486 BinSummary(BinSummary&& from) noexcept
487 : BinSummary() {
488 *this = ::std::move(from);
489 }
490
491 inline BinSummary& operator=(const BinSummary& from) {
492 if (this == &from) return *this;
493 CopyFrom(from);
494 return *this;
495 }
496 inline BinSummary& operator=(BinSummary&& from) noexcept {
497 if (this == &from) return *this;
498 if (GetOwningArena() == from.GetOwningArena()
499 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
500 && GetOwningArena() != nullptr
501 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
502 ) {
503 InternalSwap(&from);
504 } else {
505 CopyFrom(from);
506 }
507 return *this;
508 }
509
default_instance()510 static const BinSummary& default_instance() {
511 return *internal_default_instance();
512 }
internal_default_instance()513 static inline const BinSummary* internal_default_instance() {
514 return reinterpret_cast<const BinSummary*>(
515 &_BinSummary_default_instance_);
516 }
517 static constexpr int kIndexInFileMessages =
518 2;
519
swap(BinSummary & a,BinSummary & b)520 friend void swap(BinSummary& a, BinSummary& b) {
521 a.Swap(&b);
522 }
Swap(BinSummary * other)523 inline void Swap(BinSummary* other) {
524 if (other == this) return;
525 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
526 if (GetOwningArena() != nullptr &&
527 GetOwningArena() == other->GetOwningArena()) {
528 #else // PROTOBUF_FORCE_COPY_IN_SWAP
529 if (GetOwningArena() == other->GetOwningArena()) {
530 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
531 InternalSwap(other);
532 } else {
533 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
534 }
535 }
536 void UnsafeArenaSwap(BinSummary* other) {
537 if (other == this) return;
538 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
539 InternalSwap(other);
540 }
541
542 // implements Message ----------------------------------------------
543
544 BinSummary* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
545 return CreateMaybeMessage<BinSummary>(arena);
546 }
547 BinSummary* New() const {
548 return New(nullptr);
549 }
550 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
551 void CopyFrom(const BinSummary& from);
552 void MergeFrom(const BinSummary& from);
553 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
554 bool IsInitialized() const final;
555
556 size_t ByteSizeLong() const final;
557 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
558 ::uint8_t* _InternalSerialize(
559 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
560 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
561
562 private:
563 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
564 void SharedDtor();
565 void SetCachedSize(int size) const;
566 void InternalSwap(BinSummary* other);
567
568 private:
569 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
570 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
571 return "tensorflow.BinSummary";
572 }
573 protected:
574 explicit BinSummary(::PROTOBUF_NAMESPACE_ID::Arena* arena,
575 bool is_message_owned = false);
576 public:
577
578 std::string GetTypeName() const final;
579
580 // nested types ----------------------------------------------------
581
582 // accessors -------------------------------------------------------
583
584 enum : int {
585 kTotalBytesInUseFieldNumber = 2,
586 kTotalBytesInBinFieldNumber = 3,
587 kTotalChunksInUseFieldNumber = 4,
588 kTotalChunksInBinFieldNumber = 5,
589 kBinFieldNumber = 1,
590 };
591 // int64 total_bytes_in_use = 2;
592 void clear_total_bytes_in_use();
593 ::int64_t total_bytes_in_use() const;
594 void set_total_bytes_in_use(::int64_t value);
595 private:
596 ::int64_t _internal_total_bytes_in_use() const;
597 void _internal_set_total_bytes_in_use(::int64_t value);
598 public:
599
600 // int64 total_bytes_in_bin = 3;
601 void clear_total_bytes_in_bin();
602 ::int64_t total_bytes_in_bin() const;
603 void set_total_bytes_in_bin(::int64_t value);
604 private:
605 ::int64_t _internal_total_bytes_in_bin() const;
606 void _internal_set_total_bytes_in_bin(::int64_t value);
607 public:
608
609 // int64 total_chunks_in_use = 4;
610 void clear_total_chunks_in_use();
611 ::int64_t total_chunks_in_use() const;
612 void set_total_chunks_in_use(::int64_t value);
613 private:
614 ::int64_t _internal_total_chunks_in_use() const;
615 void _internal_set_total_chunks_in_use(::int64_t value);
616 public:
617
618 // int64 total_chunks_in_bin = 5;
619 void clear_total_chunks_in_bin();
620 ::int64_t total_chunks_in_bin() const;
621 void set_total_chunks_in_bin(::int64_t value);
622 private:
623 ::int64_t _internal_total_chunks_in_bin() const;
624 void _internal_set_total_chunks_in_bin(::int64_t value);
625 public:
626
627 // int32 bin = 1;
628 void clear_bin();
629 ::int32_t bin() const;
630 void set_bin(::int32_t value);
631 private:
632 ::int32_t _internal_bin() const;
633 void _internal_set_bin(::int32_t value);
634 public:
635
636 // @@protoc_insertion_point(class_scope:tensorflow.BinSummary)
637 private:
638 class _Internal;
639
640 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
641 typedef void InternalArenaConstructable_;
642 typedef void DestructorSkippable_;
643 struct Impl_ {
644 ::int64_t total_bytes_in_use_;
645 ::int64_t total_bytes_in_bin_;
646 ::int64_t total_chunks_in_use_;
647 ::int64_t total_chunks_in_bin_;
648 ::int32_t bin_;
649 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
650 };
651 union { Impl_ _impl_; };
652 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fbfc_5fmemory_5fmap_2eproto;
653 };
654 // -------------------------------------------------------------------
655
656 class SnapShot final :
657 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.SnapShot) */ {
658 public:
SnapShot()659 inline SnapShot() : SnapShot(nullptr) {}
660 ~SnapShot() override;
661 explicit PROTOBUF_CONSTEXPR SnapShot(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
662
663 SnapShot(const SnapShot& from);
SnapShot(SnapShot && from)664 SnapShot(SnapShot&& from) noexcept
665 : SnapShot() {
666 *this = ::std::move(from);
667 }
668
669 inline SnapShot& operator=(const SnapShot& from) {
670 if (this == &from) return *this;
671 CopyFrom(from);
672 return *this;
673 }
674 inline SnapShot& operator=(SnapShot&& from) noexcept {
675 if (this == &from) return *this;
676 if (GetOwningArena() == from.GetOwningArena()
677 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
678 && GetOwningArena() != nullptr
679 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
680 ) {
681 InternalSwap(&from);
682 } else {
683 CopyFrom(from);
684 }
685 return *this;
686 }
687
default_instance()688 static const SnapShot& default_instance() {
689 return *internal_default_instance();
690 }
internal_default_instance()691 static inline const SnapShot* internal_default_instance() {
692 return reinterpret_cast<const SnapShot*>(
693 &_SnapShot_default_instance_);
694 }
695 static constexpr int kIndexInFileMessages =
696 3;
697
swap(SnapShot & a,SnapShot & b)698 friend void swap(SnapShot& a, SnapShot& b) {
699 a.Swap(&b);
700 }
Swap(SnapShot * other)701 inline void Swap(SnapShot* other) {
702 if (other == this) return;
703 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
704 if (GetOwningArena() != nullptr &&
705 GetOwningArena() == other->GetOwningArena()) {
706 #else // PROTOBUF_FORCE_COPY_IN_SWAP
707 if (GetOwningArena() == other->GetOwningArena()) {
708 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
709 InternalSwap(other);
710 } else {
711 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
712 }
713 }
714 void UnsafeArenaSwap(SnapShot* other) {
715 if (other == this) return;
716 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
717 InternalSwap(other);
718 }
719
720 // implements Message ----------------------------------------------
721
722 SnapShot* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
723 return CreateMaybeMessage<SnapShot>(arena);
724 }
725 SnapShot* New() const {
726 return New(nullptr);
727 }
728 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
729 void CopyFrom(const SnapShot& from);
730 void MergeFrom(const SnapShot& from);
731 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
732 bool IsInitialized() const final;
733
734 size_t ByteSizeLong() const final;
735 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
736 ::uint8_t* _InternalSerialize(
737 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
738 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
739
740 private:
741 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
742 void SharedDtor();
743 void SetCachedSize(int size) const;
744 void InternalSwap(SnapShot* other);
745
746 private:
747 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
748 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
749 return "tensorflow.SnapShot";
750 }
751 protected:
752 explicit SnapShot(::PROTOBUF_NAMESPACE_ID::Arena* arena,
753 bool is_message_owned = false);
754 public:
755
756 std::string GetTypeName() const final;
757
758 // nested types ----------------------------------------------------
759
760 // accessors -------------------------------------------------------
761
762 enum : int {
763 kActionCountFieldNumber = 1,
764 kSizeFieldNumber = 2,
765 };
766 // uint64 action_count = 1;
767 void clear_action_count();
768 ::uint64_t action_count() const;
769 void set_action_count(::uint64_t value);
770 private:
771 ::uint64_t _internal_action_count() const;
772 void _internal_set_action_count(::uint64_t value);
773 public:
774
775 // int64 size = 2;
776 void clear_size();
777 ::int64_t size() const;
778 void set_size(::int64_t value);
779 private:
780 ::int64_t _internal_size() const;
781 void _internal_set_size(::int64_t value);
782 public:
783
784 // @@protoc_insertion_point(class_scope:tensorflow.SnapShot)
785 private:
786 class _Internal;
787
788 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
789 typedef void InternalArenaConstructable_;
790 typedef void DestructorSkippable_;
791 struct Impl_ {
792 ::uint64_t action_count_;
793 ::int64_t size_;
794 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
795 };
796 union { Impl_ _impl_; };
797 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fbfc_5fmemory_5fmap_2eproto;
798 };
799 // -------------------------------------------------------------------
800
801 class MemoryDump final :
802 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.MemoryDump) */ {
803 public:
MemoryDump()804 inline MemoryDump() : MemoryDump(nullptr) {}
805 ~MemoryDump() override;
806 explicit PROTOBUF_CONSTEXPR MemoryDump(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
807
808 MemoryDump(const MemoryDump& from);
MemoryDump(MemoryDump && from)809 MemoryDump(MemoryDump&& from) noexcept
810 : MemoryDump() {
811 *this = ::std::move(from);
812 }
813
814 inline MemoryDump& operator=(const MemoryDump& from) {
815 if (this == &from) return *this;
816 CopyFrom(from);
817 return *this;
818 }
819 inline MemoryDump& operator=(MemoryDump&& from) noexcept {
820 if (this == &from) return *this;
821 if (GetOwningArena() == from.GetOwningArena()
822 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
823 && GetOwningArena() != nullptr
824 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
825 ) {
826 InternalSwap(&from);
827 } else {
828 CopyFrom(from);
829 }
830 return *this;
831 }
832
default_instance()833 static const MemoryDump& default_instance() {
834 return *internal_default_instance();
835 }
internal_default_instance()836 static inline const MemoryDump* internal_default_instance() {
837 return reinterpret_cast<const MemoryDump*>(
838 &_MemoryDump_default_instance_);
839 }
840 static constexpr int kIndexInFileMessages =
841 4;
842
swap(MemoryDump & a,MemoryDump & b)843 friend void swap(MemoryDump& a, MemoryDump& b) {
844 a.Swap(&b);
845 }
Swap(MemoryDump * other)846 inline void Swap(MemoryDump* other) {
847 if (other == this) return;
848 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
849 if (GetOwningArena() != nullptr &&
850 GetOwningArena() == other->GetOwningArena()) {
851 #else // PROTOBUF_FORCE_COPY_IN_SWAP
852 if (GetOwningArena() == other->GetOwningArena()) {
853 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
854 InternalSwap(other);
855 } else {
856 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
857 }
858 }
859 void UnsafeArenaSwap(MemoryDump* other) {
860 if (other == this) return;
861 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
862 InternalSwap(other);
863 }
864
865 // implements Message ----------------------------------------------
866
867 MemoryDump* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
868 return CreateMaybeMessage<MemoryDump>(arena);
869 }
870 MemoryDump* New() const {
871 return New(nullptr);
872 }
873 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
874 void CopyFrom(const MemoryDump& from);
875 void MergeFrom(const MemoryDump& from);
876 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
877 bool IsInitialized() const final;
878
879 size_t ByteSizeLong() const final;
880 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
881 ::uint8_t* _InternalSerialize(
882 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
883 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
884
885 private:
886 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
887 void SharedDtor();
888 void SetCachedSize(int size) const;
889 void InternalSwap(MemoryDump* other);
890
891 private:
892 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
893 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
894 return "tensorflow.MemoryDump";
895 }
896 protected:
897 explicit MemoryDump(::PROTOBUF_NAMESPACE_ID::Arena* arena,
898 bool is_message_owned = false);
899 public:
900
901 std::string GetTypeName() const final;
902
903 // nested types ----------------------------------------------------
904
905 // accessors -------------------------------------------------------
906
907 enum : int {
908 kBinSummaryFieldNumber = 2,
909 kChunkFieldNumber = 3,
910 kSnapShotFieldNumber = 4,
911 kAllocatorNameFieldNumber = 1,
912 kStatsFieldNumber = 5,
913 };
914 // repeated .tensorflow.BinSummary bin_summary = 2;
915 int bin_summary_size() const;
916 private:
917 int _internal_bin_summary_size() const;
918 public:
919 void clear_bin_summary();
920 ::tensorflow::BinSummary* mutable_bin_summary(int index);
921 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::BinSummary >*
922 mutable_bin_summary();
923 private:
924 const ::tensorflow::BinSummary& _internal_bin_summary(int index) const;
925 ::tensorflow::BinSummary* _internal_add_bin_summary();
926 public:
927 const ::tensorflow::BinSummary& bin_summary(int index) const;
928 ::tensorflow::BinSummary* add_bin_summary();
929 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::BinSummary >&
930 bin_summary() const;
931
932 // repeated .tensorflow.MemChunk chunk = 3;
933 int chunk_size() const;
934 private:
935 int _internal_chunk_size() const;
936 public:
937 void clear_chunk();
938 ::tensorflow::MemChunk* mutable_chunk(int index);
939 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::MemChunk >*
940 mutable_chunk();
941 private:
942 const ::tensorflow::MemChunk& _internal_chunk(int index) const;
943 ::tensorflow::MemChunk* _internal_add_chunk();
944 public:
945 const ::tensorflow::MemChunk& chunk(int index) const;
946 ::tensorflow::MemChunk* add_chunk();
947 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::MemChunk >&
948 chunk() const;
949
950 // repeated .tensorflow.SnapShot snap_shot = 4;
951 int snap_shot_size() const;
952 private:
953 int _internal_snap_shot_size() const;
954 public:
955 void clear_snap_shot();
956 ::tensorflow::SnapShot* mutable_snap_shot(int index);
957 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::SnapShot >*
958 mutable_snap_shot();
959 private:
960 const ::tensorflow::SnapShot& _internal_snap_shot(int index) const;
961 ::tensorflow::SnapShot* _internal_add_snap_shot();
962 public:
963 const ::tensorflow::SnapShot& snap_shot(int index) const;
964 ::tensorflow::SnapShot* add_snap_shot();
965 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::SnapShot >&
966 snap_shot() const;
967
968 // string allocator_name = 1;
969 void clear_allocator_name();
970 const std::string& allocator_name() const;
971 template <typename ArgT0 = const std::string&, typename... ArgT>
972 void set_allocator_name(ArgT0&& arg0, ArgT... args);
973 std::string* mutable_allocator_name();
974 PROTOBUF_NODISCARD std::string* release_allocator_name();
975 void set_allocated_allocator_name(std::string* allocator_name);
976 private:
977 const std::string& _internal_allocator_name() const;
978 inline PROTOBUF_ALWAYS_INLINE void _internal_set_allocator_name(const std::string& value);
979 std::string* _internal_mutable_allocator_name();
980 public:
981
982 // .tensorflow.MemAllocatorStats stats = 5;
983 bool has_stats() const;
984 private:
985 bool _internal_has_stats() const;
986 public:
987 void clear_stats();
988 const ::tensorflow::MemAllocatorStats& stats() const;
989 PROTOBUF_NODISCARD ::tensorflow::MemAllocatorStats* release_stats();
990 ::tensorflow::MemAllocatorStats* mutable_stats();
991 void set_allocated_stats(::tensorflow::MemAllocatorStats* stats);
992 private:
993 const ::tensorflow::MemAllocatorStats& _internal_stats() const;
994 ::tensorflow::MemAllocatorStats* _internal_mutable_stats();
995 public:
996 void unsafe_arena_set_allocated_stats(
997 ::tensorflow::MemAllocatorStats* stats);
998 ::tensorflow::MemAllocatorStats* unsafe_arena_release_stats();
999
1000 // @@protoc_insertion_point(class_scope:tensorflow.MemoryDump)
1001 private:
1002 class _Internal;
1003
1004 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1005 typedef void InternalArenaConstructable_;
1006 typedef void DestructorSkippable_;
1007 struct Impl_ {
1008 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::BinSummary > bin_summary_;
1009 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::MemChunk > chunk_;
1010 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::SnapShot > snap_shot_;
1011 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr allocator_name_;
1012 ::tensorflow::MemAllocatorStats* stats_;
1013 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1014 };
1015 union { Impl_ _impl_; };
1016 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fbfc_5fmemory_5fmap_2eproto;
1017 };
1018 // ===================================================================
1019
1020
1021 // ===================================================================
1022
1023 #ifdef __GNUC__
1024 #pragma GCC diagnostic push
1025 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
1026 #endif // __GNUC__
1027 // MemAllocatorStats
1028
1029 // int64 num_allocs = 1;
clear_num_allocs()1030 inline void MemAllocatorStats::clear_num_allocs() {
1031 _impl_.num_allocs_ = ::int64_t{0};
1032 }
_internal_num_allocs()1033 inline ::int64_t MemAllocatorStats::_internal_num_allocs() const {
1034 return _impl_.num_allocs_;
1035 }
num_allocs()1036 inline ::int64_t MemAllocatorStats::num_allocs() const {
1037 // @@protoc_insertion_point(field_get:tensorflow.MemAllocatorStats.num_allocs)
1038 return _internal_num_allocs();
1039 }
_internal_set_num_allocs(::int64_t value)1040 inline void MemAllocatorStats::_internal_set_num_allocs(::int64_t value) {
1041
1042 _impl_.num_allocs_ = value;
1043 }
set_num_allocs(::int64_t value)1044 inline void MemAllocatorStats::set_num_allocs(::int64_t value) {
1045 _internal_set_num_allocs(value);
1046 // @@protoc_insertion_point(field_set:tensorflow.MemAllocatorStats.num_allocs)
1047 }
1048
1049 // int64 bytes_in_use = 2;
clear_bytes_in_use()1050 inline void MemAllocatorStats::clear_bytes_in_use() {
1051 _impl_.bytes_in_use_ = ::int64_t{0};
1052 }
_internal_bytes_in_use()1053 inline ::int64_t MemAllocatorStats::_internal_bytes_in_use() const {
1054 return _impl_.bytes_in_use_;
1055 }
bytes_in_use()1056 inline ::int64_t MemAllocatorStats::bytes_in_use() const {
1057 // @@protoc_insertion_point(field_get:tensorflow.MemAllocatorStats.bytes_in_use)
1058 return _internal_bytes_in_use();
1059 }
_internal_set_bytes_in_use(::int64_t value)1060 inline void MemAllocatorStats::_internal_set_bytes_in_use(::int64_t value) {
1061
1062 _impl_.bytes_in_use_ = value;
1063 }
set_bytes_in_use(::int64_t value)1064 inline void MemAllocatorStats::set_bytes_in_use(::int64_t value) {
1065 _internal_set_bytes_in_use(value);
1066 // @@protoc_insertion_point(field_set:tensorflow.MemAllocatorStats.bytes_in_use)
1067 }
1068
1069 // int64 peak_bytes_in_use = 3;
clear_peak_bytes_in_use()1070 inline void MemAllocatorStats::clear_peak_bytes_in_use() {
1071 _impl_.peak_bytes_in_use_ = ::int64_t{0};
1072 }
_internal_peak_bytes_in_use()1073 inline ::int64_t MemAllocatorStats::_internal_peak_bytes_in_use() const {
1074 return _impl_.peak_bytes_in_use_;
1075 }
peak_bytes_in_use()1076 inline ::int64_t MemAllocatorStats::peak_bytes_in_use() const {
1077 // @@protoc_insertion_point(field_get:tensorflow.MemAllocatorStats.peak_bytes_in_use)
1078 return _internal_peak_bytes_in_use();
1079 }
_internal_set_peak_bytes_in_use(::int64_t value)1080 inline void MemAllocatorStats::_internal_set_peak_bytes_in_use(::int64_t value) {
1081
1082 _impl_.peak_bytes_in_use_ = value;
1083 }
set_peak_bytes_in_use(::int64_t value)1084 inline void MemAllocatorStats::set_peak_bytes_in_use(::int64_t value) {
1085 _internal_set_peak_bytes_in_use(value);
1086 // @@protoc_insertion_point(field_set:tensorflow.MemAllocatorStats.peak_bytes_in_use)
1087 }
1088
1089 // int64 largest_alloc_size = 4;
clear_largest_alloc_size()1090 inline void MemAllocatorStats::clear_largest_alloc_size() {
1091 _impl_.largest_alloc_size_ = ::int64_t{0};
1092 }
_internal_largest_alloc_size()1093 inline ::int64_t MemAllocatorStats::_internal_largest_alloc_size() const {
1094 return _impl_.largest_alloc_size_;
1095 }
largest_alloc_size()1096 inline ::int64_t MemAllocatorStats::largest_alloc_size() const {
1097 // @@protoc_insertion_point(field_get:tensorflow.MemAllocatorStats.largest_alloc_size)
1098 return _internal_largest_alloc_size();
1099 }
_internal_set_largest_alloc_size(::int64_t value)1100 inline void MemAllocatorStats::_internal_set_largest_alloc_size(::int64_t value) {
1101
1102 _impl_.largest_alloc_size_ = value;
1103 }
set_largest_alloc_size(::int64_t value)1104 inline void MemAllocatorStats::set_largest_alloc_size(::int64_t value) {
1105 _internal_set_largest_alloc_size(value);
1106 // @@protoc_insertion_point(field_set:tensorflow.MemAllocatorStats.largest_alloc_size)
1107 }
1108
1109 // float fragmentation_metric = 5;
clear_fragmentation_metric()1110 inline void MemAllocatorStats::clear_fragmentation_metric() {
1111 _impl_.fragmentation_metric_ = 0;
1112 }
_internal_fragmentation_metric()1113 inline float MemAllocatorStats::_internal_fragmentation_metric() const {
1114 return _impl_.fragmentation_metric_;
1115 }
fragmentation_metric()1116 inline float MemAllocatorStats::fragmentation_metric() const {
1117 // @@protoc_insertion_point(field_get:tensorflow.MemAllocatorStats.fragmentation_metric)
1118 return _internal_fragmentation_metric();
1119 }
_internal_set_fragmentation_metric(float value)1120 inline void MemAllocatorStats::_internal_set_fragmentation_metric(float value) {
1121
1122 _impl_.fragmentation_metric_ = value;
1123 }
set_fragmentation_metric(float value)1124 inline void MemAllocatorStats::set_fragmentation_metric(float value) {
1125 _internal_set_fragmentation_metric(value);
1126 // @@protoc_insertion_point(field_set:tensorflow.MemAllocatorStats.fragmentation_metric)
1127 }
1128
1129 // -------------------------------------------------------------------
1130
1131 // MemChunk
1132
1133 // uint64 address = 1;
clear_address()1134 inline void MemChunk::clear_address() {
1135 _impl_.address_ = ::uint64_t{0u};
1136 }
_internal_address()1137 inline ::uint64_t MemChunk::_internal_address() const {
1138 return _impl_.address_;
1139 }
address()1140 inline ::uint64_t MemChunk::address() const {
1141 // @@protoc_insertion_point(field_get:tensorflow.MemChunk.address)
1142 return _internal_address();
1143 }
_internal_set_address(::uint64_t value)1144 inline void MemChunk::_internal_set_address(::uint64_t value) {
1145
1146 _impl_.address_ = value;
1147 }
set_address(::uint64_t value)1148 inline void MemChunk::set_address(::uint64_t value) {
1149 _internal_set_address(value);
1150 // @@protoc_insertion_point(field_set:tensorflow.MemChunk.address)
1151 }
1152
1153 // int64 size = 2;
clear_size()1154 inline void MemChunk::clear_size() {
1155 _impl_.size_ = ::int64_t{0};
1156 }
_internal_size()1157 inline ::int64_t MemChunk::_internal_size() const {
1158 return _impl_.size_;
1159 }
size()1160 inline ::int64_t MemChunk::size() const {
1161 // @@protoc_insertion_point(field_get:tensorflow.MemChunk.size)
1162 return _internal_size();
1163 }
_internal_set_size(::int64_t value)1164 inline void MemChunk::_internal_set_size(::int64_t value) {
1165
1166 _impl_.size_ = value;
1167 }
set_size(::int64_t value)1168 inline void MemChunk::set_size(::int64_t value) {
1169 _internal_set_size(value);
1170 // @@protoc_insertion_point(field_set:tensorflow.MemChunk.size)
1171 }
1172
1173 // int64 requested_size = 3;
clear_requested_size()1174 inline void MemChunk::clear_requested_size() {
1175 _impl_.requested_size_ = ::int64_t{0};
1176 }
_internal_requested_size()1177 inline ::int64_t MemChunk::_internal_requested_size() const {
1178 return _impl_.requested_size_;
1179 }
requested_size()1180 inline ::int64_t MemChunk::requested_size() const {
1181 // @@protoc_insertion_point(field_get:tensorflow.MemChunk.requested_size)
1182 return _internal_requested_size();
1183 }
_internal_set_requested_size(::int64_t value)1184 inline void MemChunk::_internal_set_requested_size(::int64_t value) {
1185
1186 _impl_.requested_size_ = value;
1187 }
set_requested_size(::int64_t value)1188 inline void MemChunk::set_requested_size(::int64_t value) {
1189 _internal_set_requested_size(value);
1190 // @@protoc_insertion_point(field_set:tensorflow.MemChunk.requested_size)
1191 }
1192
1193 // int32 bin = 4;
clear_bin()1194 inline void MemChunk::clear_bin() {
1195 _impl_.bin_ = 0;
1196 }
_internal_bin()1197 inline ::int32_t MemChunk::_internal_bin() const {
1198 return _impl_.bin_;
1199 }
bin()1200 inline ::int32_t MemChunk::bin() const {
1201 // @@protoc_insertion_point(field_get:tensorflow.MemChunk.bin)
1202 return _internal_bin();
1203 }
_internal_set_bin(::int32_t value)1204 inline void MemChunk::_internal_set_bin(::int32_t value) {
1205
1206 _impl_.bin_ = value;
1207 }
set_bin(::int32_t value)1208 inline void MemChunk::set_bin(::int32_t value) {
1209 _internal_set_bin(value);
1210 // @@protoc_insertion_point(field_set:tensorflow.MemChunk.bin)
1211 }
1212
1213 // string op_name = 5;
clear_op_name()1214 inline void MemChunk::clear_op_name() {
1215 _impl_.op_name_.ClearToEmpty();
1216 }
op_name()1217 inline const std::string& MemChunk::op_name() const {
1218 // @@protoc_insertion_point(field_get:tensorflow.MemChunk.op_name)
1219 return _internal_op_name();
1220 }
1221 template <typename ArgT0, typename... ArgT>
1222 inline PROTOBUF_ALWAYS_INLINE
set_op_name(ArgT0 && arg0,ArgT...args)1223 void MemChunk::set_op_name(ArgT0&& arg0, ArgT... args) {
1224
1225 _impl_.op_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1226 // @@protoc_insertion_point(field_set:tensorflow.MemChunk.op_name)
1227 }
mutable_op_name()1228 inline std::string* MemChunk::mutable_op_name() {
1229 std::string* _s = _internal_mutable_op_name();
1230 // @@protoc_insertion_point(field_mutable:tensorflow.MemChunk.op_name)
1231 return _s;
1232 }
_internal_op_name()1233 inline const std::string& MemChunk::_internal_op_name() const {
1234 return _impl_.op_name_.Get();
1235 }
_internal_set_op_name(const std::string & value)1236 inline void MemChunk::_internal_set_op_name(const std::string& value) {
1237
1238 _impl_.op_name_.Set(value, GetArenaForAllocation());
1239 }
_internal_mutable_op_name()1240 inline std::string* MemChunk::_internal_mutable_op_name() {
1241
1242 return _impl_.op_name_.Mutable(GetArenaForAllocation());
1243 }
release_op_name()1244 inline std::string* MemChunk::release_op_name() {
1245 // @@protoc_insertion_point(field_release:tensorflow.MemChunk.op_name)
1246 return _impl_.op_name_.Release();
1247 }
set_allocated_op_name(std::string * op_name)1248 inline void MemChunk::set_allocated_op_name(std::string* op_name) {
1249 _impl_.op_name_.SetAllocated(op_name, GetArenaForAllocation());
1250 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1251 if (_impl_.op_name_.IsDefault()) {
1252 _impl_.op_name_.Set("", GetArenaForAllocation());
1253 }
1254 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1255 // @@protoc_insertion_point(field_set_allocated:tensorflow.MemChunk.op_name)
1256 }
1257
1258 // uint64 freed_at_count = 6;
clear_freed_at_count()1259 inline void MemChunk::clear_freed_at_count() {
1260 _impl_.freed_at_count_ = ::uint64_t{0u};
1261 }
_internal_freed_at_count()1262 inline ::uint64_t MemChunk::_internal_freed_at_count() const {
1263 return _impl_.freed_at_count_;
1264 }
freed_at_count()1265 inline ::uint64_t MemChunk::freed_at_count() const {
1266 // @@protoc_insertion_point(field_get:tensorflow.MemChunk.freed_at_count)
1267 return _internal_freed_at_count();
1268 }
_internal_set_freed_at_count(::uint64_t value)1269 inline void MemChunk::_internal_set_freed_at_count(::uint64_t value) {
1270
1271 _impl_.freed_at_count_ = value;
1272 }
set_freed_at_count(::uint64_t value)1273 inline void MemChunk::set_freed_at_count(::uint64_t value) {
1274 _internal_set_freed_at_count(value);
1275 // @@protoc_insertion_point(field_set:tensorflow.MemChunk.freed_at_count)
1276 }
1277
1278 // uint64 action_count = 7;
clear_action_count()1279 inline void MemChunk::clear_action_count() {
1280 _impl_.action_count_ = ::uint64_t{0u};
1281 }
_internal_action_count()1282 inline ::uint64_t MemChunk::_internal_action_count() const {
1283 return _impl_.action_count_;
1284 }
action_count()1285 inline ::uint64_t MemChunk::action_count() const {
1286 // @@protoc_insertion_point(field_get:tensorflow.MemChunk.action_count)
1287 return _internal_action_count();
1288 }
_internal_set_action_count(::uint64_t value)1289 inline void MemChunk::_internal_set_action_count(::uint64_t value) {
1290
1291 _impl_.action_count_ = value;
1292 }
set_action_count(::uint64_t value)1293 inline void MemChunk::set_action_count(::uint64_t value) {
1294 _internal_set_action_count(value);
1295 // @@protoc_insertion_point(field_set:tensorflow.MemChunk.action_count)
1296 }
1297
1298 // bool in_use = 8;
clear_in_use()1299 inline void MemChunk::clear_in_use() {
1300 _impl_.in_use_ = false;
1301 }
_internal_in_use()1302 inline bool MemChunk::_internal_in_use() const {
1303 return _impl_.in_use_;
1304 }
in_use()1305 inline bool MemChunk::in_use() const {
1306 // @@protoc_insertion_point(field_get:tensorflow.MemChunk.in_use)
1307 return _internal_in_use();
1308 }
_internal_set_in_use(bool value)1309 inline void MemChunk::_internal_set_in_use(bool value) {
1310
1311 _impl_.in_use_ = value;
1312 }
set_in_use(bool value)1313 inline void MemChunk::set_in_use(bool value) {
1314 _internal_set_in_use(value);
1315 // @@protoc_insertion_point(field_set:tensorflow.MemChunk.in_use)
1316 }
1317
1318 // uint64 step_id = 9;
clear_step_id()1319 inline void MemChunk::clear_step_id() {
1320 _impl_.step_id_ = ::uint64_t{0u};
1321 }
_internal_step_id()1322 inline ::uint64_t MemChunk::_internal_step_id() const {
1323 return _impl_.step_id_;
1324 }
step_id()1325 inline ::uint64_t MemChunk::step_id() const {
1326 // @@protoc_insertion_point(field_get:tensorflow.MemChunk.step_id)
1327 return _internal_step_id();
1328 }
_internal_set_step_id(::uint64_t value)1329 inline void MemChunk::_internal_set_step_id(::uint64_t value) {
1330
1331 _impl_.step_id_ = value;
1332 }
set_step_id(::uint64_t value)1333 inline void MemChunk::set_step_id(::uint64_t value) {
1334 _internal_set_step_id(value);
1335 // @@protoc_insertion_point(field_set:tensorflow.MemChunk.step_id)
1336 }
1337
1338 // -------------------------------------------------------------------
1339
1340 // BinSummary
1341
1342 // int32 bin = 1;
clear_bin()1343 inline void BinSummary::clear_bin() {
1344 _impl_.bin_ = 0;
1345 }
_internal_bin()1346 inline ::int32_t BinSummary::_internal_bin() const {
1347 return _impl_.bin_;
1348 }
bin()1349 inline ::int32_t BinSummary::bin() const {
1350 // @@protoc_insertion_point(field_get:tensorflow.BinSummary.bin)
1351 return _internal_bin();
1352 }
_internal_set_bin(::int32_t value)1353 inline void BinSummary::_internal_set_bin(::int32_t value) {
1354
1355 _impl_.bin_ = value;
1356 }
set_bin(::int32_t value)1357 inline void BinSummary::set_bin(::int32_t value) {
1358 _internal_set_bin(value);
1359 // @@protoc_insertion_point(field_set:tensorflow.BinSummary.bin)
1360 }
1361
1362 // int64 total_bytes_in_use = 2;
clear_total_bytes_in_use()1363 inline void BinSummary::clear_total_bytes_in_use() {
1364 _impl_.total_bytes_in_use_ = ::int64_t{0};
1365 }
_internal_total_bytes_in_use()1366 inline ::int64_t BinSummary::_internal_total_bytes_in_use() const {
1367 return _impl_.total_bytes_in_use_;
1368 }
total_bytes_in_use()1369 inline ::int64_t BinSummary::total_bytes_in_use() const {
1370 // @@protoc_insertion_point(field_get:tensorflow.BinSummary.total_bytes_in_use)
1371 return _internal_total_bytes_in_use();
1372 }
_internal_set_total_bytes_in_use(::int64_t value)1373 inline void BinSummary::_internal_set_total_bytes_in_use(::int64_t value) {
1374
1375 _impl_.total_bytes_in_use_ = value;
1376 }
set_total_bytes_in_use(::int64_t value)1377 inline void BinSummary::set_total_bytes_in_use(::int64_t value) {
1378 _internal_set_total_bytes_in_use(value);
1379 // @@protoc_insertion_point(field_set:tensorflow.BinSummary.total_bytes_in_use)
1380 }
1381
1382 // int64 total_bytes_in_bin = 3;
clear_total_bytes_in_bin()1383 inline void BinSummary::clear_total_bytes_in_bin() {
1384 _impl_.total_bytes_in_bin_ = ::int64_t{0};
1385 }
_internal_total_bytes_in_bin()1386 inline ::int64_t BinSummary::_internal_total_bytes_in_bin() const {
1387 return _impl_.total_bytes_in_bin_;
1388 }
total_bytes_in_bin()1389 inline ::int64_t BinSummary::total_bytes_in_bin() const {
1390 // @@protoc_insertion_point(field_get:tensorflow.BinSummary.total_bytes_in_bin)
1391 return _internal_total_bytes_in_bin();
1392 }
_internal_set_total_bytes_in_bin(::int64_t value)1393 inline void BinSummary::_internal_set_total_bytes_in_bin(::int64_t value) {
1394
1395 _impl_.total_bytes_in_bin_ = value;
1396 }
set_total_bytes_in_bin(::int64_t value)1397 inline void BinSummary::set_total_bytes_in_bin(::int64_t value) {
1398 _internal_set_total_bytes_in_bin(value);
1399 // @@protoc_insertion_point(field_set:tensorflow.BinSummary.total_bytes_in_bin)
1400 }
1401
1402 // int64 total_chunks_in_use = 4;
clear_total_chunks_in_use()1403 inline void BinSummary::clear_total_chunks_in_use() {
1404 _impl_.total_chunks_in_use_ = ::int64_t{0};
1405 }
_internal_total_chunks_in_use()1406 inline ::int64_t BinSummary::_internal_total_chunks_in_use() const {
1407 return _impl_.total_chunks_in_use_;
1408 }
total_chunks_in_use()1409 inline ::int64_t BinSummary::total_chunks_in_use() const {
1410 // @@protoc_insertion_point(field_get:tensorflow.BinSummary.total_chunks_in_use)
1411 return _internal_total_chunks_in_use();
1412 }
_internal_set_total_chunks_in_use(::int64_t value)1413 inline void BinSummary::_internal_set_total_chunks_in_use(::int64_t value) {
1414
1415 _impl_.total_chunks_in_use_ = value;
1416 }
set_total_chunks_in_use(::int64_t value)1417 inline void BinSummary::set_total_chunks_in_use(::int64_t value) {
1418 _internal_set_total_chunks_in_use(value);
1419 // @@protoc_insertion_point(field_set:tensorflow.BinSummary.total_chunks_in_use)
1420 }
1421
1422 // int64 total_chunks_in_bin = 5;
clear_total_chunks_in_bin()1423 inline void BinSummary::clear_total_chunks_in_bin() {
1424 _impl_.total_chunks_in_bin_ = ::int64_t{0};
1425 }
_internal_total_chunks_in_bin()1426 inline ::int64_t BinSummary::_internal_total_chunks_in_bin() const {
1427 return _impl_.total_chunks_in_bin_;
1428 }
total_chunks_in_bin()1429 inline ::int64_t BinSummary::total_chunks_in_bin() const {
1430 // @@protoc_insertion_point(field_get:tensorflow.BinSummary.total_chunks_in_bin)
1431 return _internal_total_chunks_in_bin();
1432 }
_internal_set_total_chunks_in_bin(::int64_t value)1433 inline void BinSummary::_internal_set_total_chunks_in_bin(::int64_t value) {
1434
1435 _impl_.total_chunks_in_bin_ = value;
1436 }
set_total_chunks_in_bin(::int64_t value)1437 inline void BinSummary::set_total_chunks_in_bin(::int64_t value) {
1438 _internal_set_total_chunks_in_bin(value);
1439 // @@protoc_insertion_point(field_set:tensorflow.BinSummary.total_chunks_in_bin)
1440 }
1441
1442 // -------------------------------------------------------------------
1443
1444 // SnapShot
1445
1446 // uint64 action_count = 1;
clear_action_count()1447 inline void SnapShot::clear_action_count() {
1448 _impl_.action_count_ = ::uint64_t{0u};
1449 }
_internal_action_count()1450 inline ::uint64_t SnapShot::_internal_action_count() const {
1451 return _impl_.action_count_;
1452 }
action_count()1453 inline ::uint64_t SnapShot::action_count() const {
1454 // @@protoc_insertion_point(field_get:tensorflow.SnapShot.action_count)
1455 return _internal_action_count();
1456 }
_internal_set_action_count(::uint64_t value)1457 inline void SnapShot::_internal_set_action_count(::uint64_t value) {
1458
1459 _impl_.action_count_ = value;
1460 }
set_action_count(::uint64_t value)1461 inline void SnapShot::set_action_count(::uint64_t value) {
1462 _internal_set_action_count(value);
1463 // @@protoc_insertion_point(field_set:tensorflow.SnapShot.action_count)
1464 }
1465
1466 // int64 size = 2;
clear_size()1467 inline void SnapShot::clear_size() {
1468 _impl_.size_ = ::int64_t{0};
1469 }
_internal_size()1470 inline ::int64_t SnapShot::_internal_size() const {
1471 return _impl_.size_;
1472 }
size()1473 inline ::int64_t SnapShot::size() const {
1474 // @@protoc_insertion_point(field_get:tensorflow.SnapShot.size)
1475 return _internal_size();
1476 }
_internal_set_size(::int64_t value)1477 inline void SnapShot::_internal_set_size(::int64_t value) {
1478
1479 _impl_.size_ = value;
1480 }
set_size(::int64_t value)1481 inline void SnapShot::set_size(::int64_t value) {
1482 _internal_set_size(value);
1483 // @@protoc_insertion_point(field_set:tensorflow.SnapShot.size)
1484 }
1485
1486 // -------------------------------------------------------------------
1487
1488 // MemoryDump
1489
1490 // string allocator_name = 1;
clear_allocator_name()1491 inline void MemoryDump::clear_allocator_name() {
1492 _impl_.allocator_name_.ClearToEmpty();
1493 }
allocator_name()1494 inline const std::string& MemoryDump::allocator_name() const {
1495 // @@protoc_insertion_point(field_get:tensorflow.MemoryDump.allocator_name)
1496 return _internal_allocator_name();
1497 }
1498 template <typename ArgT0, typename... ArgT>
1499 inline PROTOBUF_ALWAYS_INLINE
set_allocator_name(ArgT0 && arg0,ArgT...args)1500 void MemoryDump::set_allocator_name(ArgT0&& arg0, ArgT... args) {
1501
1502 _impl_.allocator_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1503 // @@protoc_insertion_point(field_set:tensorflow.MemoryDump.allocator_name)
1504 }
mutable_allocator_name()1505 inline std::string* MemoryDump::mutable_allocator_name() {
1506 std::string* _s = _internal_mutable_allocator_name();
1507 // @@protoc_insertion_point(field_mutable:tensorflow.MemoryDump.allocator_name)
1508 return _s;
1509 }
_internal_allocator_name()1510 inline const std::string& MemoryDump::_internal_allocator_name() const {
1511 return _impl_.allocator_name_.Get();
1512 }
_internal_set_allocator_name(const std::string & value)1513 inline void MemoryDump::_internal_set_allocator_name(const std::string& value) {
1514
1515 _impl_.allocator_name_.Set(value, GetArenaForAllocation());
1516 }
_internal_mutable_allocator_name()1517 inline std::string* MemoryDump::_internal_mutable_allocator_name() {
1518
1519 return _impl_.allocator_name_.Mutable(GetArenaForAllocation());
1520 }
release_allocator_name()1521 inline std::string* MemoryDump::release_allocator_name() {
1522 // @@protoc_insertion_point(field_release:tensorflow.MemoryDump.allocator_name)
1523 return _impl_.allocator_name_.Release();
1524 }
set_allocated_allocator_name(std::string * allocator_name)1525 inline void MemoryDump::set_allocated_allocator_name(std::string* allocator_name) {
1526 _impl_.allocator_name_.SetAllocated(allocator_name, GetArenaForAllocation());
1527 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1528 if (_impl_.allocator_name_.IsDefault()) {
1529 _impl_.allocator_name_.Set("", GetArenaForAllocation());
1530 }
1531 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1532 // @@protoc_insertion_point(field_set_allocated:tensorflow.MemoryDump.allocator_name)
1533 }
1534
1535 // repeated .tensorflow.BinSummary bin_summary = 2;
_internal_bin_summary_size()1536 inline int MemoryDump::_internal_bin_summary_size() const {
1537 return _impl_.bin_summary_.size();
1538 }
bin_summary_size()1539 inline int MemoryDump::bin_summary_size() const {
1540 return _internal_bin_summary_size();
1541 }
clear_bin_summary()1542 inline void MemoryDump::clear_bin_summary() {
1543 _impl_.bin_summary_.Clear();
1544 }
mutable_bin_summary(int index)1545 inline ::tensorflow::BinSummary* MemoryDump::mutable_bin_summary(int index) {
1546 // @@protoc_insertion_point(field_mutable:tensorflow.MemoryDump.bin_summary)
1547 return _impl_.bin_summary_.Mutable(index);
1548 }
1549 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::BinSummary >*
mutable_bin_summary()1550 MemoryDump::mutable_bin_summary() {
1551 // @@protoc_insertion_point(field_mutable_list:tensorflow.MemoryDump.bin_summary)
1552 return &_impl_.bin_summary_;
1553 }
_internal_bin_summary(int index)1554 inline const ::tensorflow::BinSummary& MemoryDump::_internal_bin_summary(int index) const {
1555 return _impl_.bin_summary_.Get(index);
1556 }
bin_summary(int index)1557 inline const ::tensorflow::BinSummary& MemoryDump::bin_summary(int index) const {
1558 // @@protoc_insertion_point(field_get:tensorflow.MemoryDump.bin_summary)
1559 return _internal_bin_summary(index);
1560 }
_internal_add_bin_summary()1561 inline ::tensorflow::BinSummary* MemoryDump::_internal_add_bin_summary() {
1562 return _impl_.bin_summary_.Add();
1563 }
add_bin_summary()1564 inline ::tensorflow::BinSummary* MemoryDump::add_bin_summary() {
1565 ::tensorflow::BinSummary* _add = _internal_add_bin_summary();
1566 // @@protoc_insertion_point(field_add:tensorflow.MemoryDump.bin_summary)
1567 return _add;
1568 }
1569 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::BinSummary >&
bin_summary()1570 MemoryDump::bin_summary() const {
1571 // @@protoc_insertion_point(field_list:tensorflow.MemoryDump.bin_summary)
1572 return _impl_.bin_summary_;
1573 }
1574
1575 // repeated .tensorflow.MemChunk chunk = 3;
_internal_chunk_size()1576 inline int MemoryDump::_internal_chunk_size() const {
1577 return _impl_.chunk_.size();
1578 }
chunk_size()1579 inline int MemoryDump::chunk_size() const {
1580 return _internal_chunk_size();
1581 }
clear_chunk()1582 inline void MemoryDump::clear_chunk() {
1583 _impl_.chunk_.Clear();
1584 }
mutable_chunk(int index)1585 inline ::tensorflow::MemChunk* MemoryDump::mutable_chunk(int index) {
1586 // @@protoc_insertion_point(field_mutable:tensorflow.MemoryDump.chunk)
1587 return _impl_.chunk_.Mutable(index);
1588 }
1589 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::MemChunk >*
mutable_chunk()1590 MemoryDump::mutable_chunk() {
1591 // @@protoc_insertion_point(field_mutable_list:tensorflow.MemoryDump.chunk)
1592 return &_impl_.chunk_;
1593 }
_internal_chunk(int index)1594 inline const ::tensorflow::MemChunk& MemoryDump::_internal_chunk(int index) const {
1595 return _impl_.chunk_.Get(index);
1596 }
chunk(int index)1597 inline const ::tensorflow::MemChunk& MemoryDump::chunk(int index) const {
1598 // @@protoc_insertion_point(field_get:tensorflow.MemoryDump.chunk)
1599 return _internal_chunk(index);
1600 }
_internal_add_chunk()1601 inline ::tensorflow::MemChunk* MemoryDump::_internal_add_chunk() {
1602 return _impl_.chunk_.Add();
1603 }
add_chunk()1604 inline ::tensorflow::MemChunk* MemoryDump::add_chunk() {
1605 ::tensorflow::MemChunk* _add = _internal_add_chunk();
1606 // @@protoc_insertion_point(field_add:tensorflow.MemoryDump.chunk)
1607 return _add;
1608 }
1609 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::MemChunk >&
chunk()1610 MemoryDump::chunk() const {
1611 // @@protoc_insertion_point(field_list:tensorflow.MemoryDump.chunk)
1612 return _impl_.chunk_;
1613 }
1614
1615 // repeated .tensorflow.SnapShot snap_shot = 4;
_internal_snap_shot_size()1616 inline int MemoryDump::_internal_snap_shot_size() const {
1617 return _impl_.snap_shot_.size();
1618 }
snap_shot_size()1619 inline int MemoryDump::snap_shot_size() const {
1620 return _internal_snap_shot_size();
1621 }
clear_snap_shot()1622 inline void MemoryDump::clear_snap_shot() {
1623 _impl_.snap_shot_.Clear();
1624 }
mutable_snap_shot(int index)1625 inline ::tensorflow::SnapShot* MemoryDump::mutable_snap_shot(int index) {
1626 // @@protoc_insertion_point(field_mutable:tensorflow.MemoryDump.snap_shot)
1627 return _impl_.snap_shot_.Mutable(index);
1628 }
1629 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::SnapShot >*
mutable_snap_shot()1630 MemoryDump::mutable_snap_shot() {
1631 // @@protoc_insertion_point(field_mutable_list:tensorflow.MemoryDump.snap_shot)
1632 return &_impl_.snap_shot_;
1633 }
_internal_snap_shot(int index)1634 inline const ::tensorflow::SnapShot& MemoryDump::_internal_snap_shot(int index) const {
1635 return _impl_.snap_shot_.Get(index);
1636 }
snap_shot(int index)1637 inline const ::tensorflow::SnapShot& MemoryDump::snap_shot(int index) const {
1638 // @@protoc_insertion_point(field_get:tensorflow.MemoryDump.snap_shot)
1639 return _internal_snap_shot(index);
1640 }
_internal_add_snap_shot()1641 inline ::tensorflow::SnapShot* MemoryDump::_internal_add_snap_shot() {
1642 return _impl_.snap_shot_.Add();
1643 }
add_snap_shot()1644 inline ::tensorflow::SnapShot* MemoryDump::add_snap_shot() {
1645 ::tensorflow::SnapShot* _add = _internal_add_snap_shot();
1646 // @@protoc_insertion_point(field_add:tensorflow.MemoryDump.snap_shot)
1647 return _add;
1648 }
1649 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::SnapShot >&
snap_shot()1650 MemoryDump::snap_shot() const {
1651 // @@protoc_insertion_point(field_list:tensorflow.MemoryDump.snap_shot)
1652 return _impl_.snap_shot_;
1653 }
1654
1655 // .tensorflow.MemAllocatorStats stats = 5;
_internal_has_stats()1656 inline bool MemoryDump::_internal_has_stats() const {
1657 return this != internal_default_instance() && _impl_.stats_ != nullptr;
1658 }
has_stats()1659 inline bool MemoryDump::has_stats() const {
1660 return _internal_has_stats();
1661 }
clear_stats()1662 inline void MemoryDump::clear_stats() {
1663 if (GetArenaForAllocation() == nullptr && _impl_.stats_ != nullptr) {
1664 delete _impl_.stats_;
1665 }
1666 _impl_.stats_ = nullptr;
1667 }
_internal_stats()1668 inline const ::tensorflow::MemAllocatorStats& MemoryDump::_internal_stats() const {
1669 const ::tensorflow::MemAllocatorStats* p = _impl_.stats_;
1670 return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::MemAllocatorStats&>(
1671 ::tensorflow::_MemAllocatorStats_default_instance_);
1672 }
stats()1673 inline const ::tensorflow::MemAllocatorStats& MemoryDump::stats() const {
1674 // @@protoc_insertion_point(field_get:tensorflow.MemoryDump.stats)
1675 return _internal_stats();
1676 }
unsafe_arena_set_allocated_stats(::tensorflow::MemAllocatorStats * stats)1677 inline void MemoryDump::unsafe_arena_set_allocated_stats(
1678 ::tensorflow::MemAllocatorStats* stats) {
1679 if (GetArenaForAllocation() == nullptr) {
1680 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.stats_);
1681 }
1682 _impl_.stats_ = stats;
1683 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.MemoryDump.stats)
1684 }
release_stats()1685 inline ::tensorflow::MemAllocatorStats* MemoryDump::release_stats() {
1686
1687 ::tensorflow::MemAllocatorStats* temp = _impl_.stats_;
1688 _impl_.stats_ = nullptr;
1689 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
1690 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
1691 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1692 if (GetArenaForAllocation() == nullptr) { delete old; }
1693 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
1694 if (GetArenaForAllocation() != nullptr) {
1695 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1696 }
1697 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
1698 return temp;
1699 }
unsafe_arena_release_stats()1700 inline ::tensorflow::MemAllocatorStats* MemoryDump::unsafe_arena_release_stats() {
1701 // @@protoc_insertion_point(field_release:tensorflow.MemoryDump.stats)
1702
1703 ::tensorflow::MemAllocatorStats* temp = _impl_.stats_;
1704 _impl_.stats_ = nullptr;
1705 return temp;
1706 }
_internal_mutable_stats()1707 inline ::tensorflow::MemAllocatorStats* MemoryDump::_internal_mutable_stats() {
1708
1709 if (_impl_.stats_ == nullptr) {
1710 auto* p = CreateMaybeMessage<::tensorflow::MemAllocatorStats>(GetArenaForAllocation());
1711 _impl_.stats_ = p;
1712 }
1713 return _impl_.stats_;
1714 }
mutable_stats()1715 inline ::tensorflow::MemAllocatorStats* MemoryDump::mutable_stats() {
1716 ::tensorflow::MemAllocatorStats* _msg = _internal_mutable_stats();
1717 // @@protoc_insertion_point(field_mutable:tensorflow.MemoryDump.stats)
1718 return _msg;
1719 }
set_allocated_stats(::tensorflow::MemAllocatorStats * stats)1720 inline void MemoryDump::set_allocated_stats(::tensorflow::MemAllocatorStats* stats) {
1721 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
1722 if (message_arena == nullptr) {
1723 delete _impl_.stats_;
1724 }
1725 if (stats) {
1726 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
1727 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(stats);
1728 if (message_arena != submessage_arena) {
1729 stats = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
1730 message_arena, stats, submessage_arena);
1731 }
1732
1733 } else {
1734
1735 }
1736 _impl_.stats_ = stats;
1737 // @@protoc_insertion_point(field_set_allocated:tensorflow.MemoryDump.stats)
1738 }
1739
1740 #ifdef __GNUC__
1741 #pragma GCC diagnostic pop
1742 #endif // __GNUC__
1743 // -------------------------------------------------------------------
1744
1745 // -------------------------------------------------------------------
1746
1747 // -------------------------------------------------------------------
1748
1749 // -------------------------------------------------------------------
1750
1751
1752 // @@protoc_insertion_point(namespace_scope)
1753
1754 } // namespace tensorflow
1755
1756 // @@protoc_insertion_point(global_scope)
1757
1758 #include <google/protobuf/port_undef.inc>
1759 #endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fprotobuf_2fbfc_5fmemory_5fmap_2eproto
1760