1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: tensorflow/core/grappler/costs/op_performance_data.proto
3
4 #ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fgrappler_2fcosts_2fop_5fperformance_5fdata_2eproto
5 #define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fgrappler_2fcosts_2fop_5fperformance_5fdata_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 #include <google/protobuf/map.h> // IWYU pragma: export
33 #include <google/protobuf/map_entry_lite.h>
34 #include <google/protobuf/map_field_lite.h>
35 #include "tensorflow/core/framework/tensor.pb.h"
36 #include "tensorflow/core/framework/tensor_shape.pb.h"
37 #include "tensorflow/core/framework/types.pb.h"
38 #include "tensorflow/core/framework/attr_value.pb.h"
39 #include "tensorflow/core/protobuf/device_properties.pb.h"
40 // @@protoc_insertion_point(includes)
41 #include <google/protobuf/port_def.inc>
42 #define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcore_2fgrappler_2fcosts_2fop_5fperformance_5fdata_2eproto
43 PROTOBUF_NAMESPACE_OPEN
44 namespace internal {
45 class AnyMetadata;
46 } // namespace internal
47 PROTOBUF_NAMESPACE_CLOSE
48
49 // Internal implementation detail -- do not use these members.
50 struct TableStruct_tensorflow_2fcore_2fgrappler_2fcosts_2fop_5fperformance_5fdata_2eproto {
51 static const ::uint32_t offsets[];
52 };
53 namespace tensorflow {
54 class LogNormalDistribution;
55 struct LogNormalDistributionDefaultTypeInternal;
56 extern LogNormalDistributionDefaultTypeInternal _LogNormalDistribution_default_instance_;
57 class NormalDistribution;
58 struct NormalDistributionDefaultTypeInternal;
59 extern NormalDistributionDefaultTypeInternal _NormalDistribution_default_instance_;
60 class OpInfo;
61 struct OpInfoDefaultTypeInternal;
62 extern OpInfoDefaultTypeInternal _OpInfo_default_instance_;
63 class OpInfo_AttrEntry_DoNotUse;
64 struct OpInfo_AttrEntry_DoNotUseDefaultTypeInternal;
65 extern OpInfo_AttrEntry_DoNotUseDefaultTypeInternal _OpInfo_AttrEntry_DoNotUse_default_instance_;
66 class OpInfo_TensorProperties;
67 struct OpInfo_TensorPropertiesDefaultTypeInternal;
68 extern OpInfo_TensorPropertiesDefaultTypeInternal _OpInfo_TensorProperties_default_instance_;
69 class OpPerformance;
70 struct OpPerformanceDefaultTypeInternal;
71 extern OpPerformanceDefaultTypeInternal _OpPerformance_default_instance_;
72 class OpPerformanceList;
73 struct OpPerformanceListDefaultTypeInternal;
74 extern OpPerformanceListDefaultTypeInternal _OpPerformanceList_default_instance_;
75 class OpPerformance_OpMemory;
76 struct OpPerformance_OpMemoryDefaultTypeInternal;
77 extern OpPerformance_OpMemoryDefaultTypeInternal _OpPerformance_OpMemory_default_instance_;
78 class SessionInfo;
79 struct SessionInfoDefaultTypeInternal;
80 extern SessionInfoDefaultTypeInternal _SessionInfo_default_instance_;
81 } // namespace tensorflow
82 PROTOBUF_NAMESPACE_OPEN
83 template<> ::tensorflow::LogNormalDistribution* Arena::CreateMaybeMessage<::tensorflow::LogNormalDistribution>(Arena*);
84 template<> ::tensorflow::NormalDistribution* Arena::CreateMaybeMessage<::tensorflow::NormalDistribution>(Arena*);
85 template<> ::tensorflow::OpInfo* Arena::CreateMaybeMessage<::tensorflow::OpInfo>(Arena*);
86 template<> ::tensorflow::OpInfo_AttrEntry_DoNotUse* Arena::CreateMaybeMessage<::tensorflow::OpInfo_AttrEntry_DoNotUse>(Arena*);
87 template<> ::tensorflow::OpInfo_TensorProperties* Arena::CreateMaybeMessage<::tensorflow::OpInfo_TensorProperties>(Arena*);
88 template<> ::tensorflow::OpPerformance* Arena::CreateMaybeMessage<::tensorflow::OpPerformance>(Arena*);
89 template<> ::tensorflow::OpPerformanceList* Arena::CreateMaybeMessage<::tensorflow::OpPerformanceList>(Arena*);
90 template<> ::tensorflow::OpPerformance_OpMemory* Arena::CreateMaybeMessage<::tensorflow::OpPerformance_OpMemory>(Arena*);
91 template<> ::tensorflow::SessionInfo* Arena::CreateMaybeMessage<::tensorflow::SessionInfo>(Arena*);
92 PROTOBUF_NAMESPACE_CLOSE
93 namespace tensorflow {
94
95 // ===================================================================
96
97 class SessionInfo final :
98 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.SessionInfo) */ {
99 public:
SessionInfo()100 inline SessionInfo() : SessionInfo(nullptr) {}
101 ~SessionInfo() override;
102 explicit PROTOBUF_CONSTEXPR SessionInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
103
104 SessionInfo(const SessionInfo& from);
SessionInfo(SessionInfo && from)105 SessionInfo(SessionInfo&& from) noexcept
106 : SessionInfo() {
107 *this = ::std::move(from);
108 }
109
110 inline SessionInfo& operator=(const SessionInfo& from) {
111 if (this == &from) return *this;
112 CopyFrom(from);
113 return *this;
114 }
115 inline SessionInfo& operator=(SessionInfo&& from) noexcept {
116 if (this == &from) return *this;
117 if (GetOwningArena() == from.GetOwningArena()
118 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
119 && GetOwningArena() != nullptr
120 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
121 ) {
122 InternalSwap(&from);
123 } else {
124 CopyFrom(from);
125 }
126 return *this;
127 }
128
default_instance()129 static const SessionInfo& default_instance() {
130 return *internal_default_instance();
131 }
internal_default_instance()132 static inline const SessionInfo* internal_default_instance() {
133 return reinterpret_cast<const SessionInfo*>(
134 &_SessionInfo_default_instance_);
135 }
136 static constexpr int kIndexInFileMessages =
137 0;
138
swap(SessionInfo & a,SessionInfo & b)139 friend void swap(SessionInfo& a, SessionInfo& b) {
140 a.Swap(&b);
141 }
Swap(SessionInfo * other)142 inline void Swap(SessionInfo* other) {
143 if (other == this) return;
144 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
145 if (GetOwningArena() != nullptr &&
146 GetOwningArena() == other->GetOwningArena()) {
147 #else // PROTOBUF_FORCE_COPY_IN_SWAP
148 if (GetOwningArena() == other->GetOwningArena()) {
149 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
150 InternalSwap(other);
151 } else {
152 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
153 }
154 }
155 void UnsafeArenaSwap(SessionInfo* other) {
156 if (other == this) return;
157 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
158 InternalSwap(other);
159 }
160
161 // implements Message ----------------------------------------------
162
163 SessionInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
164 return CreateMaybeMessage<SessionInfo>(arena);
165 }
166 SessionInfo* New() const {
167 return New(nullptr);
168 }
169 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
170 void CopyFrom(const SessionInfo& from);
171 void MergeFrom(const SessionInfo& from);
172 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
173 bool IsInitialized() const final;
174
175 size_t ByteSizeLong() const final;
176 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
177 ::uint8_t* _InternalSerialize(
178 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
179 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
180
181 private:
182 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
183 void SharedDtor();
184 void SetCachedSize(int size) const;
185 void InternalSwap(SessionInfo* other);
186
187 private:
188 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
189 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
190 return "tensorflow.SessionInfo";
191 }
192 protected:
193 explicit SessionInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
194 bool is_message_owned = false);
195 public:
196
197 std::string GetTypeName() const final;
198
199 // nested types ----------------------------------------------------
200
201 // accessors -------------------------------------------------------
202
203 enum : int {
204 kIntraOpParallelismFieldNumber = 1,
205 };
206 // int64 intra_op_parallelism = 1;
207 void clear_intra_op_parallelism();
208 ::int64_t intra_op_parallelism() const;
209 void set_intra_op_parallelism(::int64_t value);
210 private:
211 ::int64_t _internal_intra_op_parallelism() const;
212 void _internal_set_intra_op_parallelism(::int64_t value);
213 public:
214
215 // @@protoc_insertion_point(class_scope:tensorflow.SessionInfo)
216 private:
217 class _Internal;
218
219 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
220 typedef void InternalArenaConstructable_;
221 typedef void DestructorSkippable_;
222 struct Impl_ {
223 ::int64_t intra_op_parallelism_;
224 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
225 };
226 union { Impl_ _impl_; };
227 friend struct ::TableStruct_tensorflow_2fcore_2fgrappler_2fcosts_2fop_5fperformance_5fdata_2eproto;
228 };
229 // -------------------------------------------------------------------
230
231 class OpInfo_AttrEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntryLite<OpInfo_AttrEntry_DoNotUse,
232 std::string, ::tensorflow::AttrValue,
233 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
234 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
235 public:
236 typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntryLite<OpInfo_AttrEntry_DoNotUse,
237 std::string, ::tensorflow::AttrValue,
238 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
239 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
240 OpInfo_AttrEntry_DoNotUse();
241 explicit PROTOBUF_CONSTEXPR OpInfo_AttrEntry_DoNotUse(
242 ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
243 explicit OpInfo_AttrEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
244 void MergeFrom(const OpInfo_AttrEntry_DoNotUse& other);
internal_default_instance()245 static const OpInfo_AttrEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const OpInfo_AttrEntry_DoNotUse*>(&_OpInfo_AttrEntry_DoNotUse_default_instance_); }
ValidateKey(std::string * s)246 static bool ValidateKey(std::string* s) {
247 return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "tensorflow.OpInfo.AttrEntry.key");
248 }
ValidateValue(void *)249 static bool ValidateValue(void*) { return true; }
250 friend struct ::TableStruct_tensorflow_2fcore_2fgrappler_2fcosts_2fop_5fperformance_5fdata_2eproto;
251 };
252
253 // -------------------------------------------------------------------
254
255 class OpInfo_TensorProperties final :
256 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.OpInfo.TensorProperties) */ {
257 public:
OpInfo_TensorProperties()258 inline OpInfo_TensorProperties() : OpInfo_TensorProperties(nullptr) {}
259 ~OpInfo_TensorProperties() override;
260 explicit PROTOBUF_CONSTEXPR OpInfo_TensorProperties(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
261
262 OpInfo_TensorProperties(const OpInfo_TensorProperties& from);
OpInfo_TensorProperties(OpInfo_TensorProperties && from)263 OpInfo_TensorProperties(OpInfo_TensorProperties&& from) noexcept
264 : OpInfo_TensorProperties() {
265 *this = ::std::move(from);
266 }
267
268 inline OpInfo_TensorProperties& operator=(const OpInfo_TensorProperties& from) {
269 if (this == &from) return *this;
270 CopyFrom(from);
271 return *this;
272 }
273 inline OpInfo_TensorProperties& operator=(OpInfo_TensorProperties&& from) noexcept {
274 if (this == &from) return *this;
275 if (GetOwningArena() == from.GetOwningArena()
276 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
277 && GetOwningArena() != nullptr
278 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
279 ) {
280 InternalSwap(&from);
281 } else {
282 CopyFrom(from);
283 }
284 return *this;
285 }
286
default_instance()287 static const OpInfo_TensorProperties& default_instance() {
288 return *internal_default_instance();
289 }
internal_default_instance()290 static inline const OpInfo_TensorProperties* internal_default_instance() {
291 return reinterpret_cast<const OpInfo_TensorProperties*>(
292 &_OpInfo_TensorProperties_default_instance_);
293 }
294 static constexpr int kIndexInFileMessages =
295 2;
296
swap(OpInfo_TensorProperties & a,OpInfo_TensorProperties & b)297 friend void swap(OpInfo_TensorProperties& a, OpInfo_TensorProperties& b) {
298 a.Swap(&b);
299 }
Swap(OpInfo_TensorProperties * other)300 inline void Swap(OpInfo_TensorProperties* other) {
301 if (other == this) return;
302 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
303 if (GetOwningArena() != nullptr &&
304 GetOwningArena() == other->GetOwningArena()) {
305 #else // PROTOBUF_FORCE_COPY_IN_SWAP
306 if (GetOwningArena() == other->GetOwningArena()) {
307 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
308 InternalSwap(other);
309 } else {
310 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
311 }
312 }
313 void UnsafeArenaSwap(OpInfo_TensorProperties* other) {
314 if (other == this) return;
315 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
316 InternalSwap(other);
317 }
318
319 // implements Message ----------------------------------------------
320
321 OpInfo_TensorProperties* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
322 return CreateMaybeMessage<OpInfo_TensorProperties>(arena);
323 }
324 OpInfo_TensorProperties* New() const {
325 return New(nullptr);
326 }
327 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
328 void CopyFrom(const OpInfo_TensorProperties& from);
329 void MergeFrom(const OpInfo_TensorProperties& from);
330 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
331 bool IsInitialized() const final;
332
333 size_t ByteSizeLong() const final;
334 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
335 ::uint8_t* _InternalSerialize(
336 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
337 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
338
339 private:
340 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
341 void SharedDtor();
342 void SetCachedSize(int size) const;
343 void InternalSwap(OpInfo_TensorProperties* other);
344
345 private:
346 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
347 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
348 return "tensorflow.OpInfo.TensorProperties";
349 }
350 protected:
351 explicit OpInfo_TensorProperties(::PROTOBUF_NAMESPACE_ID::Arena* arena,
352 bool is_message_owned = false);
353 public:
354
355 std::string GetTypeName() const final;
356
357 // nested types ----------------------------------------------------
358
359 // accessors -------------------------------------------------------
360
361 enum : int {
362 kShapeFieldNumber = 2,
363 kValueFieldNumber = 3,
364 kDtypeFieldNumber = 1,
365 };
366 // .tensorflow.TensorShapeProto shape = 2;
367 bool has_shape() const;
368 private:
369 bool _internal_has_shape() const;
370 public:
371 void clear_shape();
372 const ::tensorflow::TensorShapeProto& shape() const;
373 PROTOBUF_NODISCARD ::tensorflow::TensorShapeProto* release_shape();
374 ::tensorflow::TensorShapeProto* mutable_shape();
375 void set_allocated_shape(::tensorflow::TensorShapeProto* shape);
376 private:
377 const ::tensorflow::TensorShapeProto& _internal_shape() const;
378 ::tensorflow::TensorShapeProto* _internal_mutable_shape();
379 public:
380 void unsafe_arena_set_allocated_shape(
381 ::tensorflow::TensorShapeProto* shape);
382 ::tensorflow::TensorShapeProto* unsafe_arena_release_shape();
383
384 // .tensorflow.TensorProto value = 3;
385 bool has_value() const;
386 private:
387 bool _internal_has_value() const;
388 public:
389 void clear_value();
390 const ::tensorflow::TensorProto& value() const;
391 PROTOBUF_NODISCARD ::tensorflow::TensorProto* release_value();
392 ::tensorflow::TensorProto* mutable_value();
393 void set_allocated_value(::tensorflow::TensorProto* value);
394 private:
395 const ::tensorflow::TensorProto& _internal_value() const;
396 ::tensorflow::TensorProto* _internal_mutable_value();
397 public:
398 void unsafe_arena_set_allocated_value(
399 ::tensorflow::TensorProto* value);
400 ::tensorflow::TensorProto* unsafe_arena_release_value();
401
402 // .tensorflow.DataType dtype = 1;
403 void clear_dtype();
404 ::tensorflow::DataType dtype() const;
405 void set_dtype(::tensorflow::DataType value);
406 private:
407 ::tensorflow::DataType _internal_dtype() const;
408 void _internal_set_dtype(::tensorflow::DataType value);
409 public:
410
411 // @@protoc_insertion_point(class_scope:tensorflow.OpInfo.TensorProperties)
412 private:
413 class _Internal;
414
415 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
416 typedef void InternalArenaConstructable_;
417 typedef void DestructorSkippable_;
418 struct Impl_ {
419 ::tensorflow::TensorShapeProto* shape_;
420 ::tensorflow::TensorProto* value_;
421 int dtype_;
422 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
423 };
424 union { Impl_ _impl_; };
425 friend struct ::TableStruct_tensorflow_2fcore_2fgrappler_2fcosts_2fop_5fperformance_5fdata_2eproto;
426 };
427 // -------------------------------------------------------------------
428
429 class OpInfo final :
430 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.OpInfo) */ {
431 public:
OpInfo()432 inline OpInfo() : OpInfo(nullptr) {}
433 ~OpInfo() override;
434 explicit PROTOBUF_CONSTEXPR OpInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
435
436 OpInfo(const OpInfo& from);
OpInfo(OpInfo && from)437 OpInfo(OpInfo&& from) noexcept
438 : OpInfo() {
439 *this = ::std::move(from);
440 }
441
442 inline OpInfo& operator=(const OpInfo& from) {
443 if (this == &from) return *this;
444 CopyFrom(from);
445 return *this;
446 }
447 inline OpInfo& operator=(OpInfo&& from) noexcept {
448 if (this == &from) return *this;
449 if (GetOwningArena() == from.GetOwningArena()
450 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
451 && GetOwningArena() != nullptr
452 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
453 ) {
454 InternalSwap(&from);
455 } else {
456 CopyFrom(from);
457 }
458 return *this;
459 }
460
default_instance()461 static const OpInfo& default_instance() {
462 return *internal_default_instance();
463 }
internal_default_instance()464 static inline const OpInfo* internal_default_instance() {
465 return reinterpret_cast<const OpInfo*>(
466 &_OpInfo_default_instance_);
467 }
468 static constexpr int kIndexInFileMessages =
469 3;
470
swap(OpInfo & a,OpInfo & b)471 friend void swap(OpInfo& a, OpInfo& b) {
472 a.Swap(&b);
473 }
Swap(OpInfo * other)474 inline void Swap(OpInfo* other) {
475 if (other == this) return;
476 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
477 if (GetOwningArena() != nullptr &&
478 GetOwningArena() == other->GetOwningArena()) {
479 #else // PROTOBUF_FORCE_COPY_IN_SWAP
480 if (GetOwningArena() == other->GetOwningArena()) {
481 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
482 InternalSwap(other);
483 } else {
484 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
485 }
486 }
487 void UnsafeArenaSwap(OpInfo* other) {
488 if (other == this) return;
489 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
490 InternalSwap(other);
491 }
492
493 // implements Message ----------------------------------------------
494
495 OpInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
496 return CreateMaybeMessage<OpInfo>(arena);
497 }
498 OpInfo* New() const {
499 return New(nullptr);
500 }
501 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
502 void CopyFrom(const OpInfo& from);
503 void MergeFrom(const OpInfo& from);
504 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
505 bool IsInitialized() const final;
506
507 size_t ByteSizeLong() const final;
508 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
509 ::uint8_t* _InternalSerialize(
510 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
511 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
512
513 private:
514 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
515 void SharedDtor();
516 void SetCachedSize(int size) const;
517 void InternalSwap(OpInfo* other);
518
519 private:
520 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
521 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
522 return "tensorflow.OpInfo";
523 }
524 protected:
525 explicit OpInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
526 bool is_message_owned = false);
527 public:
528
529 std::string GetTypeName() const final;
530
531 // nested types ----------------------------------------------------
532
533 typedef OpInfo_TensorProperties TensorProperties;
534
535 // accessors -------------------------------------------------------
536
537 enum : int {
538 kAttrFieldNumber = 2,
539 kInputsFieldNumber = 3,
540 kOutputsFieldNumber = 5,
541 kOpFieldNumber = 1,
542 kDeviceFieldNumber = 4,
543 kSessionInfoFieldNumber = 6,
544 };
545 // map<string, .tensorflow.AttrValue> attr = 2;
546 int attr_size() const;
547 private:
548 int _internal_attr_size() const;
549 public:
550 void clear_attr();
551 private:
552 const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::AttrValue >&
553 _internal_attr() const;
554 ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::AttrValue >*
555 _internal_mutable_attr();
556 public:
557 const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::AttrValue >&
558 attr() const;
559 ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::AttrValue >*
560 mutable_attr();
561
562 // repeated .tensorflow.OpInfo.TensorProperties inputs = 3;
563 int inputs_size() const;
564 private:
565 int _internal_inputs_size() const;
566 public:
567 void clear_inputs();
568 ::tensorflow::OpInfo_TensorProperties* mutable_inputs(int index);
569 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpInfo_TensorProperties >*
570 mutable_inputs();
571 private:
572 const ::tensorflow::OpInfo_TensorProperties& _internal_inputs(int index) const;
573 ::tensorflow::OpInfo_TensorProperties* _internal_add_inputs();
574 public:
575 const ::tensorflow::OpInfo_TensorProperties& inputs(int index) const;
576 ::tensorflow::OpInfo_TensorProperties* add_inputs();
577 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpInfo_TensorProperties >&
578 inputs() const;
579
580 // repeated .tensorflow.OpInfo.TensorProperties outputs = 5;
581 int outputs_size() const;
582 private:
583 int _internal_outputs_size() const;
584 public:
585 void clear_outputs();
586 ::tensorflow::OpInfo_TensorProperties* mutable_outputs(int index);
587 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpInfo_TensorProperties >*
588 mutable_outputs();
589 private:
590 const ::tensorflow::OpInfo_TensorProperties& _internal_outputs(int index) const;
591 ::tensorflow::OpInfo_TensorProperties* _internal_add_outputs();
592 public:
593 const ::tensorflow::OpInfo_TensorProperties& outputs(int index) const;
594 ::tensorflow::OpInfo_TensorProperties* add_outputs();
595 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpInfo_TensorProperties >&
596 outputs() const;
597
598 // string op = 1;
599 void clear_op();
600 const std::string& op() const;
601 template <typename ArgT0 = const std::string&, typename... ArgT>
602 void set_op(ArgT0&& arg0, ArgT... args);
603 std::string* mutable_op();
604 PROTOBUF_NODISCARD std::string* release_op();
605 void set_allocated_op(std::string* op);
606 private:
607 const std::string& _internal_op() const;
608 inline PROTOBUF_ALWAYS_INLINE void _internal_set_op(const std::string& value);
609 std::string* _internal_mutable_op();
610 public:
611
612 // .tensorflow.DeviceProperties device = 4;
613 bool has_device() const;
614 private:
615 bool _internal_has_device() const;
616 public:
617 void clear_device();
618 const ::tensorflow::DeviceProperties& device() const;
619 PROTOBUF_NODISCARD ::tensorflow::DeviceProperties* release_device();
620 ::tensorflow::DeviceProperties* mutable_device();
621 void set_allocated_device(::tensorflow::DeviceProperties* device);
622 private:
623 const ::tensorflow::DeviceProperties& _internal_device() const;
624 ::tensorflow::DeviceProperties* _internal_mutable_device();
625 public:
626 void unsafe_arena_set_allocated_device(
627 ::tensorflow::DeviceProperties* device);
628 ::tensorflow::DeviceProperties* unsafe_arena_release_device();
629
630 // .tensorflow.SessionInfo session_info = 6;
631 bool has_session_info() const;
632 private:
633 bool _internal_has_session_info() const;
634 public:
635 void clear_session_info();
636 const ::tensorflow::SessionInfo& session_info() const;
637 PROTOBUF_NODISCARD ::tensorflow::SessionInfo* release_session_info();
638 ::tensorflow::SessionInfo* mutable_session_info();
639 void set_allocated_session_info(::tensorflow::SessionInfo* session_info);
640 private:
641 const ::tensorflow::SessionInfo& _internal_session_info() const;
642 ::tensorflow::SessionInfo* _internal_mutable_session_info();
643 public:
644 void unsafe_arena_set_allocated_session_info(
645 ::tensorflow::SessionInfo* session_info);
646 ::tensorflow::SessionInfo* unsafe_arena_release_session_info();
647
648 // @@protoc_insertion_point(class_scope:tensorflow.OpInfo)
649 private:
650 class _Internal;
651
652 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
653 typedef void InternalArenaConstructable_;
654 typedef void DestructorSkippable_;
655 struct Impl_ {
656 ::PROTOBUF_NAMESPACE_ID::internal::MapFieldLite<
657 OpInfo_AttrEntry_DoNotUse,
658 std::string, ::tensorflow::AttrValue,
659 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
660 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> attr_;
661 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpInfo_TensorProperties > inputs_;
662 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpInfo_TensorProperties > outputs_;
663 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr op_;
664 ::tensorflow::DeviceProperties* device_;
665 ::tensorflow::SessionInfo* session_info_;
666 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
667 };
668 union { Impl_ _impl_; };
669 friend struct ::TableStruct_tensorflow_2fcore_2fgrappler_2fcosts_2fop_5fperformance_5fdata_2eproto;
670 };
671 // -------------------------------------------------------------------
672
673 class NormalDistribution final :
674 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.NormalDistribution) */ {
675 public:
NormalDistribution()676 inline NormalDistribution() : NormalDistribution(nullptr) {}
677 ~NormalDistribution() override;
678 explicit PROTOBUF_CONSTEXPR NormalDistribution(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
679
680 NormalDistribution(const NormalDistribution& from);
NormalDistribution(NormalDistribution && from)681 NormalDistribution(NormalDistribution&& from) noexcept
682 : NormalDistribution() {
683 *this = ::std::move(from);
684 }
685
686 inline NormalDistribution& operator=(const NormalDistribution& from) {
687 if (this == &from) return *this;
688 CopyFrom(from);
689 return *this;
690 }
691 inline NormalDistribution& operator=(NormalDistribution&& from) noexcept {
692 if (this == &from) return *this;
693 if (GetOwningArena() == from.GetOwningArena()
694 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
695 && GetOwningArena() != nullptr
696 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
697 ) {
698 InternalSwap(&from);
699 } else {
700 CopyFrom(from);
701 }
702 return *this;
703 }
704
default_instance()705 static const NormalDistribution& default_instance() {
706 return *internal_default_instance();
707 }
internal_default_instance()708 static inline const NormalDistribution* internal_default_instance() {
709 return reinterpret_cast<const NormalDistribution*>(
710 &_NormalDistribution_default_instance_);
711 }
712 static constexpr int kIndexInFileMessages =
713 4;
714
swap(NormalDistribution & a,NormalDistribution & b)715 friend void swap(NormalDistribution& a, NormalDistribution& b) {
716 a.Swap(&b);
717 }
Swap(NormalDistribution * other)718 inline void Swap(NormalDistribution* other) {
719 if (other == this) return;
720 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
721 if (GetOwningArena() != nullptr &&
722 GetOwningArena() == other->GetOwningArena()) {
723 #else // PROTOBUF_FORCE_COPY_IN_SWAP
724 if (GetOwningArena() == other->GetOwningArena()) {
725 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
726 InternalSwap(other);
727 } else {
728 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
729 }
730 }
731 void UnsafeArenaSwap(NormalDistribution* other) {
732 if (other == this) return;
733 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
734 InternalSwap(other);
735 }
736
737 // implements Message ----------------------------------------------
738
739 NormalDistribution* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
740 return CreateMaybeMessage<NormalDistribution>(arena);
741 }
742 NormalDistribution* New() const {
743 return New(nullptr);
744 }
745 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
746 void CopyFrom(const NormalDistribution& from);
747 void MergeFrom(const NormalDistribution& from);
748 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
749 bool IsInitialized() const final;
750
751 size_t ByteSizeLong() const final;
752 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
753 ::uint8_t* _InternalSerialize(
754 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
755 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
756
757 private:
758 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
759 void SharedDtor();
760 void SetCachedSize(int size) const;
761 void InternalSwap(NormalDistribution* other);
762
763 private:
764 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
765 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
766 return "tensorflow.NormalDistribution";
767 }
768 protected:
769 explicit NormalDistribution(::PROTOBUF_NAMESPACE_ID::Arena* arena,
770 bool is_message_owned = false);
771 public:
772
773 std::string GetTypeName() const final;
774
775 // nested types ----------------------------------------------------
776
777 // accessors -------------------------------------------------------
778
779 enum : int {
780 kMuFieldNumber = 1,
781 kSigmaFieldNumber = 2,
782 };
783 // double mu = 1;
784 void clear_mu();
785 double mu() const;
786 void set_mu(double value);
787 private:
788 double _internal_mu() const;
789 void _internal_set_mu(double value);
790 public:
791
792 // double sigma = 2;
793 void clear_sigma();
794 double sigma() const;
795 void set_sigma(double value);
796 private:
797 double _internal_sigma() const;
798 void _internal_set_sigma(double value);
799 public:
800
801 // @@protoc_insertion_point(class_scope:tensorflow.NormalDistribution)
802 private:
803 class _Internal;
804
805 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
806 typedef void InternalArenaConstructable_;
807 typedef void DestructorSkippable_;
808 struct Impl_ {
809 double mu_;
810 double sigma_;
811 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
812 };
813 union { Impl_ _impl_; };
814 friend struct ::TableStruct_tensorflow_2fcore_2fgrappler_2fcosts_2fop_5fperformance_5fdata_2eproto;
815 };
816 // -------------------------------------------------------------------
817
818 class LogNormalDistribution final :
819 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.LogNormalDistribution) */ {
820 public:
LogNormalDistribution()821 inline LogNormalDistribution() : LogNormalDistribution(nullptr) {}
822 ~LogNormalDistribution() override;
823 explicit PROTOBUF_CONSTEXPR LogNormalDistribution(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
824
825 LogNormalDistribution(const LogNormalDistribution& from);
LogNormalDistribution(LogNormalDistribution && from)826 LogNormalDistribution(LogNormalDistribution&& from) noexcept
827 : LogNormalDistribution() {
828 *this = ::std::move(from);
829 }
830
831 inline LogNormalDistribution& operator=(const LogNormalDistribution& from) {
832 if (this == &from) return *this;
833 CopyFrom(from);
834 return *this;
835 }
836 inline LogNormalDistribution& operator=(LogNormalDistribution&& from) noexcept {
837 if (this == &from) return *this;
838 if (GetOwningArena() == from.GetOwningArena()
839 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
840 && GetOwningArena() != nullptr
841 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
842 ) {
843 InternalSwap(&from);
844 } else {
845 CopyFrom(from);
846 }
847 return *this;
848 }
849
default_instance()850 static const LogNormalDistribution& default_instance() {
851 return *internal_default_instance();
852 }
internal_default_instance()853 static inline const LogNormalDistribution* internal_default_instance() {
854 return reinterpret_cast<const LogNormalDistribution*>(
855 &_LogNormalDistribution_default_instance_);
856 }
857 static constexpr int kIndexInFileMessages =
858 5;
859
swap(LogNormalDistribution & a,LogNormalDistribution & b)860 friend void swap(LogNormalDistribution& a, LogNormalDistribution& b) {
861 a.Swap(&b);
862 }
Swap(LogNormalDistribution * other)863 inline void Swap(LogNormalDistribution* other) {
864 if (other == this) return;
865 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
866 if (GetOwningArena() != nullptr &&
867 GetOwningArena() == other->GetOwningArena()) {
868 #else // PROTOBUF_FORCE_COPY_IN_SWAP
869 if (GetOwningArena() == other->GetOwningArena()) {
870 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
871 InternalSwap(other);
872 } else {
873 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
874 }
875 }
876 void UnsafeArenaSwap(LogNormalDistribution* other) {
877 if (other == this) return;
878 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
879 InternalSwap(other);
880 }
881
882 // implements Message ----------------------------------------------
883
884 LogNormalDistribution* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
885 return CreateMaybeMessage<LogNormalDistribution>(arena);
886 }
887 LogNormalDistribution* New() const {
888 return New(nullptr);
889 }
890 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
891 void CopyFrom(const LogNormalDistribution& from);
892 void MergeFrom(const LogNormalDistribution& from);
893 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
894 bool IsInitialized() const final;
895
896 size_t ByteSizeLong() const final;
897 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
898 ::uint8_t* _InternalSerialize(
899 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
900 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
901
902 private:
903 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
904 void SharedDtor();
905 void SetCachedSize(int size) const;
906 void InternalSwap(LogNormalDistribution* other);
907
908 private:
909 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
910 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
911 return "tensorflow.LogNormalDistribution";
912 }
913 protected:
914 explicit LogNormalDistribution(::PROTOBUF_NAMESPACE_ID::Arena* arena,
915 bool is_message_owned = false);
916 public:
917
918 std::string GetTypeName() const final;
919
920 // nested types ----------------------------------------------------
921
922 // accessors -------------------------------------------------------
923
924 enum : int {
925 kMuFieldNumber = 1,
926 kSigmaFieldNumber = 2,
927 };
928 // double mu = 1;
929 void clear_mu();
930 double mu() const;
931 void set_mu(double value);
932 private:
933 double _internal_mu() const;
934 void _internal_set_mu(double value);
935 public:
936
937 // double sigma = 2;
938 void clear_sigma();
939 double sigma() const;
940 void set_sigma(double value);
941 private:
942 double _internal_sigma() const;
943 void _internal_set_sigma(double value);
944 public:
945
946 // @@protoc_insertion_point(class_scope:tensorflow.LogNormalDistribution)
947 private:
948 class _Internal;
949
950 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
951 typedef void InternalArenaConstructable_;
952 typedef void DestructorSkippable_;
953 struct Impl_ {
954 double mu_;
955 double sigma_;
956 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
957 };
958 union { Impl_ _impl_; };
959 friend struct ::TableStruct_tensorflow_2fcore_2fgrappler_2fcosts_2fop_5fperformance_5fdata_2eproto;
960 };
961 // -------------------------------------------------------------------
962
963 class OpPerformance_OpMemory final :
964 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.OpPerformance.OpMemory) */ {
965 public:
OpPerformance_OpMemory()966 inline OpPerformance_OpMemory() : OpPerformance_OpMemory(nullptr) {}
967 ~OpPerformance_OpMemory() override;
968 explicit PROTOBUF_CONSTEXPR OpPerformance_OpMemory(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
969
970 OpPerformance_OpMemory(const OpPerformance_OpMemory& from);
OpPerformance_OpMemory(OpPerformance_OpMemory && from)971 OpPerformance_OpMemory(OpPerformance_OpMemory&& from) noexcept
972 : OpPerformance_OpMemory() {
973 *this = ::std::move(from);
974 }
975
976 inline OpPerformance_OpMemory& operator=(const OpPerformance_OpMemory& from) {
977 if (this == &from) return *this;
978 CopyFrom(from);
979 return *this;
980 }
981 inline OpPerformance_OpMemory& operator=(OpPerformance_OpMemory&& from) noexcept {
982 if (this == &from) return *this;
983 if (GetOwningArena() == from.GetOwningArena()
984 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
985 && GetOwningArena() != nullptr
986 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
987 ) {
988 InternalSwap(&from);
989 } else {
990 CopyFrom(from);
991 }
992 return *this;
993 }
994
default_instance()995 static const OpPerformance_OpMemory& default_instance() {
996 return *internal_default_instance();
997 }
internal_default_instance()998 static inline const OpPerformance_OpMemory* internal_default_instance() {
999 return reinterpret_cast<const OpPerformance_OpMemory*>(
1000 &_OpPerformance_OpMemory_default_instance_);
1001 }
1002 static constexpr int kIndexInFileMessages =
1003 6;
1004
swap(OpPerformance_OpMemory & a,OpPerformance_OpMemory & b)1005 friend void swap(OpPerformance_OpMemory& a, OpPerformance_OpMemory& b) {
1006 a.Swap(&b);
1007 }
Swap(OpPerformance_OpMemory * other)1008 inline void Swap(OpPerformance_OpMemory* other) {
1009 if (other == this) return;
1010 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1011 if (GetOwningArena() != nullptr &&
1012 GetOwningArena() == other->GetOwningArena()) {
1013 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1014 if (GetOwningArena() == other->GetOwningArena()) {
1015 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1016 InternalSwap(other);
1017 } else {
1018 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1019 }
1020 }
1021 void UnsafeArenaSwap(OpPerformance_OpMemory* other) {
1022 if (other == this) return;
1023 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1024 InternalSwap(other);
1025 }
1026
1027 // implements Message ----------------------------------------------
1028
1029 OpPerformance_OpMemory* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1030 return CreateMaybeMessage<OpPerformance_OpMemory>(arena);
1031 }
1032 OpPerformance_OpMemory* New() const {
1033 return New(nullptr);
1034 }
1035 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1036 void CopyFrom(const OpPerformance_OpMemory& from);
1037 void MergeFrom(const OpPerformance_OpMemory& from);
1038 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1039 bool IsInitialized() const final;
1040
1041 size_t ByteSizeLong() const final;
1042 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1043 ::uint8_t* _InternalSerialize(
1044 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1045 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1046
1047 private:
1048 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1049 void SharedDtor();
1050 void SetCachedSize(int size) const;
1051 void InternalSwap(OpPerformance_OpMemory* other);
1052
1053 private:
1054 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1055 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1056 return "tensorflow.OpPerformance.OpMemory";
1057 }
1058 protected:
1059 explicit OpPerformance_OpMemory(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1060 bool is_message_owned = false);
1061 public:
1062
1063 std::string GetTypeName() const final;
1064
1065 // nested types ----------------------------------------------------
1066
1067 // accessors -------------------------------------------------------
1068
1069 enum : int {
1070 kOutputMemoryFieldNumber = 1,
1071 kTempMemoryFieldNumber = 2,
1072 kDeviceTempMemoryFieldNumber = 3,
1073 kPersistentMemoryFieldNumber = 4,
1074 kDevicePersistentMemoryFieldNumber = 5,
1075 };
1076 // repeated int64 output_memory = 1;
1077 int output_memory_size() const;
1078 private:
1079 int _internal_output_memory_size() const;
1080 public:
1081 void clear_output_memory();
1082 private:
1083 ::int64_t _internal_output_memory(int index) const;
1084 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >&
1085 _internal_output_memory() const;
1086 void _internal_add_output_memory(::int64_t value);
1087 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >*
1088 _internal_mutable_output_memory();
1089 public:
1090 ::int64_t output_memory(int index) const;
1091 void set_output_memory(int index, ::int64_t value);
1092 void add_output_memory(::int64_t value);
1093 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >&
1094 output_memory() const;
1095 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >*
1096 mutable_output_memory();
1097
1098 // int64 temp_memory = 2;
1099 void clear_temp_memory();
1100 ::int64_t temp_memory() const;
1101 void set_temp_memory(::int64_t value);
1102 private:
1103 ::int64_t _internal_temp_memory() const;
1104 void _internal_set_temp_memory(::int64_t value);
1105 public:
1106
1107 // int64 device_temp_memory = 3 [deprecated = true];
1108 PROTOBUF_DEPRECATED void clear_device_temp_memory();
1109 PROTOBUF_DEPRECATED ::int64_t device_temp_memory() const;
1110 PROTOBUF_DEPRECATED void set_device_temp_memory(::int64_t value);
1111 private:
1112 ::int64_t _internal_device_temp_memory() const;
1113 void _internal_set_device_temp_memory(::int64_t value);
1114 public:
1115
1116 // int64 persistent_memory = 4;
1117 void clear_persistent_memory();
1118 ::int64_t persistent_memory() const;
1119 void set_persistent_memory(::int64_t value);
1120 private:
1121 ::int64_t _internal_persistent_memory() const;
1122 void _internal_set_persistent_memory(::int64_t value);
1123 public:
1124
1125 // int64 device_persistent_memory = 5 [deprecated = true];
1126 PROTOBUF_DEPRECATED void clear_device_persistent_memory();
1127 PROTOBUF_DEPRECATED ::int64_t device_persistent_memory() const;
1128 PROTOBUF_DEPRECATED void set_device_persistent_memory(::int64_t value);
1129 private:
1130 ::int64_t _internal_device_persistent_memory() const;
1131 void _internal_set_device_persistent_memory(::int64_t value);
1132 public:
1133
1134 // @@protoc_insertion_point(class_scope:tensorflow.OpPerformance.OpMemory)
1135 private:
1136 class _Internal;
1137
1138 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1139 typedef void InternalArenaConstructable_;
1140 typedef void DestructorSkippable_;
1141 struct Impl_ {
1142 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t > output_memory_;
1143 mutable std::atomic<int> _output_memory_cached_byte_size_;
1144 ::int64_t temp_memory_;
1145 ::int64_t device_temp_memory_;
1146 ::int64_t persistent_memory_;
1147 ::int64_t device_persistent_memory_;
1148 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1149 };
1150 union { Impl_ _impl_; };
1151 friend struct ::TableStruct_tensorflow_2fcore_2fgrappler_2fcosts_2fop_5fperformance_5fdata_2eproto;
1152 };
1153 // -------------------------------------------------------------------
1154
1155 class OpPerformance final :
1156 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.OpPerformance) */ {
1157 public:
OpPerformance()1158 inline OpPerformance() : OpPerformance(nullptr) {}
1159 ~OpPerformance() override;
1160 explicit PROTOBUF_CONSTEXPR OpPerformance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1161
1162 OpPerformance(const OpPerformance& from);
OpPerformance(OpPerformance && from)1163 OpPerformance(OpPerformance&& from) noexcept
1164 : OpPerformance() {
1165 *this = ::std::move(from);
1166 }
1167
1168 inline OpPerformance& operator=(const OpPerformance& from) {
1169 if (this == &from) return *this;
1170 CopyFrom(from);
1171 return *this;
1172 }
1173 inline OpPerformance& operator=(OpPerformance&& from) noexcept {
1174 if (this == &from) return *this;
1175 if (GetOwningArena() == from.GetOwningArena()
1176 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1177 && GetOwningArena() != nullptr
1178 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1179 ) {
1180 InternalSwap(&from);
1181 } else {
1182 CopyFrom(from);
1183 }
1184 return *this;
1185 }
1186
default_instance()1187 static const OpPerformance& default_instance() {
1188 return *internal_default_instance();
1189 }
1190 enum ExecutionTimeCase {
1191 kExecutionTimeNormal = 10,
1192 kExecutionTimeLogNormal = 11,
1193 EXECUTION_TIME_NOT_SET = 0,
1194 };
1195
internal_default_instance()1196 static inline const OpPerformance* internal_default_instance() {
1197 return reinterpret_cast<const OpPerformance*>(
1198 &_OpPerformance_default_instance_);
1199 }
1200 static constexpr int kIndexInFileMessages =
1201 7;
1202
swap(OpPerformance & a,OpPerformance & b)1203 friend void swap(OpPerformance& a, OpPerformance& b) {
1204 a.Swap(&b);
1205 }
Swap(OpPerformance * other)1206 inline void Swap(OpPerformance* other) {
1207 if (other == this) return;
1208 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1209 if (GetOwningArena() != nullptr &&
1210 GetOwningArena() == other->GetOwningArena()) {
1211 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1212 if (GetOwningArena() == other->GetOwningArena()) {
1213 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1214 InternalSwap(other);
1215 } else {
1216 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1217 }
1218 }
1219 void UnsafeArenaSwap(OpPerformance* other) {
1220 if (other == this) return;
1221 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1222 InternalSwap(other);
1223 }
1224
1225 // implements Message ----------------------------------------------
1226
1227 OpPerformance* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1228 return CreateMaybeMessage<OpPerformance>(arena);
1229 }
1230 OpPerformance* New() const {
1231 return New(nullptr);
1232 }
1233 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1234 void CopyFrom(const OpPerformance& from);
1235 void MergeFrom(const OpPerformance& from);
1236 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1237 bool IsInitialized() const final;
1238
1239 size_t ByteSizeLong() const final;
1240 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1241 ::uint8_t* _InternalSerialize(
1242 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1243 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1244
1245 private:
1246 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1247 void SharedDtor();
1248 void SetCachedSize(int size) const;
1249 void InternalSwap(OpPerformance* other);
1250
1251 private:
1252 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1253 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1254 return "tensorflow.OpPerformance";
1255 }
1256 protected:
1257 explicit OpPerformance(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1258 bool is_message_owned = false);
1259 public:
1260
1261 std::string GetTypeName() const final;
1262
1263 // nested types ----------------------------------------------------
1264
1265 typedef OpPerformance_OpMemory OpMemory;
1266
1267 // accessors -------------------------------------------------------
1268
1269 enum : int {
1270 kNodeFieldNumber = 5,
1271 kOpFieldNumber = 1,
1272 kOpMemoryFieldNumber = 9,
1273 kSessionInfoFieldNumber = 12,
1274 kTemporaryMemorySizeFieldNumber = 2,
1275 kComputeCostFieldNumber = 3,
1276 kComputeEfficiencyFieldNumber = 4,
1277 kComputeTimeFieldNumber = 6,
1278 kMemoryTimeFieldNumber = 7,
1279 kMemoryEfficiencyFieldNumber = 8,
1280 kExecutionTimeNormalFieldNumber = 10,
1281 kExecutionTimeLogNormalFieldNumber = 11,
1282 };
1283 // string node = 5;
1284 void clear_node();
1285 const std::string& node() const;
1286 template <typename ArgT0 = const std::string&, typename... ArgT>
1287 void set_node(ArgT0&& arg0, ArgT... args);
1288 std::string* mutable_node();
1289 PROTOBUF_NODISCARD std::string* release_node();
1290 void set_allocated_node(std::string* node);
1291 private:
1292 const std::string& _internal_node() const;
1293 inline PROTOBUF_ALWAYS_INLINE void _internal_set_node(const std::string& value);
1294 std::string* _internal_mutable_node();
1295 public:
1296
1297 // .tensorflow.OpInfo op = 1;
1298 bool has_op() const;
1299 private:
1300 bool _internal_has_op() const;
1301 public:
1302 void clear_op();
1303 const ::tensorflow::OpInfo& op() const;
1304 PROTOBUF_NODISCARD ::tensorflow::OpInfo* release_op();
1305 ::tensorflow::OpInfo* mutable_op();
1306 void set_allocated_op(::tensorflow::OpInfo* op);
1307 private:
1308 const ::tensorflow::OpInfo& _internal_op() const;
1309 ::tensorflow::OpInfo* _internal_mutable_op();
1310 public:
1311 void unsafe_arena_set_allocated_op(
1312 ::tensorflow::OpInfo* op);
1313 ::tensorflow::OpInfo* unsafe_arena_release_op();
1314
1315 // .tensorflow.OpPerformance.OpMemory op_memory = 9;
1316 bool has_op_memory() const;
1317 private:
1318 bool _internal_has_op_memory() const;
1319 public:
1320 void clear_op_memory();
1321 const ::tensorflow::OpPerformance_OpMemory& op_memory() const;
1322 PROTOBUF_NODISCARD ::tensorflow::OpPerformance_OpMemory* release_op_memory();
1323 ::tensorflow::OpPerformance_OpMemory* mutable_op_memory();
1324 void set_allocated_op_memory(::tensorflow::OpPerformance_OpMemory* op_memory);
1325 private:
1326 const ::tensorflow::OpPerformance_OpMemory& _internal_op_memory() const;
1327 ::tensorflow::OpPerformance_OpMemory* _internal_mutable_op_memory();
1328 public:
1329 void unsafe_arena_set_allocated_op_memory(
1330 ::tensorflow::OpPerformance_OpMemory* op_memory);
1331 ::tensorflow::OpPerformance_OpMemory* unsafe_arena_release_op_memory();
1332
1333 // .tensorflow.SessionInfo session_info = 12 [deprecated = true];
1334 PROTOBUF_DEPRECATED bool has_session_info() const;
1335 private:
1336 bool _internal_has_session_info() const;
1337 public:
1338 PROTOBUF_DEPRECATED void clear_session_info();
1339 PROTOBUF_DEPRECATED const ::tensorflow::SessionInfo& session_info() const;
1340 PROTOBUF_NODISCARD PROTOBUF_DEPRECATED ::tensorflow::SessionInfo* release_session_info();
1341 PROTOBUF_DEPRECATED ::tensorflow::SessionInfo* mutable_session_info();
1342 PROTOBUF_DEPRECATED void set_allocated_session_info(::tensorflow::SessionInfo* session_info);
1343 private:
1344 const ::tensorflow::SessionInfo& _internal_session_info() const;
1345 ::tensorflow::SessionInfo* _internal_mutable_session_info();
1346 public:
1347 PROTOBUF_DEPRECATED void unsafe_arena_set_allocated_session_info(
1348 ::tensorflow::SessionInfo* session_info);
1349 PROTOBUF_DEPRECATED ::tensorflow::SessionInfo* unsafe_arena_release_session_info();
1350
1351 // int64 temporary_memory_size = 2;
1352 void clear_temporary_memory_size();
1353 ::int64_t temporary_memory_size() const;
1354 void set_temporary_memory_size(::int64_t value);
1355 private:
1356 ::int64_t _internal_temporary_memory_size() const;
1357 void _internal_set_temporary_memory_size(::int64_t value);
1358 public:
1359
1360 // int64 compute_cost = 3;
1361 void clear_compute_cost();
1362 ::int64_t compute_cost() const;
1363 void set_compute_cost(::int64_t value);
1364 private:
1365 ::int64_t _internal_compute_cost() const;
1366 void _internal_set_compute_cost(::int64_t value);
1367 public:
1368
1369 // double compute_efficiency = 4;
1370 void clear_compute_efficiency();
1371 double compute_efficiency() const;
1372 void set_compute_efficiency(double value);
1373 private:
1374 double _internal_compute_efficiency() const;
1375 void _internal_set_compute_efficiency(double value);
1376 public:
1377
1378 // int64 compute_time = 6;
1379 void clear_compute_time();
1380 ::int64_t compute_time() const;
1381 void set_compute_time(::int64_t value);
1382 private:
1383 ::int64_t _internal_compute_time() const;
1384 void _internal_set_compute_time(::int64_t value);
1385 public:
1386
1387 // int64 memory_time = 7;
1388 void clear_memory_time();
1389 ::int64_t memory_time() const;
1390 void set_memory_time(::int64_t value);
1391 private:
1392 ::int64_t _internal_memory_time() const;
1393 void _internal_set_memory_time(::int64_t value);
1394 public:
1395
1396 // double memory_efficiency = 8;
1397 void clear_memory_efficiency();
1398 double memory_efficiency() const;
1399 void set_memory_efficiency(double value);
1400 private:
1401 double _internal_memory_efficiency() const;
1402 void _internal_set_memory_efficiency(double value);
1403 public:
1404
1405 // .tensorflow.NormalDistribution execution_time_normal = 10;
1406 bool has_execution_time_normal() const;
1407 private:
1408 bool _internal_has_execution_time_normal() const;
1409 public:
1410 void clear_execution_time_normal();
1411 const ::tensorflow::NormalDistribution& execution_time_normal() const;
1412 PROTOBUF_NODISCARD ::tensorflow::NormalDistribution* release_execution_time_normal();
1413 ::tensorflow::NormalDistribution* mutable_execution_time_normal();
1414 void set_allocated_execution_time_normal(::tensorflow::NormalDistribution* execution_time_normal);
1415 private:
1416 const ::tensorflow::NormalDistribution& _internal_execution_time_normal() const;
1417 ::tensorflow::NormalDistribution* _internal_mutable_execution_time_normal();
1418 public:
1419 void unsafe_arena_set_allocated_execution_time_normal(
1420 ::tensorflow::NormalDistribution* execution_time_normal);
1421 ::tensorflow::NormalDistribution* unsafe_arena_release_execution_time_normal();
1422
1423 // .tensorflow.LogNormalDistribution execution_time_log_normal = 11;
1424 bool has_execution_time_log_normal() const;
1425 private:
1426 bool _internal_has_execution_time_log_normal() const;
1427 public:
1428 void clear_execution_time_log_normal();
1429 const ::tensorflow::LogNormalDistribution& execution_time_log_normal() const;
1430 PROTOBUF_NODISCARD ::tensorflow::LogNormalDistribution* release_execution_time_log_normal();
1431 ::tensorflow::LogNormalDistribution* mutable_execution_time_log_normal();
1432 void set_allocated_execution_time_log_normal(::tensorflow::LogNormalDistribution* execution_time_log_normal);
1433 private:
1434 const ::tensorflow::LogNormalDistribution& _internal_execution_time_log_normal() const;
1435 ::tensorflow::LogNormalDistribution* _internal_mutable_execution_time_log_normal();
1436 public:
1437 void unsafe_arena_set_allocated_execution_time_log_normal(
1438 ::tensorflow::LogNormalDistribution* execution_time_log_normal);
1439 ::tensorflow::LogNormalDistribution* unsafe_arena_release_execution_time_log_normal();
1440
1441 void clear_execution_time();
1442 ExecutionTimeCase execution_time_case() const;
1443 // @@protoc_insertion_point(class_scope:tensorflow.OpPerformance)
1444 private:
1445 class _Internal;
1446 void set_has_execution_time_normal();
1447 void set_has_execution_time_log_normal();
1448
1449 inline bool has_execution_time() const;
1450 inline void clear_has_execution_time();
1451
1452 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1453 typedef void InternalArenaConstructable_;
1454 typedef void DestructorSkippable_;
1455 struct Impl_ {
1456 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr node_;
1457 ::tensorflow::OpInfo* op_;
1458 ::tensorflow::OpPerformance_OpMemory* op_memory_;
1459 ::tensorflow::SessionInfo* session_info_;
1460 ::int64_t temporary_memory_size_;
1461 ::int64_t compute_cost_;
1462 double compute_efficiency_;
1463 ::int64_t compute_time_;
1464 ::int64_t memory_time_;
1465 double memory_efficiency_;
1466 union ExecutionTimeUnion {
1467 constexpr ExecutionTimeUnion() : _constinit_{} {}
1468 ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
1469 ::tensorflow::NormalDistribution* execution_time_normal_;
1470 ::tensorflow::LogNormalDistribution* execution_time_log_normal_;
1471 } execution_time_;
1472 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1473 ::uint32_t _oneof_case_[1];
1474
1475 };
1476 union { Impl_ _impl_; };
1477 friend struct ::TableStruct_tensorflow_2fcore_2fgrappler_2fcosts_2fop_5fperformance_5fdata_2eproto;
1478 };
1479 // -------------------------------------------------------------------
1480
1481 class OpPerformanceList final :
1482 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.OpPerformanceList) */ {
1483 public:
OpPerformanceList()1484 inline OpPerformanceList() : OpPerformanceList(nullptr) {}
1485 ~OpPerformanceList() override;
1486 explicit PROTOBUF_CONSTEXPR OpPerformanceList(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1487
1488 OpPerformanceList(const OpPerformanceList& from);
OpPerformanceList(OpPerformanceList && from)1489 OpPerformanceList(OpPerformanceList&& from) noexcept
1490 : OpPerformanceList() {
1491 *this = ::std::move(from);
1492 }
1493
1494 inline OpPerformanceList& operator=(const OpPerformanceList& from) {
1495 if (this == &from) return *this;
1496 CopyFrom(from);
1497 return *this;
1498 }
1499 inline OpPerformanceList& operator=(OpPerformanceList&& from) noexcept {
1500 if (this == &from) return *this;
1501 if (GetOwningArena() == from.GetOwningArena()
1502 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1503 && GetOwningArena() != nullptr
1504 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1505 ) {
1506 InternalSwap(&from);
1507 } else {
1508 CopyFrom(from);
1509 }
1510 return *this;
1511 }
1512
default_instance()1513 static const OpPerformanceList& default_instance() {
1514 return *internal_default_instance();
1515 }
internal_default_instance()1516 static inline const OpPerformanceList* internal_default_instance() {
1517 return reinterpret_cast<const OpPerformanceList*>(
1518 &_OpPerformanceList_default_instance_);
1519 }
1520 static constexpr int kIndexInFileMessages =
1521 8;
1522
swap(OpPerformanceList & a,OpPerformanceList & b)1523 friend void swap(OpPerformanceList& a, OpPerformanceList& b) {
1524 a.Swap(&b);
1525 }
Swap(OpPerformanceList * other)1526 inline void Swap(OpPerformanceList* other) {
1527 if (other == this) return;
1528 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1529 if (GetOwningArena() != nullptr &&
1530 GetOwningArena() == other->GetOwningArena()) {
1531 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1532 if (GetOwningArena() == other->GetOwningArena()) {
1533 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1534 InternalSwap(other);
1535 } else {
1536 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1537 }
1538 }
1539 void UnsafeArenaSwap(OpPerformanceList* other) {
1540 if (other == this) return;
1541 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1542 InternalSwap(other);
1543 }
1544
1545 // implements Message ----------------------------------------------
1546
1547 OpPerformanceList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1548 return CreateMaybeMessage<OpPerformanceList>(arena);
1549 }
1550 OpPerformanceList* New() const {
1551 return New(nullptr);
1552 }
1553 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1554 void CopyFrom(const OpPerformanceList& from);
1555 void MergeFrom(const OpPerformanceList& from);
1556 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1557 bool IsInitialized() const final;
1558
1559 size_t ByteSizeLong() const final;
1560 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1561 ::uint8_t* _InternalSerialize(
1562 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1563 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1564
1565 private:
1566 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1567 void SharedDtor();
1568 void SetCachedSize(int size) const;
1569 void InternalSwap(OpPerformanceList* other);
1570
1571 private:
1572 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1573 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1574 return "tensorflow.OpPerformanceList";
1575 }
1576 protected:
1577 explicit OpPerformanceList(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1578 bool is_message_owned = false);
1579 public:
1580
1581 std::string GetTypeName() const final;
1582
1583 // nested types ----------------------------------------------------
1584
1585 // accessors -------------------------------------------------------
1586
1587 enum : int {
1588 kOpPerformanceFieldNumber = 1,
1589 };
1590 // repeated .tensorflow.OpPerformance op_performance = 1;
1591 int op_performance_size() const;
1592 private:
1593 int _internal_op_performance_size() const;
1594 public:
1595 void clear_op_performance();
1596 ::tensorflow::OpPerformance* mutable_op_performance(int index);
1597 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpPerformance >*
1598 mutable_op_performance();
1599 private:
1600 const ::tensorflow::OpPerformance& _internal_op_performance(int index) const;
1601 ::tensorflow::OpPerformance* _internal_add_op_performance();
1602 public:
1603 const ::tensorflow::OpPerformance& op_performance(int index) const;
1604 ::tensorflow::OpPerformance* add_op_performance();
1605 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpPerformance >&
1606 op_performance() const;
1607
1608 // @@protoc_insertion_point(class_scope:tensorflow.OpPerformanceList)
1609 private:
1610 class _Internal;
1611
1612 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1613 typedef void InternalArenaConstructable_;
1614 typedef void DestructorSkippable_;
1615 struct Impl_ {
1616 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpPerformance > op_performance_;
1617 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1618 };
1619 union { Impl_ _impl_; };
1620 friend struct ::TableStruct_tensorflow_2fcore_2fgrappler_2fcosts_2fop_5fperformance_5fdata_2eproto;
1621 };
1622 // ===================================================================
1623
1624
1625 // ===================================================================
1626
1627 #ifdef __GNUC__
1628 #pragma GCC diagnostic push
1629 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
1630 #endif // __GNUC__
1631 // SessionInfo
1632
1633 // int64 intra_op_parallelism = 1;
clear_intra_op_parallelism()1634 inline void SessionInfo::clear_intra_op_parallelism() {
1635 _impl_.intra_op_parallelism_ = ::int64_t{0};
1636 }
_internal_intra_op_parallelism()1637 inline ::int64_t SessionInfo::_internal_intra_op_parallelism() const {
1638 return _impl_.intra_op_parallelism_;
1639 }
intra_op_parallelism()1640 inline ::int64_t SessionInfo::intra_op_parallelism() const {
1641 // @@protoc_insertion_point(field_get:tensorflow.SessionInfo.intra_op_parallelism)
1642 return _internal_intra_op_parallelism();
1643 }
_internal_set_intra_op_parallelism(::int64_t value)1644 inline void SessionInfo::_internal_set_intra_op_parallelism(::int64_t value) {
1645
1646 _impl_.intra_op_parallelism_ = value;
1647 }
set_intra_op_parallelism(::int64_t value)1648 inline void SessionInfo::set_intra_op_parallelism(::int64_t value) {
1649 _internal_set_intra_op_parallelism(value);
1650 // @@protoc_insertion_point(field_set:tensorflow.SessionInfo.intra_op_parallelism)
1651 }
1652
1653 // -------------------------------------------------------------------
1654
1655 // -------------------------------------------------------------------
1656
1657 // OpInfo_TensorProperties
1658
1659 // .tensorflow.DataType dtype = 1;
clear_dtype()1660 inline void OpInfo_TensorProperties::clear_dtype() {
1661 _impl_.dtype_ = 0;
1662 }
_internal_dtype()1663 inline ::tensorflow::DataType OpInfo_TensorProperties::_internal_dtype() const {
1664 return static_cast< ::tensorflow::DataType >(_impl_.dtype_);
1665 }
dtype()1666 inline ::tensorflow::DataType OpInfo_TensorProperties::dtype() const {
1667 // @@protoc_insertion_point(field_get:tensorflow.OpInfo.TensorProperties.dtype)
1668 return _internal_dtype();
1669 }
_internal_set_dtype(::tensorflow::DataType value)1670 inline void OpInfo_TensorProperties::_internal_set_dtype(::tensorflow::DataType value) {
1671
1672 _impl_.dtype_ = value;
1673 }
set_dtype(::tensorflow::DataType value)1674 inline void OpInfo_TensorProperties::set_dtype(::tensorflow::DataType value) {
1675 _internal_set_dtype(value);
1676 // @@protoc_insertion_point(field_set:tensorflow.OpInfo.TensorProperties.dtype)
1677 }
1678
1679 // .tensorflow.TensorShapeProto shape = 2;
_internal_has_shape()1680 inline bool OpInfo_TensorProperties::_internal_has_shape() const {
1681 return this != internal_default_instance() && _impl_.shape_ != nullptr;
1682 }
has_shape()1683 inline bool OpInfo_TensorProperties::has_shape() const {
1684 return _internal_has_shape();
1685 }
_internal_shape()1686 inline const ::tensorflow::TensorShapeProto& OpInfo_TensorProperties::_internal_shape() const {
1687 const ::tensorflow::TensorShapeProto* p = _impl_.shape_;
1688 return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::TensorShapeProto&>(
1689 ::tensorflow::_TensorShapeProto_default_instance_);
1690 }
shape()1691 inline const ::tensorflow::TensorShapeProto& OpInfo_TensorProperties::shape() const {
1692 // @@protoc_insertion_point(field_get:tensorflow.OpInfo.TensorProperties.shape)
1693 return _internal_shape();
1694 }
unsafe_arena_set_allocated_shape(::tensorflow::TensorShapeProto * shape)1695 inline void OpInfo_TensorProperties::unsafe_arena_set_allocated_shape(
1696 ::tensorflow::TensorShapeProto* shape) {
1697 if (GetArenaForAllocation() == nullptr) {
1698 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.shape_);
1699 }
1700 _impl_.shape_ = shape;
1701 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.OpInfo.TensorProperties.shape)
1702 }
release_shape()1703 inline ::tensorflow::TensorShapeProto* OpInfo_TensorProperties::release_shape() {
1704
1705 ::tensorflow::TensorShapeProto* temp = _impl_.shape_;
1706 _impl_.shape_ = nullptr;
1707 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
1708 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
1709 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1710 if (GetArenaForAllocation() == nullptr) { delete old; }
1711 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
1712 if (GetArenaForAllocation() != nullptr) {
1713 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1714 }
1715 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
1716 return temp;
1717 }
unsafe_arena_release_shape()1718 inline ::tensorflow::TensorShapeProto* OpInfo_TensorProperties::unsafe_arena_release_shape() {
1719 // @@protoc_insertion_point(field_release:tensorflow.OpInfo.TensorProperties.shape)
1720
1721 ::tensorflow::TensorShapeProto* temp = _impl_.shape_;
1722 _impl_.shape_ = nullptr;
1723 return temp;
1724 }
_internal_mutable_shape()1725 inline ::tensorflow::TensorShapeProto* OpInfo_TensorProperties::_internal_mutable_shape() {
1726
1727 if (_impl_.shape_ == nullptr) {
1728 auto* p = CreateMaybeMessage<::tensorflow::TensorShapeProto>(GetArenaForAllocation());
1729 _impl_.shape_ = p;
1730 }
1731 return _impl_.shape_;
1732 }
mutable_shape()1733 inline ::tensorflow::TensorShapeProto* OpInfo_TensorProperties::mutable_shape() {
1734 ::tensorflow::TensorShapeProto* _msg = _internal_mutable_shape();
1735 // @@protoc_insertion_point(field_mutable:tensorflow.OpInfo.TensorProperties.shape)
1736 return _msg;
1737 }
set_allocated_shape(::tensorflow::TensorShapeProto * shape)1738 inline void OpInfo_TensorProperties::set_allocated_shape(::tensorflow::TensorShapeProto* shape) {
1739 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
1740 if (message_arena == nullptr) {
1741 delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.shape_);
1742 }
1743 if (shape) {
1744 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
1745 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
1746 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(shape));
1747 if (message_arena != submessage_arena) {
1748 shape = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
1749 message_arena, shape, submessage_arena);
1750 }
1751
1752 } else {
1753
1754 }
1755 _impl_.shape_ = shape;
1756 // @@protoc_insertion_point(field_set_allocated:tensorflow.OpInfo.TensorProperties.shape)
1757 }
1758
1759 // .tensorflow.TensorProto value = 3;
_internal_has_value()1760 inline bool OpInfo_TensorProperties::_internal_has_value() const {
1761 return this != internal_default_instance() && _impl_.value_ != nullptr;
1762 }
has_value()1763 inline bool OpInfo_TensorProperties::has_value() const {
1764 return _internal_has_value();
1765 }
_internal_value()1766 inline const ::tensorflow::TensorProto& OpInfo_TensorProperties::_internal_value() const {
1767 const ::tensorflow::TensorProto* p = _impl_.value_;
1768 return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::TensorProto&>(
1769 ::tensorflow::_TensorProto_default_instance_);
1770 }
value()1771 inline const ::tensorflow::TensorProto& OpInfo_TensorProperties::value() const {
1772 // @@protoc_insertion_point(field_get:tensorflow.OpInfo.TensorProperties.value)
1773 return _internal_value();
1774 }
unsafe_arena_set_allocated_value(::tensorflow::TensorProto * value)1775 inline void OpInfo_TensorProperties::unsafe_arena_set_allocated_value(
1776 ::tensorflow::TensorProto* value) {
1777 if (GetArenaForAllocation() == nullptr) {
1778 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.value_);
1779 }
1780 _impl_.value_ = value;
1781 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.OpInfo.TensorProperties.value)
1782 }
release_value()1783 inline ::tensorflow::TensorProto* OpInfo_TensorProperties::release_value() {
1784
1785 ::tensorflow::TensorProto* temp = _impl_.value_;
1786 _impl_.value_ = nullptr;
1787 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
1788 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
1789 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1790 if (GetArenaForAllocation() == nullptr) { delete old; }
1791 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
1792 if (GetArenaForAllocation() != nullptr) {
1793 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1794 }
1795 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
1796 return temp;
1797 }
unsafe_arena_release_value()1798 inline ::tensorflow::TensorProto* OpInfo_TensorProperties::unsafe_arena_release_value() {
1799 // @@protoc_insertion_point(field_release:tensorflow.OpInfo.TensorProperties.value)
1800
1801 ::tensorflow::TensorProto* temp = _impl_.value_;
1802 _impl_.value_ = nullptr;
1803 return temp;
1804 }
_internal_mutable_value()1805 inline ::tensorflow::TensorProto* OpInfo_TensorProperties::_internal_mutable_value() {
1806
1807 if (_impl_.value_ == nullptr) {
1808 auto* p = CreateMaybeMessage<::tensorflow::TensorProto>(GetArenaForAllocation());
1809 _impl_.value_ = p;
1810 }
1811 return _impl_.value_;
1812 }
mutable_value()1813 inline ::tensorflow::TensorProto* OpInfo_TensorProperties::mutable_value() {
1814 ::tensorflow::TensorProto* _msg = _internal_mutable_value();
1815 // @@protoc_insertion_point(field_mutable:tensorflow.OpInfo.TensorProperties.value)
1816 return _msg;
1817 }
set_allocated_value(::tensorflow::TensorProto * value)1818 inline void OpInfo_TensorProperties::set_allocated_value(::tensorflow::TensorProto* value) {
1819 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
1820 if (message_arena == nullptr) {
1821 delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.value_);
1822 }
1823 if (value) {
1824 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
1825 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
1826 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(value));
1827 if (message_arena != submessage_arena) {
1828 value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
1829 message_arena, value, submessage_arena);
1830 }
1831
1832 } else {
1833
1834 }
1835 _impl_.value_ = value;
1836 // @@protoc_insertion_point(field_set_allocated:tensorflow.OpInfo.TensorProperties.value)
1837 }
1838
1839 // -------------------------------------------------------------------
1840
1841 // OpInfo
1842
1843 // string op = 1;
clear_op()1844 inline void OpInfo::clear_op() {
1845 _impl_.op_.ClearToEmpty();
1846 }
op()1847 inline const std::string& OpInfo::op() const {
1848 // @@protoc_insertion_point(field_get:tensorflow.OpInfo.op)
1849 return _internal_op();
1850 }
1851 template <typename ArgT0, typename... ArgT>
1852 inline PROTOBUF_ALWAYS_INLINE
set_op(ArgT0 && arg0,ArgT...args)1853 void OpInfo::set_op(ArgT0&& arg0, ArgT... args) {
1854
1855 _impl_.op_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1856 // @@protoc_insertion_point(field_set:tensorflow.OpInfo.op)
1857 }
mutable_op()1858 inline std::string* OpInfo::mutable_op() {
1859 std::string* _s = _internal_mutable_op();
1860 // @@protoc_insertion_point(field_mutable:tensorflow.OpInfo.op)
1861 return _s;
1862 }
_internal_op()1863 inline const std::string& OpInfo::_internal_op() const {
1864 return _impl_.op_.Get();
1865 }
_internal_set_op(const std::string & value)1866 inline void OpInfo::_internal_set_op(const std::string& value) {
1867
1868 _impl_.op_.Set(value, GetArenaForAllocation());
1869 }
_internal_mutable_op()1870 inline std::string* OpInfo::_internal_mutable_op() {
1871
1872 return _impl_.op_.Mutable(GetArenaForAllocation());
1873 }
release_op()1874 inline std::string* OpInfo::release_op() {
1875 // @@protoc_insertion_point(field_release:tensorflow.OpInfo.op)
1876 return _impl_.op_.Release();
1877 }
set_allocated_op(std::string * op)1878 inline void OpInfo::set_allocated_op(std::string* op) {
1879 _impl_.op_.SetAllocated(op, GetArenaForAllocation());
1880 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1881 if (_impl_.op_.IsDefault()) {
1882 _impl_.op_.Set("", GetArenaForAllocation());
1883 }
1884 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1885 // @@protoc_insertion_point(field_set_allocated:tensorflow.OpInfo.op)
1886 }
1887
1888 // map<string, .tensorflow.AttrValue> attr = 2;
_internal_attr_size()1889 inline int OpInfo::_internal_attr_size() const {
1890 return _impl_.attr_.size();
1891 }
attr_size()1892 inline int OpInfo::attr_size() const {
1893 return _internal_attr_size();
1894 }
1895 inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::AttrValue >&
_internal_attr()1896 OpInfo::_internal_attr() const {
1897 return _impl_.attr_.GetMap();
1898 }
1899 inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::AttrValue >&
attr()1900 OpInfo::attr() const {
1901 // @@protoc_insertion_point(field_map:tensorflow.OpInfo.attr)
1902 return _internal_attr();
1903 }
1904 inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::AttrValue >*
_internal_mutable_attr()1905 OpInfo::_internal_mutable_attr() {
1906 return _impl_.attr_.MutableMap();
1907 }
1908 inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::AttrValue >*
mutable_attr()1909 OpInfo::mutable_attr() {
1910 // @@protoc_insertion_point(field_mutable_map:tensorflow.OpInfo.attr)
1911 return _internal_mutable_attr();
1912 }
1913
1914 // repeated .tensorflow.OpInfo.TensorProperties inputs = 3;
_internal_inputs_size()1915 inline int OpInfo::_internal_inputs_size() const {
1916 return _impl_.inputs_.size();
1917 }
inputs_size()1918 inline int OpInfo::inputs_size() const {
1919 return _internal_inputs_size();
1920 }
clear_inputs()1921 inline void OpInfo::clear_inputs() {
1922 _impl_.inputs_.Clear();
1923 }
mutable_inputs(int index)1924 inline ::tensorflow::OpInfo_TensorProperties* OpInfo::mutable_inputs(int index) {
1925 // @@protoc_insertion_point(field_mutable:tensorflow.OpInfo.inputs)
1926 return _impl_.inputs_.Mutable(index);
1927 }
1928 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpInfo_TensorProperties >*
mutable_inputs()1929 OpInfo::mutable_inputs() {
1930 // @@protoc_insertion_point(field_mutable_list:tensorflow.OpInfo.inputs)
1931 return &_impl_.inputs_;
1932 }
_internal_inputs(int index)1933 inline const ::tensorflow::OpInfo_TensorProperties& OpInfo::_internal_inputs(int index) const {
1934 return _impl_.inputs_.Get(index);
1935 }
inputs(int index)1936 inline const ::tensorflow::OpInfo_TensorProperties& OpInfo::inputs(int index) const {
1937 // @@protoc_insertion_point(field_get:tensorflow.OpInfo.inputs)
1938 return _internal_inputs(index);
1939 }
_internal_add_inputs()1940 inline ::tensorflow::OpInfo_TensorProperties* OpInfo::_internal_add_inputs() {
1941 return _impl_.inputs_.Add();
1942 }
add_inputs()1943 inline ::tensorflow::OpInfo_TensorProperties* OpInfo::add_inputs() {
1944 ::tensorflow::OpInfo_TensorProperties* _add = _internal_add_inputs();
1945 // @@protoc_insertion_point(field_add:tensorflow.OpInfo.inputs)
1946 return _add;
1947 }
1948 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpInfo_TensorProperties >&
inputs()1949 OpInfo::inputs() const {
1950 // @@protoc_insertion_point(field_list:tensorflow.OpInfo.inputs)
1951 return _impl_.inputs_;
1952 }
1953
1954 // repeated .tensorflow.OpInfo.TensorProperties outputs = 5;
_internal_outputs_size()1955 inline int OpInfo::_internal_outputs_size() const {
1956 return _impl_.outputs_.size();
1957 }
outputs_size()1958 inline int OpInfo::outputs_size() const {
1959 return _internal_outputs_size();
1960 }
clear_outputs()1961 inline void OpInfo::clear_outputs() {
1962 _impl_.outputs_.Clear();
1963 }
mutable_outputs(int index)1964 inline ::tensorflow::OpInfo_TensorProperties* OpInfo::mutable_outputs(int index) {
1965 // @@protoc_insertion_point(field_mutable:tensorflow.OpInfo.outputs)
1966 return _impl_.outputs_.Mutable(index);
1967 }
1968 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpInfo_TensorProperties >*
mutable_outputs()1969 OpInfo::mutable_outputs() {
1970 // @@protoc_insertion_point(field_mutable_list:tensorflow.OpInfo.outputs)
1971 return &_impl_.outputs_;
1972 }
_internal_outputs(int index)1973 inline const ::tensorflow::OpInfo_TensorProperties& OpInfo::_internal_outputs(int index) const {
1974 return _impl_.outputs_.Get(index);
1975 }
outputs(int index)1976 inline const ::tensorflow::OpInfo_TensorProperties& OpInfo::outputs(int index) const {
1977 // @@protoc_insertion_point(field_get:tensorflow.OpInfo.outputs)
1978 return _internal_outputs(index);
1979 }
_internal_add_outputs()1980 inline ::tensorflow::OpInfo_TensorProperties* OpInfo::_internal_add_outputs() {
1981 return _impl_.outputs_.Add();
1982 }
add_outputs()1983 inline ::tensorflow::OpInfo_TensorProperties* OpInfo::add_outputs() {
1984 ::tensorflow::OpInfo_TensorProperties* _add = _internal_add_outputs();
1985 // @@protoc_insertion_point(field_add:tensorflow.OpInfo.outputs)
1986 return _add;
1987 }
1988 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpInfo_TensorProperties >&
outputs()1989 OpInfo::outputs() const {
1990 // @@protoc_insertion_point(field_list:tensorflow.OpInfo.outputs)
1991 return _impl_.outputs_;
1992 }
1993
1994 // .tensorflow.DeviceProperties device = 4;
_internal_has_device()1995 inline bool OpInfo::_internal_has_device() const {
1996 return this != internal_default_instance() && _impl_.device_ != nullptr;
1997 }
has_device()1998 inline bool OpInfo::has_device() const {
1999 return _internal_has_device();
2000 }
_internal_device()2001 inline const ::tensorflow::DeviceProperties& OpInfo::_internal_device() const {
2002 const ::tensorflow::DeviceProperties* p = _impl_.device_;
2003 return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::DeviceProperties&>(
2004 ::tensorflow::_DeviceProperties_default_instance_);
2005 }
device()2006 inline const ::tensorflow::DeviceProperties& OpInfo::device() const {
2007 // @@protoc_insertion_point(field_get:tensorflow.OpInfo.device)
2008 return _internal_device();
2009 }
unsafe_arena_set_allocated_device(::tensorflow::DeviceProperties * device)2010 inline void OpInfo::unsafe_arena_set_allocated_device(
2011 ::tensorflow::DeviceProperties* device) {
2012 if (GetArenaForAllocation() == nullptr) {
2013 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.device_);
2014 }
2015 _impl_.device_ = device;
2016 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.OpInfo.device)
2017 }
release_device()2018 inline ::tensorflow::DeviceProperties* OpInfo::release_device() {
2019
2020 ::tensorflow::DeviceProperties* temp = _impl_.device_;
2021 _impl_.device_ = nullptr;
2022 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
2023 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
2024 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2025 if (GetArenaForAllocation() == nullptr) { delete old; }
2026 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
2027 if (GetArenaForAllocation() != nullptr) {
2028 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2029 }
2030 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
2031 return temp;
2032 }
unsafe_arena_release_device()2033 inline ::tensorflow::DeviceProperties* OpInfo::unsafe_arena_release_device() {
2034 // @@protoc_insertion_point(field_release:tensorflow.OpInfo.device)
2035
2036 ::tensorflow::DeviceProperties* temp = _impl_.device_;
2037 _impl_.device_ = nullptr;
2038 return temp;
2039 }
_internal_mutable_device()2040 inline ::tensorflow::DeviceProperties* OpInfo::_internal_mutable_device() {
2041
2042 if (_impl_.device_ == nullptr) {
2043 auto* p = CreateMaybeMessage<::tensorflow::DeviceProperties>(GetArenaForAllocation());
2044 _impl_.device_ = p;
2045 }
2046 return _impl_.device_;
2047 }
mutable_device()2048 inline ::tensorflow::DeviceProperties* OpInfo::mutable_device() {
2049 ::tensorflow::DeviceProperties* _msg = _internal_mutable_device();
2050 // @@protoc_insertion_point(field_mutable:tensorflow.OpInfo.device)
2051 return _msg;
2052 }
set_allocated_device(::tensorflow::DeviceProperties * device)2053 inline void OpInfo::set_allocated_device(::tensorflow::DeviceProperties* device) {
2054 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
2055 if (message_arena == nullptr) {
2056 delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.device_);
2057 }
2058 if (device) {
2059 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
2060 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
2061 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(device));
2062 if (message_arena != submessage_arena) {
2063 device = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
2064 message_arena, device, submessage_arena);
2065 }
2066
2067 } else {
2068
2069 }
2070 _impl_.device_ = device;
2071 // @@protoc_insertion_point(field_set_allocated:tensorflow.OpInfo.device)
2072 }
2073
2074 // .tensorflow.SessionInfo session_info = 6;
_internal_has_session_info()2075 inline bool OpInfo::_internal_has_session_info() const {
2076 return this != internal_default_instance() && _impl_.session_info_ != nullptr;
2077 }
has_session_info()2078 inline bool OpInfo::has_session_info() const {
2079 return _internal_has_session_info();
2080 }
clear_session_info()2081 inline void OpInfo::clear_session_info() {
2082 if (GetArenaForAllocation() == nullptr && _impl_.session_info_ != nullptr) {
2083 delete _impl_.session_info_;
2084 }
2085 _impl_.session_info_ = nullptr;
2086 }
_internal_session_info()2087 inline const ::tensorflow::SessionInfo& OpInfo::_internal_session_info() const {
2088 const ::tensorflow::SessionInfo* p = _impl_.session_info_;
2089 return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::SessionInfo&>(
2090 ::tensorflow::_SessionInfo_default_instance_);
2091 }
session_info()2092 inline const ::tensorflow::SessionInfo& OpInfo::session_info() const {
2093 // @@protoc_insertion_point(field_get:tensorflow.OpInfo.session_info)
2094 return _internal_session_info();
2095 }
unsafe_arena_set_allocated_session_info(::tensorflow::SessionInfo * session_info)2096 inline void OpInfo::unsafe_arena_set_allocated_session_info(
2097 ::tensorflow::SessionInfo* session_info) {
2098 if (GetArenaForAllocation() == nullptr) {
2099 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.session_info_);
2100 }
2101 _impl_.session_info_ = session_info;
2102 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.OpInfo.session_info)
2103 }
release_session_info()2104 inline ::tensorflow::SessionInfo* OpInfo::release_session_info() {
2105
2106 ::tensorflow::SessionInfo* temp = _impl_.session_info_;
2107 _impl_.session_info_ = nullptr;
2108 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
2109 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
2110 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2111 if (GetArenaForAllocation() == nullptr) { delete old; }
2112 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
2113 if (GetArenaForAllocation() != nullptr) {
2114 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2115 }
2116 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
2117 return temp;
2118 }
unsafe_arena_release_session_info()2119 inline ::tensorflow::SessionInfo* OpInfo::unsafe_arena_release_session_info() {
2120 // @@protoc_insertion_point(field_release:tensorflow.OpInfo.session_info)
2121
2122 ::tensorflow::SessionInfo* temp = _impl_.session_info_;
2123 _impl_.session_info_ = nullptr;
2124 return temp;
2125 }
_internal_mutable_session_info()2126 inline ::tensorflow::SessionInfo* OpInfo::_internal_mutable_session_info() {
2127
2128 if (_impl_.session_info_ == nullptr) {
2129 auto* p = CreateMaybeMessage<::tensorflow::SessionInfo>(GetArenaForAllocation());
2130 _impl_.session_info_ = p;
2131 }
2132 return _impl_.session_info_;
2133 }
mutable_session_info()2134 inline ::tensorflow::SessionInfo* OpInfo::mutable_session_info() {
2135 ::tensorflow::SessionInfo* _msg = _internal_mutable_session_info();
2136 // @@protoc_insertion_point(field_mutable:tensorflow.OpInfo.session_info)
2137 return _msg;
2138 }
set_allocated_session_info(::tensorflow::SessionInfo * session_info)2139 inline void OpInfo::set_allocated_session_info(::tensorflow::SessionInfo* session_info) {
2140 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
2141 if (message_arena == nullptr) {
2142 delete _impl_.session_info_;
2143 }
2144 if (session_info) {
2145 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
2146 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(session_info);
2147 if (message_arena != submessage_arena) {
2148 session_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
2149 message_arena, session_info, submessage_arena);
2150 }
2151
2152 } else {
2153
2154 }
2155 _impl_.session_info_ = session_info;
2156 // @@protoc_insertion_point(field_set_allocated:tensorflow.OpInfo.session_info)
2157 }
2158
2159 // -------------------------------------------------------------------
2160
2161 // NormalDistribution
2162
2163 // double mu = 1;
clear_mu()2164 inline void NormalDistribution::clear_mu() {
2165 _impl_.mu_ = 0;
2166 }
_internal_mu()2167 inline double NormalDistribution::_internal_mu() const {
2168 return _impl_.mu_;
2169 }
mu()2170 inline double NormalDistribution::mu() const {
2171 // @@protoc_insertion_point(field_get:tensorflow.NormalDistribution.mu)
2172 return _internal_mu();
2173 }
_internal_set_mu(double value)2174 inline void NormalDistribution::_internal_set_mu(double value) {
2175
2176 _impl_.mu_ = value;
2177 }
set_mu(double value)2178 inline void NormalDistribution::set_mu(double value) {
2179 _internal_set_mu(value);
2180 // @@protoc_insertion_point(field_set:tensorflow.NormalDistribution.mu)
2181 }
2182
2183 // double sigma = 2;
clear_sigma()2184 inline void NormalDistribution::clear_sigma() {
2185 _impl_.sigma_ = 0;
2186 }
_internal_sigma()2187 inline double NormalDistribution::_internal_sigma() const {
2188 return _impl_.sigma_;
2189 }
sigma()2190 inline double NormalDistribution::sigma() const {
2191 // @@protoc_insertion_point(field_get:tensorflow.NormalDistribution.sigma)
2192 return _internal_sigma();
2193 }
_internal_set_sigma(double value)2194 inline void NormalDistribution::_internal_set_sigma(double value) {
2195
2196 _impl_.sigma_ = value;
2197 }
set_sigma(double value)2198 inline void NormalDistribution::set_sigma(double value) {
2199 _internal_set_sigma(value);
2200 // @@protoc_insertion_point(field_set:tensorflow.NormalDistribution.sigma)
2201 }
2202
2203 // -------------------------------------------------------------------
2204
2205 // LogNormalDistribution
2206
2207 // double mu = 1;
clear_mu()2208 inline void LogNormalDistribution::clear_mu() {
2209 _impl_.mu_ = 0;
2210 }
_internal_mu()2211 inline double LogNormalDistribution::_internal_mu() const {
2212 return _impl_.mu_;
2213 }
mu()2214 inline double LogNormalDistribution::mu() const {
2215 // @@protoc_insertion_point(field_get:tensorflow.LogNormalDistribution.mu)
2216 return _internal_mu();
2217 }
_internal_set_mu(double value)2218 inline void LogNormalDistribution::_internal_set_mu(double value) {
2219
2220 _impl_.mu_ = value;
2221 }
set_mu(double value)2222 inline void LogNormalDistribution::set_mu(double value) {
2223 _internal_set_mu(value);
2224 // @@protoc_insertion_point(field_set:tensorflow.LogNormalDistribution.mu)
2225 }
2226
2227 // double sigma = 2;
clear_sigma()2228 inline void LogNormalDistribution::clear_sigma() {
2229 _impl_.sigma_ = 0;
2230 }
_internal_sigma()2231 inline double LogNormalDistribution::_internal_sigma() const {
2232 return _impl_.sigma_;
2233 }
sigma()2234 inline double LogNormalDistribution::sigma() const {
2235 // @@protoc_insertion_point(field_get:tensorflow.LogNormalDistribution.sigma)
2236 return _internal_sigma();
2237 }
_internal_set_sigma(double value)2238 inline void LogNormalDistribution::_internal_set_sigma(double value) {
2239
2240 _impl_.sigma_ = value;
2241 }
set_sigma(double value)2242 inline void LogNormalDistribution::set_sigma(double value) {
2243 _internal_set_sigma(value);
2244 // @@protoc_insertion_point(field_set:tensorflow.LogNormalDistribution.sigma)
2245 }
2246
2247 // -------------------------------------------------------------------
2248
2249 // OpPerformance_OpMemory
2250
2251 // repeated int64 output_memory = 1;
_internal_output_memory_size()2252 inline int OpPerformance_OpMemory::_internal_output_memory_size() const {
2253 return _impl_.output_memory_.size();
2254 }
output_memory_size()2255 inline int OpPerformance_OpMemory::output_memory_size() const {
2256 return _internal_output_memory_size();
2257 }
clear_output_memory()2258 inline void OpPerformance_OpMemory::clear_output_memory() {
2259 _impl_.output_memory_.Clear();
2260 }
_internal_output_memory(int index)2261 inline ::int64_t OpPerformance_OpMemory::_internal_output_memory(int index) const {
2262 return _impl_.output_memory_.Get(index);
2263 }
output_memory(int index)2264 inline ::int64_t OpPerformance_OpMemory::output_memory(int index) const {
2265 // @@protoc_insertion_point(field_get:tensorflow.OpPerformance.OpMemory.output_memory)
2266 return _internal_output_memory(index);
2267 }
set_output_memory(int index,::int64_t value)2268 inline void OpPerformance_OpMemory::set_output_memory(int index, ::int64_t value) {
2269 _impl_.output_memory_.Set(index, value);
2270 // @@protoc_insertion_point(field_set:tensorflow.OpPerformance.OpMemory.output_memory)
2271 }
_internal_add_output_memory(::int64_t value)2272 inline void OpPerformance_OpMemory::_internal_add_output_memory(::int64_t value) {
2273 _impl_.output_memory_.Add(value);
2274 }
add_output_memory(::int64_t value)2275 inline void OpPerformance_OpMemory::add_output_memory(::int64_t value) {
2276 _internal_add_output_memory(value);
2277 // @@protoc_insertion_point(field_add:tensorflow.OpPerformance.OpMemory.output_memory)
2278 }
2279 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >&
_internal_output_memory()2280 OpPerformance_OpMemory::_internal_output_memory() const {
2281 return _impl_.output_memory_;
2282 }
2283 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >&
output_memory()2284 OpPerformance_OpMemory::output_memory() const {
2285 // @@protoc_insertion_point(field_list:tensorflow.OpPerformance.OpMemory.output_memory)
2286 return _internal_output_memory();
2287 }
2288 inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >*
_internal_mutable_output_memory()2289 OpPerformance_OpMemory::_internal_mutable_output_memory() {
2290 return &_impl_.output_memory_;
2291 }
2292 inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >*
mutable_output_memory()2293 OpPerformance_OpMemory::mutable_output_memory() {
2294 // @@protoc_insertion_point(field_mutable_list:tensorflow.OpPerformance.OpMemory.output_memory)
2295 return _internal_mutable_output_memory();
2296 }
2297
2298 // int64 temp_memory = 2;
clear_temp_memory()2299 inline void OpPerformance_OpMemory::clear_temp_memory() {
2300 _impl_.temp_memory_ = ::int64_t{0};
2301 }
_internal_temp_memory()2302 inline ::int64_t OpPerformance_OpMemory::_internal_temp_memory() const {
2303 return _impl_.temp_memory_;
2304 }
temp_memory()2305 inline ::int64_t OpPerformance_OpMemory::temp_memory() const {
2306 // @@protoc_insertion_point(field_get:tensorflow.OpPerformance.OpMemory.temp_memory)
2307 return _internal_temp_memory();
2308 }
_internal_set_temp_memory(::int64_t value)2309 inline void OpPerformance_OpMemory::_internal_set_temp_memory(::int64_t value) {
2310
2311 _impl_.temp_memory_ = value;
2312 }
set_temp_memory(::int64_t value)2313 inline void OpPerformance_OpMemory::set_temp_memory(::int64_t value) {
2314 _internal_set_temp_memory(value);
2315 // @@protoc_insertion_point(field_set:tensorflow.OpPerformance.OpMemory.temp_memory)
2316 }
2317
2318 // int64 persistent_memory = 4;
clear_persistent_memory()2319 inline void OpPerformance_OpMemory::clear_persistent_memory() {
2320 _impl_.persistent_memory_ = ::int64_t{0};
2321 }
_internal_persistent_memory()2322 inline ::int64_t OpPerformance_OpMemory::_internal_persistent_memory() const {
2323 return _impl_.persistent_memory_;
2324 }
persistent_memory()2325 inline ::int64_t OpPerformance_OpMemory::persistent_memory() const {
2326 // @@protoc_insertion_point(field_get:tensorflow.OpPerformance.OpMemory.persistent_memory)
2327 return _internal_persistent_memory();
2328 }
_internal_set_persistent_memory(::int64_t value)2329 inline void OpPerformance_OpMemory::_internal_set_persistent_memory(::int64_t value) {
2330
2331 _impl_.persistent_memory_ = value;
2332 }
set_persistent_memory(::int64_t value)2333 inline void OpPerformance_OpMemory::set_persistent_memory(::int64_t value) {
2334 _internal_set_persistent_memory(value);
2335 // @@protoc_insertion_point(field_set:tensorflow.OpPerformance.OpMemory.persistent_memory)
2336 }
2337
2338 // int64 device_temp_memory = 3 [deprecated = true];
clear_device_temp_memory()2339 inline void OpPerformance_OpMemory::clear_device_temp_memory() {
2340 _impl_.device_temp_memory_ = ::int64_t{0};
2341 }
_internal_device_temp_memory()2342 inline ::int64_t OpPerformance_OpMemory::_internal_device_temp_memory() const {
2343 return _impl_.device_temp_memory_;
2344 }
device_temp_memory()2345 inline ::int64_t OpPerformance_OpMemory::device_temp_memory() const {
2346 // @@protoc_insertion_point(field_get:tensorflow.OpPerformance.OpMemory.device_temp_memory)
2347 return _internal_device_temp_memory();
2348 }
_internal_set_device_temp_memory(::int64_t value)2349 inline void OpPerformance_OpMemory::_internal_set_device_temp_memory(::int64_t value) {
2350
2351 _impl_.device_temp_memory_ = value;
2352 }
set_device_temp_memory(::int64_t value)2353 inline void OpPerformance_OpMemory::set_device_temp_memory(::int64_t value) {
2354 _internal_set_device_temp_memory(value);
2355 // @@protoc_insertion_point(field_set:tensorflow.OpPerformance.OpMemory.device_temp_memory)
2356 }
2357
2358 // int64 device_persistent_memory = 5 [deprecated = true];
clear_device_persistent_memory()2359 inline void OpPerformance_OpMemory::clear_device_persistent_memory() {
2360 _impl_.device_persistent_memory_ = ::int64_t{0};
2361 }
_internal_device_persistent_memory()2362 inline ::int64_t OpPerformance_OpMemory::_internal_device_persistent_memory() const {
2363 return _impl_.device_persistent_memory_;
2364 }
device_persistent_memory()2365 inline ::int64_t OpPerformance_OpMemory::device_persistent_memory() const {
2366 // @@protoc_insertion_point(field_get:tensorflow.OpPerformance.OpMemory.device_persistent_memory)
2367 return _internal_device_persistent_memory();
2368 }
_internal_set_device_persistent_memory(::int64_t value)2369 inline void OpPerformance_OpMemory::_internal_set_device_persistent_memory(::int64_t value) {
2370
2371 _impl_.device_persistent_memory_ = value;
2372 }
set_device_persistent_memory(::int64_t value)2373 inline void OpPerformance_OpMemory::set_device_persistent_memory(::int64_t value) {
2374 _internal_set_device_persistent_memory(value);
2375 // @@protoc_insertion_point(field_set:tensorflow.OpPerformance.OpMemory.device_persistent_memory)
2376 }
2377
2378 // -------------------------------------------------------------------
2379
2380 // OpPerformance
2381
2382 // .tensorflow.OpInfo op = 1;
_internal_has_op()2383 inline bool OpPerformance::_internal_has_op() const {
2384 return this != internal_default_instance() && _impl_.op_ != nullptr;
2385 }
has_op()2386 inline bool OpPerformance::has_op() const {
2387 return _internal_has_op();
2388 }
clear_op()2389 inline void OpPerformance::clear_op() {
2390 if (GetArenaForAllocation() == nullptr && _impl_.op_ != nullptr) {
2391 delete _impl_.op_;
2392 }
2393 _impl_.op_ = nullptr;
2394 }
_internal_op()2395 inline const ::tensorflow::OpInfo& OpPerformance::_internal_op() const {
2396 const ::tensorflow::OpInfo* p = _impl_.op_;
2397 return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::OpInfo&>(
2398 ::tensorflow::_OpInfo_default_instance_);
2399 }
op()2400 inline const ::tensorflow::OpInfo& OpPerformance::op() const {
2401 // @@protoc_insertion_point(field_get:tensorflow.OpPerformance.op)
2402 return _internal_op();
2403 }
unsafe_arena_set_allocated_op(::tensorflow::OpInfo * op)2404 inline void OpPerformance::unsafe_arena_set_allocated_op(
2405 ::tensorflow::OpInfo* op) {
2406 if (GetArenaForAllocation() == nullptr) {
2407 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.op_);
2408 }
2409 _impl_.op_ = op;
2410 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.OpPerformance.op)
2411 }
release_op()2412 inline ::tensorflow::OpInfo* OpPerformance::release_op() {
2413
2414 ::tensorflow::OpInfo* temp = _impl_.op_;
2415 _impl_.op_ = nullptr;
2416 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
2417 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
2418 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2419 if (GetArenaForAllocation() == nullptr) { delete old; }
2420 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
2421 if (GetArenaForAllocation() != nullptr) {
2422 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2423 }
2424 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
2425 return temp;
2426 }
unsafe_arena_release_op()2427 inline ::tensorflow::OpInfo* OpPerformance::unsafe_arena_release_op() {
2428 // @@protoc_insertion_point(field_release:tensorflow.OpPerformance.op)
2429
2430 ::tensorflow::OpInfo* temp = _impl_.op_;
2431 _impl_.op_ = nullptr;
2432 return temp;
2433 }
_internal_mutable_op()2434 inline ::tensorflow::OpInfo* OpPerformance::_internal_mutable_op() {
2435
2436 if (_impl_.op_ == nullptr) {
2437 auto* p = CreateMaybeMessage<::tensorflow::OpInfo>(GetArenaForAllocation());
2438 _impl_.op_ = p;
2439 }
2440 return _impl_.op_;
2441 }
mutable_op()2442 inline ::tensorflow::OpInfo* OpPerformance::mutable_op() {
2443 ::tensorflow::OpInfo* _msg = _internal_mutable_op();
2444 // @@protoc_insertion_point(field_mutable:tensorflow.OpPerformance.op)
2445 return _msg;
2446 }
set_allocated_op(::tensorflow::OpInfo * op)2447 inline void OpPerformance::set_allocated_op(::tensorflow::OpInfo* op) {
2448 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
2449 if (message_arena == nullptr) {
2450 delete _impl_.op_;
2451 }
2452 if (op) {
2453 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
2454 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(op);
2455 if (message_arena != submessage_arena) {
2456 op = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
2457 message_arena, op, submessage_arena);
2458 }
2459
2460 } else {
2461
2462 }
2463 _impl_.op_ = op;
2464 // @@protoc_insertion_point(field_set_allocated:tensorflow.OpPerformance.op)
2465 }
2466
2467 // .tensorflow.SessionInfo session_info = 12 [deprecated = true];
_internal_has_session_info()2468 inline bool OpPerformance::_internal_has_session_info() const {
2469 return this != internal_default_instance() && _impl_.session_info_ != nullptr;
2470 }
has_session_info()2471 inline bool OpPerformance::has_session_info() const {
2472 return _internal_has_session_info();
2473 }
clear_session_info()2474 inline void OpPerformance::clear_session_info() {
2475 if (GetArenaForAllocation() == nullptr && _impl_.session_info_ != nullptr) {
2476 delete _impl_.session_info_;
2477 }
2478 _impl_.session_info_ = nullptr;
2479 }
_internal_session_info()2480 inline const ::tensorflow::SessionInfo& OpPerformance::_internal_session_info() const {
2481 const ::tensorflow::SessionInfo* p = _impl_.session_info_;
2482 return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::SessionInfo&>(
2483 ::tensorflow::_SessionInfo_default_instance_);
2484 }
session_info()2485 inline const ::tensorflow::SessionInfo& OpPerformance::session_info() const {
2486 // @@protoc_insertion_point(field_get:tensorflow.OpPerformance.session_info)
2487 return _internal_session_info();
2488 }
unsafe_arena_set_allocated_session_info(::tensorflow::SessionInfo * session_info)2489 inline void OpPerformance::unsafe_arena_set_allocated_session_info(
2490 ::tensorflow::SessionInfo* session_info) {
2491 if (GetArenaForAllocation() == nullptr) {
2492 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.session_info_);
2493 }
2494 _impl_.session_info_ = session_info;
2495 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.OpPerformance.session_info)
2496 }
release_session_info()2497 inline ::tensorflow::SessionInfo* OpPerformance::release_session_info() {
2498
2499 ::tensorflow::SessionInfo* temp = _impl_.session_info_;
2500 _impl_.session_info_ = nullptr;
2501 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
2502 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
2503 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2504 if (GetArenaForAllocation() == nullptr) { delete old; }
2505 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
2506 if (GetArenaForAllocation() != nullptr) {
2507 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2508 }
2509 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
2510 return temp;
2511 }
unsafe_arena_release_session_info()2512 inline ::tensorflow::SessionInfo* OpPerformance::unsafe_arena_release_session_info() {
2513 // @@protoc_insertion_point(field_release:tensorflow.OpPerformance.session_info)
2514
2515 ::tensorflow::SessionInfo* temp = _impl_.session_info_;
2516 _impl_.session_info_ = nullptr;
2517 return temp;
2518 }
_internal_mutable_session_info()2519 inline ::tensorflow::SessionInfo* OpPerformance::_internal_mutable_session_info() {
2520
2521 if (_impl_.session_info_ == nullptr) {
2522 auto* p = CreateMaybeMessage<::tensorflow::SessionInfo>(GetArenaForAllocation());
2523 _impl_.session_info_ = p;
2524 }
2525 return _impl_.session_info_;
2526 }
mutable_session_info()2527 inline ::tensorflow::SessionInfo* OpPerformance::mutable_session_info() {
2528 ::tensorflow::SessionInfo* _msg = _internal_mutable_session_info();
2529 // @@protoc_insertion_point(field_mutable:tensorflow.OpPerformance.session_info)
2530 return _msg;
2531 }
set_allocated_session_info(::tensorflow::SessionInfo * session_info)2532 inline void OpPerformance::set_allocated_session_info(::tensorflow::SessionInfo* session_info) {
2533 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
2534 if (message_arena == nullptr) {
2535 delete _impl_.session_info_;
2536 }
2537 if (session_info) {
2538 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
2539 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(session_info);
2540 if (message_arena != submessage_arena) {
2541 session_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
2542 message_arena, session_info, submessage_arena);
2543 }
2544
2545 } else {
2546
2547 }
2548 _impl_.session_info_ = session_info;
2549 // @@protoc_insertion_point(field_set_allocated:tensorflow.OpPerformance.session_info)
2550 }
2551
2552 // string node = 5;
clear_node()2553 inline void OpPerformance::clear_node() {
2554 _impl_.node_.ClearToEmpty();
2555 }
node()2556 inline const std::string& OpPerformance::node() const {
2557 // @@protoc_insertion_point(field_get:tensorflow.OpPerformance.node)
2558 return _internal_node();
2559 }
2560 template <typename ArgT0, typename... ArgT>
2561 inline PROTOBUF_ALWAYS_INLINE
set_node(ArgT0 && arg0,ArgT...args)2562 void OpPerformance::set_node(ArgT0&& arg0, ArgT... args) {
2563
2564 _impl_.node_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
2565 // @@protoc_insertion_point(field_set:tensorflow.OpPerformance.node)
2566 }
mutable_node()2567 inline std::string* OpPerformance::mutable_node() {
2568 std::string* _s = _internal_mutable_node();
2569 // @@protoc_insertion_point(field_mutable:tensorflow.OpPerformance.node)
2570 return _s;
2571 }
_internal_node()2572 inline const std::string& OpPerformance::_internal_node() const {
2573 return _impl_.node_.Get();
2574 }
_internal_set_node(const std::string & value)2575 inline void OpPerformance::_internal_set_node(const std::string& value) {
2576
2577 _impl_.node_.Set(value, GetArenaForAllocation());
2578 }
_internal_mutable_node()2579 inline std::string* OpPerformance::_internal_mutable_node() {
2580
2581 return _impl_.node_.Mutable(GetArenaForAllocation());
2582 }
release_node()2583 inline std::string* OpPerformance::release_node() {
2584 // @@protoc_insertion_point(field_release:tensorflow.OpPerformance.node)
2585 return _impl_.node_.Release();
2586 }
set_allocated_node(std::string * node)2587 inline void OpPerformance::set_allocated_node(std::string* node) {
2588 _impl_.node_.SetAllocated(node, GetArenaForAllocation());
2589 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2590 if (_impl_.node_.IsDefault()) {
2591 _impl_.node_.Set("", GetArenaForAllocation());
2592 }
2593 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2594 // @@protoc_insertion_point(field_set_allocated:tensorflow.OpPerformance.node)
2595 }
2596
2597 // int64 temporary_memory_size = 2;
clear_temporary_memory_size()2598 inline void OpPerformance::clear_temporary_memory_size() {
2599 _impl_.temporary_memory_size_ = ::int64_t{0};
2600 }
_internal_temporary_memory_size()2601 inline ::int64_t OpPerformance::_internal_temporary_memory_size() const {
2602 return _impl_.temporary_memory_size_;
2603 }
temporary_memory_size()2604 inline ::int64_t OpPerformance::temporary_memory_size() const {
2605 // @@protoc_insertion_point(field_get:tensorflow.OpPerformance.temporary_memory_size)
2606 return _internal_temporary_memory_size();
2607 }
_internal_set_temporary_memory_size(::int64_t value)2608 inline void OpPerformance::_internal_set_temporary_memory_size(::int64_t value) {
2609
2610 _impl_.temporary_memory_size_ = value;
2611 }
set_temporary_memory_size(::int64_t value)2612 inline void OpPerformance::set_temporary_memory_size(::int64_t value) {
2613 _internal_set_temporary_memory_size(value);
2614 // @@protoc_insertion_point(field_set:tensorflow.OpPerformance.temporary_memory_size)
2615 }
2616
2617 // int64 compute_cost = 3;
clear_compute_cost()2618 inline void OpPerformance::clear_compute_cost() {
2619 _impl_.compute_cost_ = ::int64_t{0};
2620 }
_internal_compute_cost()2621 inline ::int64_t OpPerformance::_internal_compute_cost() const {
2622 return _impl_.compute_cost_;
2623 }
compute_cost()2624 inline ::int64_t OpPerformance::compute_cost() const {
2625 // @@protoc_insertion_point(field_get:tensorflow.OpPerformance.compute_cost)
2626 return _internal_compute_cost();
2627 }
_internal_set_compute_cost(::int64_t value)2628 inline void OpPerformance::_internal_set_compute_cost(::int64_t value) {
2629
2630 _impl_.compute_cost_ = value;
2631 }
set_compute_cost(::int64_t value)2632 inline void OpPerformance::set_compute_cost(::int64_t value) {
2633 _internal_set_compute_cost(value);
2634 // @@protoc_insertion_point(field_set:tensorflow.OpPerformance.compute_cost)
2635 }
2636
2637 // int64 compute_time = 6;
clear_compute_time()2638 inline void OpPerformance::clear_compute_time() {
2639 _impl_.compute_time_ = ::int64_t{0};
2640 }
_internal_compute_time()2641 inline ::int64_t OpPerformance::_internal_compute_time() const {
2642 return _impl_.compute_time_;
2643 }
compute_time()2644 inline ::int64_t OpPerformance::compute_time() const {
2645 // @@protoc_insertion_point(field_get:tensorflow.OpPerformance.compute_time)
2646 return _internal_compute_time();
2647 }
_internal_set_compute_time(::int64_t value)2648 inline void OpPerformance::_internal_set_compute_time(::int64_t value) {
2649
2650 _impl_.compute_time_ = value;
2651 }
set_compute_time(::int64_t value)2652 inline void OpPerformance::set_compute_time(::int64_t value) {
2653 _internal_set_compute_time(value);
2654 // @@protoc_insertion_point(field_set:tensorflow.OpPerformance.compute_time)
2655 }
2656
2657 // int64 memory_time = 7;
clear_memory_time()2658 inline void OpPerformance::clear_memory_time() {
2659 _impl_.memory_time_ = ::int64_t{0};
2660 }
_internal_memory_time()2661 inline ::int64_t OpPerformance::_internal_memory_time() const {
2662 return _impl_.memory_time_;
2663 }
memory_time()2664 inline ::int64_t OpPerformance::memory_time() const {
2665 // @@protoc_insertion_point(field_get:tensorflow.OpPerformance.memory_time)
2666 return _internal_memory_time();
2667 }
_internal_set_memory_time(::int64_t value)2668 inline void OpPerformance::_internal_set_memory_time(::int64_t value) {
2669
2670 _impl_.memory_time_ = value;
2671 }
set_memory_time(::int64_t value)2672 inline void OpPerformance::set_memory_time(::int64_t value) {
2673 _internal_set_memory_time(value);
2674 // @@protoc_insertion_point(field_set:tensorflow.OpPerformance.memory_time)
2675 }
2676
2677 // double compute_efficiency = 4;
clear_compute_efficiency()2678 inline void OpPerformance::clear_compute_efficiency() {
2679 _impl_.compute_efficiency_ = 0;
2680 }
_internal_compute_efficiency()2681 inline double OpPerformance::_internal_compute_efficiency() const {
2682 return _impl_.compute_efficiency_;
2683 }
compute_efficiency()2684 inline double OpPerformance::compute_efficiency() const {
2685 // @@protoc_insertion_point(field_get:tensorflow.OpPerformance.compute_efficiency)
2686 return _internal_compute_efficiency();
2687 }
_internal_set_compute_efficiency(double value)2688 inline void OpPerformance::_internal_set_compute_efficiency(double value) {
2689
2690 _impl_.compute_efficiency_ = value;
2691 }
set_compute_efficiency(double value)2692 inline void OpPerformance::set_compute_efficiency(double value) {
2693 _internal_set_compute_efficiency(value);
2694 // @@protoc_insertion_point(field_set:tensorflow.OpPerformance.compute_efficiency)
2695 }
2696
2697 // double memory_efficiency = 8;
clear_memory_efficiency()2698 inline void OpPerformance::clear_memory_efficiency() {
2699 _impl_.memory_efficiency_ = 0;
2700 }
_internal_memory_efficiency()2701 inline double OpPerformance::_internal_memory_efficiency() const {
2702 return _impl_.memory_efficiency_;
2703 }
memory_efficiency()2704 inline double OpPerformance::memory_efficiency() const {
2705 // @@protoc_insertion_point(field_get:tensorflow.OpPerformance.memory_efficiency)
2706 return _internal_memory_efficiency();
2707 }
_internal_set_memory_efficiency(double value)2708 inline void OpPerformance::_internal_set_memory_efficiency(double value) {
2709
2710 _impl_.memory_efficiency_ = value;
2711 }
set_memory_efficiency(double value)2712 inline void OpPerformance::set_memory_efficiency(double value) {
2713 _internal_set_memory_efficiency(value);
2714 // @@protoc_insertion_point(field_set:tensorflow.OpPerformance.memory_efficiency)
2715 }
2716
2717 // .tensorflow.NormalDistribution execution_time_normal = 10;
_internal_has_execution_time_normal()2718 inline bool OpPerformance::_internal_has_execution_time_normal() const {
2719 return execution_time_case() == kExecutionTimeNormal;
2720 }
has_execution_time_normal()2721 inline bool OpPerformance::has_execution_time_normal() const {
2722 return _internal_has_execution_time_normal();
2723 }
set_has_execution_time_normal()2724 inline void OpPerformance::set_has_execution_time_normal() {
2725 _impl_._oneof_case_[0] = kExecutionTimeNormal;
2726 }
clear_execution_time_normal()2727 inline void OpPerformance::clear_execution_time_normal() {
2728 if (_internal_has_execution_time_normal()) {
2729 if (GetArenaForAllocation() == nullptr) {
2730 delete _impl_.execution_time_.execution_time_normal_;
2731 }
2732 clear_has_execution_time();
2733 }
2734 }
release_execution_time_normal()2735 inline ::tensorflow::NormalDistribution* OpPerformance::release_execution_time_normal() {
2736 // @@protoc_insertion_point(field_release:tensorflow.OpPerformance.execution_time_normal)
2737 if (_internal_has_execution_time_normal()) {
2738 clear_has_execution_time();
2739 ::tensorflow::NormalDistribution* temp = _impl_.execution_time_.execution_time_normal_;
2740 if (GetArenaForAllocation() != nullptr) {
2741 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2742 }
2743 _impl_.execution_time_.execution_time_normal_ = nullptr;
2744 return temp;
2745 } else {
2746 return nullptr;
2747 }
2748 }
_internal_execution_time_normal()2749 inline const ::tensorflow::NormalDistribution& OpPerformance::_internal_execution_time_normal() const {
2750 return _internal_has_execution_time_normal()
2751 ? *_impl_.execution_time_.execution_time_normal_
2752 : reinterpret_cast< ::tensorflow::NormalDistribution&>(::tensorflow::_NormalDistribution_default_instance_);
2753 }
execution_time_normal()2754 inline const ::tensorflow::NormalDistribution& OpPerformance::execution_time_normal() const {
2755 // @@protoc_insertion_point(field_get:tensorflow.OpPerformance.execution_time_normal)
2756 return _internal_execution_time_normal();
2757 }
unsafe_arena_release_execution_time_normal()2758 inline ::tensorflow::NormalDistribution* OpPerformance::unsafe_arena_release_execution_time_normal() {
2759 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.OpPerformance.execution_time_normal)
2760 if (_internal_has_execution_time_normal()) {
2761 clear_has_execution_time();
2762 ::tensorflow::NormalDistribution* temp = _impl_.execution_time_.execution_time_normal_;
2763 _impl_.execution_time_.execution_time_normal_ = nullptr;
2764 return temp;
2765 } else {
2766 return nullptr;
2767 }
2768 }
unsafe_arena_set_allocated_execution_time_normal(::tensorflow::NormalDistribution * execution_time_normal)2769 inline void OpPerformance::unsafe_arena_set_allocated_execution_time_normal(::tensorflow::NormalDistribution* execution_time_normal) {
2770 clear_execution_time();
2771 if (execution_time_normal) {
2772 set_has_execution_time_normal();
2773 _impl_.execution_time_.execution_time_normal_ = execution_time_normal;
2774 }
2775 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.OpPerformance.execution_time_normal)
2776 }
_internal_mutable_execution_time_normal()2777 inline ::tensorflow::NormalDistribution* OpPerformance::_internal_mutable_execution_time_normal() {
2778 if (!_internal_has_execution_time_normal()) {
2779 clear_execution_time();
2780 set_has_execution_time_normal();
2781 _impl_.execution_time_.execution_time_normal_ = CreateMaybeMessage< ::tensorflow::NormalDistribution >(GetArenaForAllocation());
2782 }
2783 return _impl_.execution_time_.execution_time_normal_;
2784 }
mutable_execution_time_normal()2785 inline ::tensorflow::NormalDistribution* OpPerformance::mutable_execution_time_normal() {
2786 ::tensorflow::NormalDistribution* _msg = _internal_mutable_execution_time_normal();
2787 // @@protoc_insertion_point(field_mutable:tensorflow.OpPerformance.execution_time_normal)
2788 return _msg;
2789 }
2790
2791 // .tensorflow.LogNormalDistribution execution_time_log_normal = 11;
_internal_has_execution_time_log_normal()2792 inline bool OpPerformance::_internal_has_execution_time_log_normal() const {
2793 return execution_time_case() == kExecutionTimeLogNormal;
2794 }
has_execution_time_log_normal()2795 inline bool OpPerformance::has_execution_time_log_normal() const {
2796 return _internal_has_execution_time_log_normal();
2797 }
set_has_execution_time_log_normal()2798 inline void OpPerformance::set_has_execution_time_log_normal() {
2799 _impl_._oneof_case_[0] = kExecutionTimeLogNormal;
2800 }
clear_execution_time_log_normal()2801 inline void OpPerformance::clear_execution_time_log_normal() {
2802 if (_internal_has_execution_time_log_normal()) {
2803 if (GetArenaForAllocation() == nullptr) {
2804 delete _impl_.execution_time_.execution_time_log_normal_;
2805 }
2806 clear_has_execution_time();
2807 }
2808 }
release_execution_time_log_normal()2809 inline ::tensorflow::LogNormalDistribution* OpPerformance::release_execution_time_log_normal() {
2810 // @@protoc_insertion_point(field_release:tensorflow.OpPerformance.execution_time_log_normal)
2811 if (_internal_has_execution_time_log_normal()) {
2812 clear_has_execution_time();
2813 ::tensorflow::LogNormalDistribution* temp = _impl_.execution_time_.execution_time_log_normal_;
2814 if (GetArenaForAllocation() != nullptr) {
2815 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2816 }
2817 _impl_.execution_time_.execution_time_log_normal_ = nullptr;
2818 return temp;
2819 } else {
2820 return nullptr;
2821 }
2822 }
_internal_execution_time_log_normal()2823 inline const ::tensorflow::LogNormalDistribution& OpPerformance::_internal_execution_time_log_normal() const {
2824 return _internal_has_execution_time_log_normal()
2825 ? *_impl_.execution_time_.execution_time_log_normal_
2826 : reinterpret_cast< ::tensorflow::LogNormalDistribution&>(::tensorflow::_LogNormalDistribution_default_instance_);
2827 }
execution_time_log_normal()2828 inline const ::tensorflow::LogNormalDistribution& OpPerformance::execution_time_log_normal() const {
2829 // @@protoc_insertion_point(field_get:tensorflow.OpPerformance.execution_time_log_normal)
2830 return _internal_execution_time_log_normal();
2831 }
unsafe_arena_release_execution_time_log_normal()2832 inline ::tensorflow::LogNormalDistribution* OpPerformance::unsafe_arena_release_execution_time_log_normal() {
2833 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.OpPerformance.execution_time_log_normal)
2834 if (_internal_has_execution_time_log_normal()) {
2835 clear_has_execution_time();
2836 ::tensorflow::LogNormalDistribution* temp = _impl_.execution_time_.execution_time_log_normal_;
2837 _impl_.execution_time_.execution_time_log_normal_ = nullptr;
2838 return temp;
2839 } else {
2840 return nullptr;
2841 }
2842 }
unsafe_arena_set_allocated_execution_time_log_normal(::tensorflow::LogNormalDistribution * execution_time_log_normal)2843 inline void OpPerformance::unsafe_arena_set_allocated_execution_time_log_normal(::tensorflow::LogNormalDistribution* execution_time_log_normal) {
2844 clear_execution_time();
2845 if (execution_time_log_normal) {
2846 set_has_execution_time_log_normal();
2847 _impl_.execution_time_.execution_time_log_normal_ = execution_time_log_normal;
2848 }
2849 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.OpPerformance.execution_time_log_normal)
2850 }
_internal_mutable_execution_time_log_normal()2851 inline ::tensorflow::LogNormalDistribution* OpPerformance::_internal_mutable_execution_time_log_normal() {
2852 if (!_internal_has_execution_time_log_normal()) {
2853 clear_execution_time();
2854 set_has_execution_time_log_normal();
2855 _impl_.execution_time_.execution_time_log_normal_ = CreateMaybeMessage< ::tensorflow::LogNormalDistribution >(GetArenaForAllocation());
2856 }
2857 return _impl_.execution_time_.execution_time_log_normal_;
2858 }
mutable_execution_time_log_normal()2859 inline ::tensorflow::LogNormalDistribution* OpPerformance::mutable_execution_time_log_normal() {
2860 ::tensorflow::LogNormalDistribution* _msg = _internal_mutable_execution_time_log_normal();
2861 // @@protoc_insertion_point(field_mutable:tensorflow.OpPerformance.execution_time_log_normal)
2862 return _msg;
2863 }
2864
2865 // .tensorflow.OpPerformance.OpMemory op_memory = 9;
_internal_has_op_memory()2866 inline bool OpPerformance::_internal_has_op_memory() const {
2867 return this != internal_default_instance() && _impl_.op_memory_ != nullptr;
2868 }
has_op_memory()2869 inline bool OpPerformance::has_op_memory() const {
2870 return _internal_has_op_memory();
2871 }
clear_op_memory()2872 inline void OpPerformance::clear_op_memory() {
2873 if (GetArenaForAllocation() == nullptr && _impl_.op_memory_ != nullptr) {
2874 delete _impl_.op_memory_;
2875 }
2876 _impl_.op_memory_ = nullptr;
2877 }
_internal_op_memory()2878 inline const ::tensorflow::OpPerformance_OpMemory& OpPerformance::_internal_op_memory() const {
2879 const ::tensorflow::OpPerformance_OpMemory* p = _impl_.op_memory_;
2880 return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::OpPerformance_OpMemory&>(
2881 ::tensorflow::_OpPerformance_OpMemory_default_instance_);
2882 }
op_memory()2883 inline const ::tensorflow::OpPerformance_OpMemory& OpPerformance::op_memory() const {
2884 // @@protoc_insertion_point(field_get:tensorflow.OpPerformance.op_memory)
2885 return _internal_op_memory();
2886 }
unsafe_arena_set_allocated_op_memory(::tensorflow::OpPerformance_OpMemory * op_memory)2887 inline void OpPerformance::unsafe_arena_set_allocated_op_memory(
2888 ::tensorflow::OpPerformance_OpMemory* op_memory) {
2889 if (GetArenaForAllocation() == nullptr) {
2890 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.op_memory_);
2891 }
2892 _impl_.op_memory_ = op_memory;
2893 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.OpPerformance.op_memory)
2894 }
release_op_memory()2895 inline ::tensorflow::OpPerformance_OpMemory* OpPerformance::release_op_memory() {
2896
2897 ::tensorflow::OpPerformance_OpMemory* temp = _impl_.op_memory_;
2898 _impl_.op_memory_ = nullptr;
2899 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
2900 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
2901 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2902 if (GetArenaForAllocation() == nullptr) { delete old; }
2903 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
2904 if (GetArenaForAllocation() != nullptr) {
2905 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2906 }
2907 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
2908 return temp;
2909 }
unsafe_arena_release_op_memory()2910 inline ::tensorflow::OpPerformance_OpMemory* OpPerformance::unsafe_arena_release_op_memory() {
2911 // @@protoc_insertion_point(field_release:tensorflow.OpPerformance.op_memory)
2912
2913 ::tensorflow::OpPerformance_OpMemory* temp = _impl_.op_memory_;
2914 _impl_.op_memory_ = nullptr;
2915 return temp;
2916 }
_internal_mutable_op_memory()2917 inline ::tensorflow::OpPerformance_OpMemory* OpPerformance::_internal_mutable_op_memory() {
2918
2919 if (_impl_.op_memory_ == nullptr) {
2920 auto* p = CreateMaybeMessage<::tensorflow::OpPerformance_OpMemory>(GetArenaForAllocation());
2921 _impl_.op_memory_ = p;
2922 }
2923 return _impl_.op_memory_;
2924 }
mutable_op_memory()2925 inline ::tensorflow::OpPerformance_OpMemory* OpPerformance::mutable_op_memory() {
2926 ::tensorflow::OpPerformance_OpMemory* _msg = _internal_mutable_op_memory();
2927 // @@protoc_insertion_point(field_mutable:tensorflow.OpPerformance.op_memory)
2928 return _msg;
2929 }
set_allocated_op_memory(::tensorflow::OpPerformance_OpMemory * op_memory)2930 inline void OpPerformance::set_allocated_op_memory(::tensorflow::OpPerformance_OpMemory* op_memory) {
2931 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
2932 if (message_arena == nullptr) {
2933 delete _impl_.op_memory_;
2934 }
2935 if (op_memory) {
2936 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
2937 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(op_memory);
2938 if (message_arena != submessage_arena) {
2939 op_memory = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
2940 message_arena, op_memory, submessage_arena);
2941 }
2942
2943 } else {
2944
2945 }
2946 _impl_.op_memory_ = op_memory;
2947 // @@protoc_insertion_point(field_set_allocated:tensorflow.OpPerformance.op_memory)
2948 }
2949
has_execution_time()2950 inline bool OpPerformance::has_execution_time() const {
2951 return execution_time_case() != EXECUTION_TIME_NOT_SET;
2952 }
clear_has_execution_time()2953 inline void OpPerformance::clear_has_execution_time() {
2954 _impl_._oneof_case_[0] = EXECUTION_TIME_NOT_SET;
2955 }
execution_time_case()2956 inline OpPerformance::ExecutionTimeCase OpPerformance::execution_time_case() const {
2957 return OpPerformance::ExecutionTimeCase(_impl_._oneof_case_[0]);
2958 }
2959 // -------------------------------------------------------------------
2960
2961 // OpPerformanceList
2962
2963 // repeated .tensorflow.OpPerformance op_performance = 1;
_internal_op_performance_size()2964 inline int OpPerformanceList::_internal_op_performance_size() const {
2965 return _impl_.op_performance_.size();
2966 }
op_performance_size()2967 inline int OpPerformanceList::op_performance_size() const {
2968 return _internal_op_performance_size();
2969 }
clear_op_performance()2970 inline void OpPerformanceList::clear_op_performance() {
2971 _impl_.op_performance_.Clear();
2972 }
mutable_op_performance(int index)2973 inline ::tensorflow::OpPerformance* OpPerformanceList::mutable_op_performance(int index) {
2974 // @@protoc_insertion_point(field_mutable:tensorflow.OpPerformanceList.op_performance)
2975 return _impl_.op_performance_.Mutable(index);
2976 }
2977 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpPerformance >*
mutable_op_performance()2978 OpPerformanceList::mutable_op_performance() {
2979 // @@protoc_insertion_point(field_mutable_list:tensorflow.OpPerformanceList.op_performance)
2980 return &_impl_.op_performance_;
2981 }
_internal_op_performance(int index)2982 inline const ::tensorflow::OpPerformance& OpPerformanceList::_internal_op_performance(int index) const {
2983 return _impl_.op_performance_.Get(index);
2984 }
op_performance(int index)2985 inline const ::tensorflow::OpPerformance& OpPerformanceList::op_performance(int index) const {
2986 // @@protoc_insertion_point(field_get:tensorflow.OpPerformanceList.op_performance)
2987 return _internal_op_performance(index);
2988 }
_internal_add_op_performance()2989 inline ::tensorflow::OpPerformance* OpPerformanceList::_internal_add_op_performance() {
2990 return _impl_.op_performance_.Add();
2991 }
add_op_performance()2992 inline ::tensorflow::OpPerformance* OpPerformanceList::add_op_performance() {
2993 ::tensorflow::OpPerformance* _add = _internal_add_op_performance();
2994 // @@protoc_insertion_point(field_add:tensorflow.OpPerformanceList.op_performance)
2995 return _add;
2996 }
2997 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpPerformance >&
op_performance()2998 OpPerformanceList::op_performance() const {
2999 // @@protoc_insertion_point(field_list:tensorflow.OpPerformanceList.op_performance)
3000 return _impl_.op_performance_;
3001 }
3002
3003 #ifdef __GNUC__
3004 #pragma GCC diagnostic pop
3005 #endif // __GNUC__
3006 // -------------------------------------------------------------------
3007
3008 // -------------------------------------------------------------------
3009
3010 // -------------------------------------------------------------------
3011
3012 // -------------------------------------------------------------------
3013
3014 // -------------------------------------------------------------------
3015
3016 // -------------------------------------------------------------------
3017
3018 // -------------------------------------------------------------------
3019
3020 // -------------------------------------------------------------------
3021
3022
3023 // @@protoc_insertion_point(namespace_scope)
3024
3025 } // namespace tensorflow
3026
3027 // @@protoc_insertion_point(global_scope)
3028
3029 #include <google/protobuf/port_undef.inc>
3030 #endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fgrappler_2fcosts_2fop_5fperformance_5fdata_2eproto
3031