1// Generated by the protocol buffer compiler. DO NOT EDIT!
2// source: tensorflow/core/protobuf/autotuning.proto
3
4#ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fprotobuf_2fautotuning_2eproto
5#define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fprotobuf_2fautotuning_2eproto
6
7#include <limits>
8#include <string>
9
10#include <google/protobuf/port_def.inc>
11#if PROTOBUF_VERSION < 3009000
12#error This file was generated by a newer version of protoc which is
13#error incompatible with your Protocol Buffer headers. Please update
14#error your headers.
15#endif
16#if 3009002 < PROTOBUF_MIN_PROTOC_VERSION
17#error This file was generated by an older version of protoc which is
18#error incompatible with your Protocol Buffer headers. Please
19#error regenerate this file with a newer version of protoc.
20#endif
21
22#include <google/protobuf/port_undef.inc>
23#include <google/protobuf/io/coded_stream.h>
24#include <google/protobuf/arena.h>
25#include <google/protobuf/arenastring.h>
26#include <google/protobuf/generated_message_table_driven.h>
27#include <google/protobuf/generated_message_util.h>
28#include <google/protobuf/inlined_string_field.h>
29#include <google/protobuf/metadata.h>
30#include <google/protobuf/generated_message_reflection.h>
31#include <google/protobuf/message.h>
32#include <google/protobuf/repeated_field.h> // IWYU pragma: export
33#include <google/protobuf/extension_set.h> // IWYU pragma: export
34#include <google/protobuf/generated_enum_reflection.h>
35#include <google/protobuf/unknown_field_set.h>
36#include <google/protobuf/any.pb.h>
37#include <google/protobuf/duration.pb.h>
38#include "tensorflow/compiler/xla/stream_executor/dnn.pb.h"
39// @@protoc_insertion_point(includes)
40#include <google/protobuf/port_def.inc>
41#define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcore_2fprotobuf_2fautotuning_2eproto
42PROTOBUF_NAMESPACE_OPEN
43namespace internal {
44class AnyMetadata;
45} // namespace internal
46PROTOBUF_NAMESPACE_CLOSE
47
48// Internal implementation detail -- do not use these members.
49struct TableStruct_tensorflow_2fcore_2fprotobuf_2fautotuning_2eproto {
50 static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
51 PROTOBUF_SECTION_VARIABLE(protodesc_cold);
52 static const ::PROTOBUF_NAMESPACE_ID::internal::AuxillaryParseTableField aux[]
53 PROTOBUF_SECTION_VARIABLE(protodesc_cold);
54 static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[8]
55 PROTOBUF_SECTION_VARIABLE(protodesc_cold);
56 static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
57 static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
58 static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
59};
60extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_tensorflow_2fcore_2fprotobuf_2fautotuning_2eproto;
61namespace tensorflow {
62class AutotuneResult;
63class AutotuneResultDefaultTypeInternal;
64extern AutotuneResultDefaultTypeInternal _AutotuneResult_default_instance_;
65class AutotuneResult_ConvKey;
66class AutotuneResult_ConvKeyDefaultTypeInternal;
67extern AutotuneResult_ConvKeyDefaultTypeInternal _AutotuneResult_ConvKey_default_instance_;
68class AutotuneResult_CudaConvPlanKey;
69class AutotuneResult_CudaConvPlanKeyDefaultTypeInternal;
70extern AutotuneResult_CudaConvPlanKeyDefaultTypeInternal _AutotuneResult_CudaConvPlanKey_default_instance_;
71class AutotuneResult_FailureResult;
72class AutotuneResult_FailureResultDefaultTypeInternal;
73extern AutotuneResult_FailureResultDefaultTypeInternal _AutotuneResult_FailureResult_default_instance_;
74class AutotuneResult_GemmKey;
75class AutotuneResult_GemmKeyDefaultTypeInternal;
76extern AutotuneResult_GemmKeyDefaultTypeInternal _AutotuneResult_GemmKey_default_instance_;
77class AutotuningLog;
78class AutotuningLogDefaultTypeInternal;
79extern AutotuningLogDefaultTypeInternal _AutotuningLog_default_instance_;
80class ComputeCapability;
81class ComputeCapabilityDefaultTypeInternal;
82extern ComputeCapabilityDefaultTypeInternal _ComputeCapability_default_instance_;
83class CudnnVersion;
84class CudnnVersionDefaultTypeInternal;
85extern CudnnVersionDefaultTypeInternal _CudnnVersion_default_instance_;
86} // namespace tensorflow
87PROTOBUF_NAMESPACE_OPEN
88template<> ::tensorflow::AutotuneResult* Arena::CreateMaybeMessage<::tensorflow::AutotuneResult>(Arena*);
89template<> ::tensorflow::AutotuneResult_ConvKey* Arena::CreateMaybeMessage<::tensorflow::AutotuneResult_ConvKey>(Arena*);
90template<> ::tensorflow::AutotuneResult_CudaConvPlanKey* Arena::CreateMaybeMessage<::tensorflow::AutotuneResult_CudaConvPlanKey>(Arena*);
91template<> ::tensorflow::AutotuneResult_FailureResult* Arena::CreateMaybeMessage<::tensorflow::AutotuneResult_FailureResult>(Arena*);
92template<> ::tensorflow::AutotuneResult_GemmKey* Arena::CreateMaybeMessage<::tensorflow::AutotuneResult_GemmKey>(Arena*);
93template<> ::tensorflow::AutotuningLog* Arena::CreateMaybeMessage<::tensorflow::AutotuningLog>(Arena*);
94template<> ::tensorflow::ComputeCapability* Arena::CreateMaybeMessage<::tensorflow::ComputeCapability>(Arena*);
95template<> ::tensorflow::CudnnVersion* Arena::CreateMaybeMessage<::tensorflow::CudnnVersion>(Arena*);
96PROTOBUF_NAMESPACE_CLOSE
97namespace tensorflow {
98
99enum AutotuneResult_FailureKind : int {
100 AutotuneResult_FailureKind_UNKNOWN = 0,
101 AutotuneResult_FailureKind_REDZONE_MODIFIED = 1,
102 AutotuneResult_FailureKind_WRONG_RESULT = 2,
103 AutotuneResult_FailureKind_DISQUALIFIED = 3,
104 AutotuneResult_FailureKind_AutotuneResult_FailureKind_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
105 AutotuneResult_FailureKind_AutotuneResult_FailureKind_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
106};
107bool AutotuneResult_FailureKind_IsValid(int value);
108constexpr AutotuneResult_FailureKind AutotuneResult_FailureKind_FailureKind_MIN = AutotuneResult_FailureKind_UNKNOWN;
109constexpr AutotuneResult_FailureKind AutotuneResult_FailureKind_FailureKind_MAX = AutotuneResult_FailureKind_DISQUALIFIED;
110constexpr int AutotuneResult_FailureKind_FailureKind_ARRAYSIZE = AutotuneResult_FailureKind_FailureKind_MAX + 1;
111
112const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* AutotuneResult_FailureKind_descriptor();
113template<typename T>
114inline const std::string& AutotuneResult_FailureKind_Name(T enum_t_value) {
115 static_assert(::std::is_same<T, AutotuneResult_FailureKind>::value ||
116 ::std::is_integral<T>::value,
117 "Incorrect type passed to function AutotuneResult_FailureKind_Name.");
118 return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
119 AutotuneResult_FailureKind_descriptor(), enum_t_value);
120}
121inline bool AutotuneResult_FailureKind_Parse(
122 const std::string& name, AutotuneResult_FailureKind* value) {
123 return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<AutotuneResult_FailureKind>(
124 AutotuneResult_FailureKind_descriptor(), name, value);
125}
126// ===================================================================
127
128class CudnnVersion :
129 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.CudnnVersion) */ {
130 public:
131 CudnnVersion();
132 virtual ~CudnnVersion();
133
134 CudnnVersion(const CudnnVersion& from);
135 CudnnVersion(CudnnVersion&& from) noexcept
136 : CudnnVersion() {
137 *this = ::std::move(from);
138 }
139
140 inline CudnnVersion& operator=(const CudnnVersion& from) {
141 CopyFrom(from);
142 return *this;
143 }
144 inline CudnnVersion& operator=(CudnnVersion&& from) noexcept {
145 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
146 if (this != &from) InternalSwap(&from);
147 } else {
148 CopyFrom(from);
149 }
150 return *this;
151 }
152
153 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
154 return GetDescriptor();
155 }
156 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
157 return GetMetadataStatic().descriptor;
158 }
159 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
160 return GetMetadataStatic().reflection;
161 }
162 static const CudnnVersion& default_instance();
163
164 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
165 static inline const CudnnVersion* internal_default_instance() {
166 return reinterpret_cast<const CudnnVersion*>(
167 &_CudnnVersion_default_instance_);
168 }
169 static constexpr int kIndexInFileMessages =
170 0;
171
172 friend void swap(CudnnVersion& a, CudnnVersion& b) {
173 a.Swap(&b);
174 }
175 inline void Swap(CudnnVersion* other) {
176 if (other == this) return;
177 InternalSwap(other);
178 }
179
180 // implements Message ----------------------------------------------
181
182 inline CudnnVersion* New() const final {
183 return CreateMaybeMessage<CudnnVersion>(nullptr);
184 }
185
186 CudnnVersion* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
187 return CreateMaybeMessage<CudnnVersion>(arena);
188 }
189 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
190 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
191 void CopyFrom(const CudnnVersion& from);
192 void MergeFrom(const CudnnVersion& from);
193 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
194 bool IsInitialized() const final;
195
196 size_t ByteSizeLong() const final;
197 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
198 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
199 #else
200 bool MergePartialFromCodedStream(
201 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
202 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
203 void SerializeWithCachedSizes(
204 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
205 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
206 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
207 int GetCachedSize() const final { return _cached_size_.Get(); }
208
209 private:
210 inline void SharedCtor();
211 inline void SharedDtor();
212 void SetCachedSize(int size) const final;
213 void InternalSwap(CudnnVersion* other);
214 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
215 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
216 return "tensorflow.CudnnVersion";
217 }
218 private:
219 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
220 return nullptr;
221 }
222 inline void* MaybeArenaPtr() const {
223 return nullptr;
224 }
225 public:
226
227 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
228 private:
229 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
230 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fautotuning_2eproto);
231 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fautotuning_2eproto.file_level_metadata[kIndexInFileMessages];
232 }
233
234 public:
235
236 // nested types ----------------------------------------------------
237
238 // accessors -------------------------------------------------------
239
240 enum : int {
241 kMajorFieldNumber = 1,
242 kMinorFieldNumber = 2,
243 kPatchFieldNumber = 3,
244 };
245 // int32 major = 1;
246 void clear_major();
247 ::PROTOBUF_NAMESPACE_ID::int32 major() const;
248 void set_major(::PROTOBUF_NAMESPACE_ID::int32 value);
249
250 // int32 minor = 2;
251 void clear_minor();
252 ::PROTOBUF_NAMESPACE_ID::int32 minor() const;
253 void set_minor(::PROTOBUF_NAMESPACE_ID::int32 value);
254
255 // int32 patch = 3;
256 void clear_patch();
257 ::PROTOBUF_NAMESPACE_ID::int32 patch() const;
258 void set_patch(::PROTOBUF_NAMESPACE_ID::int32 value);
259
260 // @@protoc_insertion_point(class_scope:tensorflow.CudnnVersion)
261 private:
262 class _Internal;
263
264 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
265 ::PROTOBUF_NAMESPACE_ID::int32 major_;
266 ::PROTOBUF_NAMESPACE_ID::int32 minor_;
267 ::PROTOBUF_NAMESPACE_ID::int32 patch_;
268 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
269 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fautotuning_2eproto;
270};
271// -------------------------------------------------------------------
272
273class ComputeCapability :
274 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.ComputeCapability) */ {
275 public:
276 ComputeCapability();
277 virtual ~ComputeCapability();
278
279 ComputeCapability(const ComputeCapability& from);
280 ComputeCapability(ComputeCapability&& from) noexcept
281 : ComputeCapability() {
282 *this = ::std::move(from);
283 }
284
285 inline ComputeCapability& operator=(const ComputeCapability& from) {
286 CopyFrom(from);
287 return *this;
288 }
289 inline ComputeCapability& operator=(ComputeCapability&& from) noexcept {
290 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
291 if (this != &from) InternalSwap(&from);
292 } else {
293 CopyFrom(from);
294 }
295 return *this;
296 }
297
298 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
299 return GetDescriptor();
300 }
301 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
302 return GetMetadataStatic().descriptor;
303 }
304 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
305 return GetMetadataStatic().reflection;
306 }
307 static const ComputeCapability& default_instance();
308
309 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
310 static inline const ComputeCapability* internal_default_instance() {
311 return reinterpret_cast<const ComputeCapability*>(
312 &_ComputeCapability_default_instance_);
313 }
314 static constexpr int kIndexInFileMessages =
315 1;
316
317 friend void swap(ComputeCapability& a, ComputeCapability& b) {
318 a.Swap(&b);
319 }
320 inline void Swap(ComputeCapability* other) {
321 if (other == this) return;
322 InternalSwap(other);
323 }
324
325 // implements Message ----------------------------------------------
326
327 inline ComputeCapability* New() const final {
328 return CreateMaybeMessage<ComputeCapability>(nullptr);
329 }
330
331 ComputeCapability* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
332 return CreateMaybeMessage<ComputeCapability>(arena);
333 }
334 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
335 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
336 void CopyFrom(const ComputeCapability& from);
337 void MergeFrom(const ComputeCapability& from);
338 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
339 bool IsInitialized() const final;
340
341 size_t ByteSizeLong() const final;
342 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
343 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
344 #else
345 bool MergePartialFromCodedStream(
346 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
347 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
348 void SerializeWithCachedSizes(
349 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
350 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
351 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
352 int GetCachedSize() const final { return _cached_size_.Get(); }
353
354 private:
355 inline void SharedCtor();
356 inline void SharedDtor();
357 void SetCachedSize(int size) const final;
358 void InternalSwap(ComputeCapability* other);
359 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
360 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
361 return "tensorflow.ComputeCapability";
362 }
363 private:
364 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
365 return nullptr;
366 }
367 inline void* MaybeArenaPtr() const {
368 return nullptr;
369 }
370 public:
371
372 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
373 private:
374 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
375 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fautotuning_2eproto);
376 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fautotuning_2eproto.file_level_metadata[kIndexInFileMessages];
377 }
378
379 public:
380
381 // nested types ----------------------------------------------------
382
383 // accessors -------------------------------------------------------
384
385 enum : int {
386 kMajorFieldNumber = 1,
387 kMinorFieldNumber = 2,
388 };
389 // int32 major = 1;
390 void clear_major();
391 ::PROTOBUF_NAMESPACE_ID::int32 major() const;
392 void set_major(::PROTOBUF_NAMESPACE_ID::int32 value);
393
394 // int32 minor = 2;
395 void clear_minor();
396 ::PROTOBUF_NAMESPACE_ID::int32 minor() const;
397 void set_minor(::PROTOBUF_NAMESPACE_ID::int32 value);
398
399 // @@protoc_insertion_point(class_scope:tensorflow.ComputeCapability)
400 private:
401 class _Internal;
402
403 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
404 ::PROTOBUF_NAMESPACE_ID::int32 major_;
405 ::PROTOBUF_NAMESPACE_ID::int32 minor_;
406 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
407 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fautotuning_2eproto;
408};
409// -------------------------------------------------------------------
410
411class AutotuneResult_FailureResult :
412 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.AutotuneResult.FailureResult) */ {
413 public:
414 AutotuneResult_FailureResult();
415 virtual ~AutotuneResult_FailureResult();
416
417 AutotuneResult_FailureResult(const AutotuneResult_FailureResult& from);
418 AutotuneResult_FailureResult(AutotuneResult_FailureResult&& from) noexcept
419 : AutotuneResult_FailureResult() {
420 *this = ::std::move(from);
421 }
422
423 inline AutotuneResult_FailureResult& operator=(const AutotuneResult_FailureResult& from) {
424 CopyFrom(from);
425 return *this;
426 }
427 inline AutotuneResult_FailureResult& operator=(AutotuneResult_FailureResult&& from) noexcept {
428 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
429 if (this != &from) InternalSwap(&from);
430 } else {
431 CopyFrom(from);
432 }
433 return *this;
434 }
435
436 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
437 return GetDescriptor();
438 }
439 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
440 return GetMetadataStatic().descriptor;
441 }
442 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
443 return GetMetadataStatic().reflection;
444 }
445 static const AutotuneResult_FailureResult& default_instance();
446
447 enum KeyCase {
448 kReferenceConv = 11,
449 kReferenceGemm = 12,
450 kReferenceCudaConvPlan = 14,
451 kReferenceAlgorithm = 15,
452 KEY_NOT_SET = 0,
453 };
454
455 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
456 static inline const AutotuneResult_FailureResult* internal_default_instance() {
457 return reinterpret_cast<const AutotuneResult_FailureResult*>(
458 &_AutotuneResult_FailureResult_default_instance_);
459 }
460 static constexpr int kIndexInFileMessages =
461 2;
462
463 friend void swap(AutotuneResult_FailureResult& a, AutotuneResult_FailureResult& b) {
464 a.Swap(&b);
465 }
466 inline void Swap(AutotuneResult_FailureResult* other) {
467 if (other == this) return;
468 InternalSwap(other);
469 }
470
471 // implements Message ----------------------------------------------
472
473 inline AutotuneResult_FailureResult* New() const final {
474 return CreateMaybeMessage<AutotuneResult_FailureResult>(nullptr);
475 }
476
477 AutotuneResult_FailureResult* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
478 return CreateMaybeMessage<AutotuneResult_FailureResult>(arena);
479 }
480 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
481 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
482 void CopyFrom(const AutotuneResult_FailureResult& from);
483 void MergeFrom(const AutotuneResult_FailureResult& from);
484 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
485 bool IsInitialized() const final;
486
487 size_t ByteSizeLong() const final;
488 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
489 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
490 #else
491 bool MergePartialFromCodedStream(
492 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
493 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
494 void SerializeWithCachedSizes(
495 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
496 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
497 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
498 int GetCachedSize() const final { return _cached_size_.Get(); }
499
500 private:
501 inline void SharedCtor();
502 inline void SharedDtor();
503 void SetCachedSize(int size) const final;
504 void InternalSwap(AutotuneResult_FailureResult* other);
505 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
506 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
507 return "tensorflow.AutotuneResult.FailureResult";
508 }
509 private:
510 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
511 return nullptr;
512 }
513 inline void* MaybeArenaPtr() const {
514 return nullptr;
515 }
516 public:
517
518 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
519 private:
520 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
521 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fautotuning_2eproto);
522 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fautotuning_2eproto.file_level_metadata[kIndexInFileMessages];
523 }
524
525 public:
526
527 // nested types ----------------------------------------------------
528
529 // accessors -------------------------------------------------------
530
531 enum : int {
532 kMsgFieldNumber = 2,
533 kKindFieldNumber = 1,
534 kBufferAddressFieldNumber = 13,
535 kReferenceConvFieldNumber = 11,
536 kReferenceGemmFieldNumber = 12,
537 kReferenceCudaConvPlanFieldNumber = 14,
538 kReferenceAlgorithmFieldNumber = 15,
539 };
540 // string msg = 2;
541 void clear_msg();
542 const std::string& msg() const;
543 void set_msg(const std::string& value);
544 void set_msg(std::string&& value);
545 void set_msg(const char* value);
546 void set_msg(const char* value, size_t size);
547 std::string* mutable_msg();
548 std::string* release_msg();
549 void set_allocated_msg(std::string* msg);
550
551 // .tensorflow.AutotuneResult.FailureKind kind = 1;
552 void clear_kind();
553 ::tensorflow::AutotuneResult_FailureKind kind() const;
554 void set_kind(::tensorflow::AutotuneResult_FailureKind value);
555
556 // int64 buffer_address = 13;
557 void clear_buffer_address();
558 ::PROTOBUF_NAMESPACE_ID::int64 buffer_address() const;
559 void set_buffer_address(::PROTOBUF_NAMESPACE_ID::int64 value);
560
561 // .tensorflow.AutotuneResult.ConvKey reference_conv = 11;
562 bool has_reference_conv() const;
563 void clear_reference_conv();
564 const ::tensorflow::AutotuneResult_ConvKey& reference_conv() const;
565 ::tensorflow::AutotuneResult_ConvKey* release_reference_conv();
566 ::tensorflow::AutotuneResult_ConvKey* mutable_reference_conv();
567 void set_allocated_reference_conv(::tensorflow::AutotuneResult_ConvKey* reference_conv);
568
569 // .tensorflow.AutotuneResult.GemmKey reference_gemm = 12;
570 bool has_reference_gemm() const;
571 void clear_reference_gemm();
572 const ::tensorflow::AutotuneResult_GemmKey& reference_gemm() const;
573 ::tensorflow::AutotuneResult_GemmKey* release_reference_gemm();
574 ::tensorflow::AutotuneResult_GemmKey* mutable_reference_gemm();
575 void set_allocated_reference_gemm(::tensorflow::AutotuneResult_GemmKey* reference_gemm);
576
577 // .tensorflow.AutotuneResult.CudaConvPlanKey reference_cuda_conv_plan = 14;
578 bool has_reference_cuda_conv_plan() const;
579 void clear_reference_cuda_conv_plan();
580 const ::tensorflow::AutotuneResult_CudaConvPlanKey& reference_cuda_conv_plan() const;
581 ::tensorflow::AutotuneResult_CudaConvPlanKey* release_reference_cuda_conv_plan();
582 ::tensorflow::AutotuneResult_CudaConvPlanKey* mutable_reference_cuda_conv_plan();
583 void set_allocated_reference_cuda_conv_plan(::tensorflow::AutotuneResult_CudaConvPlanKey* reference_cuda_conv_plan);
584
585 // .stream_executor.dnn.AlgorithmProto reference_algorithm = 15;
586 bool has_reference_algorithm() const;
587 void clear_reference_algorithm();
588 const ::stream_executor::dnn::AlgorithmProto& reference_algorithm() const;
589 ::stream_executor::dnn::AlgorithmProto* release_reference_algorithm();
590 ::stream_executor::dnn::AlgorithmProto* mutable_reference_algorithm();
591 void set_allocated_reference_algorithm(::stream_executor::dnn::AlgorithmProto* reference_algorithm);
592
593 void clear_key();
594 KeyCase key_case() const;
595 // @@protoc_insertion_point(class_scope:tensorflow.AutotuneResult.FailureResult)
596 private:
597 class _Internal;
598 void set_has_reference_conv();
599 void set_has_reference_gemm();
600 void set_has_reference_cuda_conv_plan();
601 void set_has_reference_algorithm();
602
603 inline bool has_key() const;
604 inline void clear_has_key();
605
606 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
607 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr msg_;
608 int kind_;
609 ::PROTOBUF_NAMESPACE_ID::int64 buffer_address_;
610 union KeyUnion {
611 KeyUnion() {}
612 ::tensorflow::AutotuneResult_ConvKey* reference_conv_;
613 ::tensorflow::AutotuneResult_GemmKey* reference_gemm_;
614 ::tensorflow::AutotuneResult_CudaConvPlanKey* reference_cuda_conv_plan_;
615 ::stream_executor::dnn::AlgorithmProto* reference_algorithm_;
616 } key_;
617 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
618 ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
619
620 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fautotuning_2eproto;
621};
622// -------------------------------------------------------------------
623
624class AutotuneResult_ConvKey :
625 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.AutotuneResult.ConvKey) */ {
626 public:
627 AutotuneResult_ConvKey();
628 virtual ~AutotuneResult_ConvKey();
629
630 AutotuneResult_ConvKey(const AutotuneResult_ConvKey& from);
631 AutotuneResult_ConvKey(AutotuneResult_ConvKey&& from) noexcept
632 : AutotuneResult_ConvKey() {
633 *this = ::std::move(from);
634 }
635
636 inline AutotuneResult_ConvKey& operator=(const AutotuneResult_ConvKey& from) {
637 CopyFrom(from);
638 return *this;
639 }
640 inline AutotuneResult_ConvKey& operator=(AutotuneResult_ConvKey&& from) noexcept {
641 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
642 if (this != &from) InternalSwap(&from);
643 } else {
644 CopyFrom(from);
645 }
646 return *this;
647 }
648
649 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
650 return GetDescriptor();
651 }
652 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
653 return GetMetadataStatic().descriptor;
654 }
655 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
656 return GetMetadataStatic().reflection;
657 }
658 static const AutotuneResult_ConvKey& default_instance();
659
660 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
661 static inline const AutotuneResult_ConvKey* internal_default_instance() {
662 return reinterpret_cast<const AutotuneResult_ConvKey*>(
663 &_AutotuneResult_ConvKey_default_instance_);
664 }
665 static constexpr int kIndexInFileMessages =
666 3;
667
668 friend void swap(AutotuneResult_ConvKey& a, AutotuneResult_ConvKey& b) {
669 a.Swap(&b);
670 }
671 inline void Swap(AutotuneResult_ConvKey* other) {
672 if (other == this) return;
673 InternalSwap(other);
674 }
675
676 // implements Message ----------------------------------------------
677
678 inline AutotuneResult_ConvKey* New() const final {
679 return CreateMaybeMessage<AutotuneResult_ConvKey>(nullptr);
680 }
681
682 AutotuneResult_ConvKey* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
683 return CreateMaybeMessage<AutotuneResult_ConvKey>(arena);
684 }
685 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
686 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
687 void CopyFrom(const AutotuneResult_ConvKey& from);
688 void MergeFrom(const AutotuneResult_ConvKey& from);
689 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
690 bool IsInitialized() const final;
691
692 size_t ByteSizeLong() const final;
693 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
694 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
695 #else
696 bool MergePartialFromCodedStream(
697 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
698 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
699 void SerializeWithCachedSizes(
700 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
701 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
702 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
703 int GetCachedSize() const final { return _cached_size_.Get(); }
704
705 private:
706 inline void SharedCtor();
707 inline void SharedDtor();
708 void SetCachedSize(int size) const final;
709 void InternalSwap(AutotuneResult_ConvKey* other);
710 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
711 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
712 return "tensorflow.AutotuneResult.ConvKey";
713 }
714 private:
715 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
716 return nullptr;
717 }
718 inline void* MaybeArenaPtr() const {
719 return nullptr;
720 }
721 public:
722
723 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
724 private:
725 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
726 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fautotuning_2eproto);
727 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fautotuning_2eproto.file_level_metadata[kIndexInFileMessages];
728 }
729
730 public:
731
732 // nested types ----------------------------------------------------
733
734 // accessors -------------------------------------------------------
735
736 enum : int {
737 kAlgorithmFieldNumber = 1,
738 kTensorOpsEnabledFieldNumber = 2,
739 };
740 // int64 algorithm = 1;
741 void clear_algorithm();
742 ::PROTOBUF_NAMESPACE_ID::int64 algorithm() const;
743 void set_algorithm(::PROTOBUF_NAMESPACE_ID::int64 value);
744
745 // bool tensor_ops_enabled = 2;
746 void clear_tensor_ops_enabled();
747 bool tensor_ops_enabled() const;
748 void set_tensor_ops_enabled(bool value);
749
750 // @@protoc_insertion_point(class_scope:tensorflow.AutotuneResult.ConvKey)
751 private:
752 class _Internal;
753
754 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
755 ::PROTOBUF_NAMESPACE_ID::int64 algorithm_;
756 bool tensor_ops_enabled_;
757 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
758 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fautotuning_2eproto;
759};
760// -------------------------------------------------------------------
761
762class AutotuneResult_GemmKey :
763 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.AutotuneResult.GemmKey) */ {
764 public:
765 AutotuneResult_GemmKey();
766 virtual ~AutotuneResult_GemmKey();
767
768 AutotuneResult_GemmKey(const AutotuneResult_GemmKey& from);
769 AutotuneResult_GemmKey(AutotuneResult_GemmKey&& from) noexcept
770 : AutotuneResult_GemmKey() {
771 *this = ::std::move(from);
772 }
773
774 inline AutotuneResult_GemmKey& operator=(const AutotuneResult_GemmKey& from) {
775 CopyFrom(from);
776 return *this;
777 }
778 inline AutotuneResult_GemmKey& operator=(AutotuneResult_GemmKey&& from) noexcept {
779 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
780 if (this != &from) InternalSwap(&from);
781 } else {
782 CopyFrom(from);
783 }
784 return *this;
785 }
786
787 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
788 return GetDescriptor();
789 }
790 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
791 return GetMetadataStatic().descriptor;
792 }
793 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
794 return GetMetadataStatic().reflection;
795 }
796 static const AutotuneResult_GemmKey& default_instance();
797
798 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
799 static inline const AutotuneResult_GemmKey* internal_default_instance() {
800 return reinterpret_cast<const AutotuneResult_GemmKey*>(
801 &_AutotuneResult_GemmKey_default_instance_);
802 }
803 static constexpr int kIndexInFileMessages =
804 4;
805
806 friend void swap(AutotuneResult_GemmKey& a, AutotuneResult_GemmKey& b) {
807 a.Swap(&b);
808 }
809 inline void Swap(AutotuneResult_GemmKey* other) {
810 if (other == this) return;
811 InternalSwap(other);
812 }
813
814 // implements Message ----------------------------------------------
815
816 inline AutotuneResult_GemmKey* New() const final {
817 return CreateMaybeMessage<AutotuneResult_GemmKey>(nullptr);
818 }
819
820 AutotuneResult_GemmKey* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
821 return CreateMaybeMessage<AutotuneResult_GemmKey>(arena);
822 }
823 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
824 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
825 void CopyFrom(const AutotuneResult_GemmKey& from);
826 void MergeFrom(const AutotuneResult_GemmKey& from);
827 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
828 bool IsInitialized() const final;
829
830 size_t ByteSizeLong() const final;
831 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
832 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
833 #else
834 bool MergePartialFromCodedStream(
835 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
836 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
837 void SerializeWithCachedSizes(
838 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
839 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
840 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
841 int GetCachedSize() const final { return _cached_size_.Get(); }
842
843 private:
844 inline void SharedCtor();
845 inline void SharedDtor();
846 void SetCachedSize(int size) const final;
847 void InternalSwap(AutotuneResult_GemmKey* other);
848 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
849 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
850 return "tensorflow.AutotuneResult.GemmKey";
851 }
852 private:
853 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
854 return nullptr;
855 }
856 inline void* MaybeArenaPtr() const {
857 return nullptr;
858 }
859 public:
860
861 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
862 private:
863 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
864 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fautotuning_2eproto);
865 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fautotuning_2eproto.file_level_metadata[kIndexInFileMessages];
866 }
867
868 public:
869
870 // nested types ----------------------------------------------------
871
872 // accessors -------------------------------------------------------
873
874 enum : int {
875 kAlgorithmFieldNumber = 1,
876 };
877 // int64 algorithm = 1;
878 void clear_algorithm();
879 ::PROTOBUF_NAMESPACE_ID::int64 algorithm() const;
880 void set_algorithm(::PROTOBUF_NAMESPACE_ID::int64 value);
881
882 // @@protoc_insertion_point(class_scope:tensorflow.AutotuneResult.GemmKey)
883 private:
884 class _Internal;
885
886 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
887 ::PROTOBUF_NAMESPACE_ID::int64 algorithm_;
888 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
889 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fautotuning_2eproto;
890};
891// -------------------------------------------------------------------
892
893class AutotuneResult_CudaConvPlanKey :
894 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.AutotuneResult.CudaConvPlanKey) */ {
895 public:
896 AutotuneResult_CudaConvPlanKey();
897 virtual ~AutotuneResult_CudaConvPlanKey();
898
899 AutotuneResult_CudaConvPlanKey(const AutotuneResult_CudaConvPlanKey& from);
900 AutotuneResult_CudaConvPlanKey(AutotuneResult_CudaConvPlanKey&& from) noexcept
901 : AutotuneResult_CudaConvPlanKey() {
902 *this = ::std::move(from);
903 }
904
905 inline AutotuneResult_CudaConvPlanKey& operator=(const AutotuneResult_CudaConvPlanKey& from) {
906 CopyFrom(from);
907 return *this;
908 }
909 inline AutotuneResult_CudaConvPlanKey& operator=(AutotuneResult_CudaConvPlanKey&& from) noexcept {
910 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
911 if (this != &from) InternalSwap(&from);
912 } else {
913 CopyFrom(from);
914 }
915 return *this;
916 }
917
918 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
919 return GetDescriptor();
920 }
921 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
922 return GetMetadataStatic().descriptor;
923 }
924 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
925 return GetMetadataStatic().reflection;
926 }
927 static const AutotuneResult_CudaConvPlanKey& default_instance();
928
929 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
930 static inline const AutotuneResult_CudaConvPlanKey* internal_default_instance() {
931 return reinterpret_cast<const AutotuneResult_CudaConvPlanKey*>(
932 &_AutotuneResult_CudaConvPlanKey_default_instance_);
933 }
934 static constexpr int kIndexInFileMessages =
935 5;
936
937 friend void swap(AutotuneResult_CudaConvPlanKey& a, AutotuneResult_CudaConvPlanKey& b) {
938 a.Swap(&b);
939 }
940 inline void Swap(AutotuneResult_CudaConvPlanKey* other) {
941 if (other == this) return;
942 InternalSwap(other);
943 }
944
945 // implements Message ----------------------------------------------
946
947 inline AutotuneResult_CudaConvPlanKey* New() const final {
948 return CreateMaybeMessage<AutotuneResult_CudaConvPlanKey>(nullptr);
949 }
950
951 AutotuneResult_CudaConvPlanKey* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
952 return CreateMaybeMessage<AutotuneResult_CudaConvPlanKey>(arena);
953 }
954 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
955 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
956 void CopyFrom(const AutotuneResult_CudaConvPlanKey& from);
957 void MergeFrom(const AutotuneResult_CudaConvPlanKey& from);
958 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
959 bool IsInitialized() const final;
960
961 size_t ByteSizeLong() const final;
962 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
963 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
964 #else
965 bool MergePartialFromCodedStream(
966 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
967 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
968 void SerializeWithCachedSizes(
969 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
970 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
971 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
972 int GetCachedSize() const final { return _cached_size_.Get(); }
973
974 private:
975 inline void SharedCtor();
976 inline void SharedDtor();
977 void SetCachedSize(int size) const final;
978 void InternalSwap(AutotuneResult_CudaConvPlanKey* other);
979 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
980 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
981 return "tensorflow.AutotuneResult.CudaConvPlanKey";
982 }
983 private:
984 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
985 return nullptr;
986 }
987 inline void* MaybeArenaPtr() const {
988 return nullptr;
989 }
990 public:
991
992 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
993 private:
994 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
995 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fautotuning_2eproto);
996 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fautotuning_2eproto.file_level_metadata[kIndexInFileMessages];
997 }
998
999 public:
1000
1001 // nested types ----------------------------------------------------
1002
1003 // accessors -------------------------------------------------------
1004
1005 enum : int {
1006 kExecPlanIdFieldNumber = 1,
1007 };
1008 // string exec_plan_id = 1;
1009 void clear_exec_plan_id();
1010 const std::string& exec_plan_id() const;
1011 void set_exec_plan_id(const std::string& value);
1012 void set_exec_plan_id(std::string&& value);
1013 void set_exec_plan_id(const char* value);
1014 void set_exec_plan_id(const char* value, size_t size);
1015 std::string* mutable_exec_plan_id();
1016 std::string* release_exec_plan_id();
1017 void set_allocated_exec_plan_id(std::string* exec_plan_id);
1018
1019 // @@protoc_insertion_point(class_scope:tensorflow.AutotuneResult.CudaConvPlanKey)
1020 private:
1021 class _Internal;
1022
1023 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
1024 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr exec_plan_id_;
1025 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1026 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fautotuning_2eproto;
1027};
1028// -------------------------------------------------------------------
1029
1030class AutotuneResult :
1031 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.AutotuneResult) */ {
1032 public:
1033 AutotuneResult();
1034 virtual ~AutotuneResult();
1035
1036 AutotuneResult(const AutotuneResult& from);
1037 AutotuneResult(AutotuneResult&& from) noexcept
1038 : AutotuneResult() {
1039 *this = ::std::move(from);
1040 }
1041
1042 inline AutotuneResult& operator=(const AutotuneResult& from) {
1043 CopyFrom(from);
1044 return *this;
1045 }
1046 inline AutotuneResult& operator=(AutotuneResult&& from) noexcept {
1047 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1048 if (this != &from) InternalSwap(&from);
1049 } else {
1050 CopyFrom(from);
1051 }
1052 return *this;
1053 }
1054
1055 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
1056 return GetDescriptor();
1057 }
1058 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
1059 return GetMetadataStatic().descriptor;
1060 }
1061 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
1062 return GetMetadataStatic().reflection;
1063 }
1064 static const AutotuneResult& default_instance();
1065
1066 enum KeyCase {
1067 kConv = 5,
1068 kGemm = 6,
1069 kCudaConvPlan = 15,
1070 kAlgorithm = 16,
1071 KEY_NOT_SET = 0,
1072 };
1073
1074 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1075 static inline const AutotuneResult* internal_default_instance() {
1076 return reinterpret_cast<const AutotuneResult*>(
1077 &_AutotuneResult_default_instance_);
1078 }
1079 static constexpr int kIndexInFileMessages =
1080 6;
1081
1082 friend void swap(AutotuneResult& a, AutotuneResult& b) {
1083 a.Swap(&b);
1084 }
1085 inline void Swap(AutotuneResult* other) {
1086 if (other == this) return;
1087 InternalSwap(other);
1088 }
1089
1090 // implements Message ----------------------------------------------
1091
1092 inline AutotuneResult* New() const final {
1093 return CreateMaybeMessage<AutotuneResult>(nullptr);
1094 }
1095
1096 AutotuneResult* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1097 return CreateMaybeMessage<AutotuneResult>(arena);
1098 }
1099 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1100 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1101 void CopyFrom(const AutotuneResult& from);
1102 void MergeFrom(const AutotuneResult& from);
1103 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1104 bool IsInitialized() const final;
1105
1106 size_t ByteSizeLong() const final;
1107 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
1108 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1109 #else
1110 bool MergePartialFromCodedStream(
1111 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
1112 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
1113 void SerializeWithCachedSizes(
1114 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
1115 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
1116 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
1117 int GetCachedSize() const final { return _cached_size_.Get(); }
1118
1119 private:
1120 inline void SharedCtor();
1121 inline void SharedDtor();
1122 void SetCachedSize(int size) const final;
1123 void InternalSwap(AutotuneResult* other);
1124 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1125 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1126 return "tensorflow.AutotuneResult";
1127 }
1128 private:
1129 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
1130 return nullptr;
1131 }
1132 inline void* MaybeArenaPtr() const {
1133 return nullptr;
1134 }
1135 public:
1136
1137 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
1138 private:
1139 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
1140 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fautotuning_2eproto);
1141 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fautotuning_2eproto.file_level_metadata[kIndexInFileMessages];
1142 }
1143
1144 public:
1145
1146 // nested types ----------------------------------------------------
1147
1148 typedef AutotuneResult_FailureResult FailureResult;
1149 typedef AutotuneResult_ConvKey ConvKey;
1150 typedef AutotuneResult_GemmKey GemmKey;
1151 typedef AutotuneResult_CudaConvPlanKey CudaConvPlanKey;
1152
1153 typedef AutotuneResult_FailureKind FailureKind;
1154 static constexpr FailureKind UNKNOWN =
1155 AutotuneResult_FailureKind_UNKNOWN;
1156 static constexpr FailureKind REDZONE_MODIFIED =
1157 AutotuneResult_FailureKind_REDZONE_MODIFIED;
1158 static constexpr FailureKind WRONG_RESULT =
1159 AutotuneResult_FailureKind_WRONG_RESULT;
1160 static constexpr FailureKind DISQUALIFIED =
1161 AutotuneResult_FailureKind_DISQUALIFIED;
1162 static inline bool FailureKind_IsValid(int value) {
1163 return AutotuneResult_FailureKind_IsValid(value);
1164 }
1165 static constexpr FailureKind FailureKind_MIN =
1166 AutotuneResult_FailureKind_FailureKind_MIN;
1167 static constexpr FailureKind FailureKind_MAX =
1168 AutotuneResult_FailureKind_FailureKind_MAX;
1169 static constexpr int FailureKind_ARRAYSIZE =
1170 AutotuneResult_FailureKind_FailureKind_ARRAYSIZE;
1171 static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
1172 FailureKind_descriptor() {
1173 return AutotuneResult_FailureKind_descriptor();
1174 }
1175 template<typename T>
1176 static inline const std::string& FailureKind_Name(T enum_t_value) {
1177 static_assert(::std::is_same<T, FailureKind>::value ||
1178 ::std::is_integral<T>::value,
1179 "Incorrect type passed to function FailureKind_Name.");
1180 return AutotuneResult_FailureKind_Name(enum_t_value);
1181 }
1182 static inline bool FailureKind_Parse(const std::string& name,
1183 FailureKind* value) {
1184 return AutotuneResult_FailureKind_Parse(name, value);
1185 }
1186
1187 // accessors -------------------------------------------------------
1188
1189 enum : int {
1190 kFailureFieldNumber = 7,
1191 kRunTimeFieldNumber = 9,
1192 kScratchBytesFieldNumber = 8,
1193 kConvFieldNumber = 5,
1194 kGemmFieldNumber = 6,
1195 kCudaConvPlanFieldNumber = 15,
1196 kAlgorithmFieldNumber = 16,
1197 };
1198 // .tensorflow.AutotuneResult.FailureResult failure = 7;
1199 bool has_failure() const;
1200 void clear_failure();
1201 const ::tensorflow::AutotuneResult_FailureResult& failure() const;
1202 ::tensorflow::AutotuneResult_FailureResult* release_failure();
1203 ::tensorflow::AutotuneResult_FailureResult* mutable_failure();
1204 void set_allocated_failure(::tensorflow::AutotuneResult_FailureResult* failure);
1205
1206 // .google.protobuf.Duration run_time = 9;
1207 bool has_run_time() const;
1208 void clear_run_time();
1209 const PROTOBUF_NAMESPACE_ID::Duration& run_time() const;
1210 PROTOBUF_NAMESPACE_ID::Duration* release_run_time();
1211 PROTOBUF_NAMESPACE_ID::Duration* mutable_run_time();
1212 void set_allocated_run_time(PROTOBUF_NAMESPACE_ID::Duration* run_time);
1213
1214 // int64 scratch_bytes = 8;
1215 void clear_scratch_bytes();
1216 ::PROTOBUF_NAMESPACE_ID::int64 scratch_bytes() const;
1217 void set_scratch_bytes(::PROTOBUF_NAMESPACE_ID::int64 value);
1218
1219 // .tensorflow.AutotuneResult.ConvKey conv = 5;
1220 bool has_conv() const;
1221 void clear_conv();
1222 const ::tensorflow::AutotuneResult_ConvKey& conv() const;
1223 ::tensorflow::AutotuneResult_ConvKey* release_conv();
1224 ::tensorflow::AutotuneResult_ConvKey* mutable_conv();
1225 void set_allocated_conv(::tensorflow::AutotuneResult_ConvKey* conv);
1226
1227 // .tensorflow.AutotuneResult.GemmKey gemm = 6;
1228 bool has_gemm() const;
1229 void clear_gemm();
1230 const ::tensorflow::AutotuneResult_GemmKey& gemm() const;
1231 ::tensorflow::AutotuneResult_GemmKey* release_gemm();
1232 ::tensorflow::AutotuneResult_GemmKey* mutable_gemm();
1233 void set_allocated_gemm(::tensorflow::AutotuneResult_GemmKey* gemm);
1234
1235 // .tensorflow.AutotuneResult.CudaConvPlanKey cuda_conv_plan = 15;
1236 bool has_cuda_conv_plan() const;
1237 void clear_cuda_conv_plan();
1238 const ::tensorflow::AutotuneResult_CudaConvPlanKey& cuda_conv_plan() const;
1239 ::tensorflow::AutotuneResult_CudaConvPlanKey* release_cuda_conv_plan();
1240 ::tensorflow::AutotuneResult_CudaConvPlanKey* mutable_cuda_conv_plan();
1241 void set_allocated_cuda_conv_plan(::tensorflow::AutotuneResult_CudaConvPlanKey* cuda_conv_plan);
1242
1243 // .stream_executor.dnn.AlgorithmProto algorithm = 16;
1244 bool has_algorithm() const;
1245 void clear_algorithm();
1246 const ::stream_executor::dnn::AlgorithmProto& algorithm() const;
1247 ::stream_executor::dnn::AlgorithmProto* release_algorithm();
1248 ::stream_executor::dnn::AlgorithmProto* mutable_algorithm();
1249 void set_allocated_algorithm(::stream_executor::dnn::AlgorithmProto* algorithm);
1250
1251 void clear_key();
1252 KeyCase key_case() const;
1253 // @@protoc_insertion_point(class_scope:tensorflow.AutotuneResult)
1254 private:
1255 class _Internal;
1256 void set_has_conv();
1257 void set_has_gemm();
1258 void set_has_cuda_conv_plan();
1259 void set_has_algorithm();
1260
1261 inline bool has_key() const;
1262 inline void clear_has_key();
1263
1264 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
1265 ::tensorflow::AutotuneResult_FailureResult* failure_;
1266 PROTOBUF_NAMESPACE_ID::Duration* run_time_;
1267 ::PROTOBUF_NAMESPACE_ID::int64 scratch_bytes_;
1268 union KeyUnion {
1269 KeyUnion() {}
1270 ::tensorflow::AutotuneResult_ConvKey* conv_;
1271 ::tensorflow::AutotuneResult_GemmKey* gemm_;
1272 ::tensorflow::AutotuneResult_CudaConvPlanKey* cuda_conv_plan_;
1273 ::stream_executor::dnn::AlgorithmProto* algorithm_;
1274 } key_;
1275 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1276 ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
1277
1278 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fautotuning_2eproto;
1279};
1280// -------------------------------------------------------------------
1281
1282class AutotuningLog :
1283 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.AutotuningLog) */ {
1284 public:
1285 AutotuningLog();
1286 virtual ~AutotuningLog();
1287
1288 AutotuningLog(const AutotuningLog& from);
1289 AutotuningLog(AutotuningLog&& from) noexcept
1290 : AutotuningLog() {
1291 *this = ::std::move(from);
1292 }
1293
1294 inline AutotuningLog& operator=(const AutotuningLog& from) {
1295 CopyFrom(from);
1296 return *this;
1297 }
1298 inline AutotuningLog& operator=(AutotuningLog&& from) noexcept {
1299 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1300 if (this != &from) InternalSwap(&from);
1301 } else {
1302 CopyFrom(from);
1303 }
1304 return *this;
1305 }
1306
1307 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
1308 return GetDescriptor();
1309 }
1310 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
1311 return GetMetadataStatic().descriptor;
1312 }
1313 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
1314 return GetMetadataStatic().reflection;
1315 }
1316 static const AutotuningLog& default_instance();
1317
1318 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1319 static inline const AutotuningLog* internal_default_instance() {
1320 return reinterpret_cast<const AutotuningLog*>(
1321 &_AutotuningLog_default_instance_);
1322 }
1323 static constexpr int kIndexInFileMessages =
1324 7;
1325
1326 friend void swap(AutotuningLog& a, AutotuningLog& b) {
1327 a.Swap(&b);
1328 }
1329 inline void Swap(AutotuningLog* other) {
1330 if (other == this) return;
1331 InternalSwap(other);
1332 }
1333
1334 // implements Message ----------------------------------------------
1335
1336 inline AutotuningLog* New() const final {
1337 return CreateMaybeMessage<AutotuningLog>(nullptr);
1338 }
1339
1340 AutotuningLog* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1341 return CreateMaybeMessage<AutotuningLog>(arena);
1342 }
1343 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1344 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1345 void CopyFrom(const AutotuningLog& from);
1346 void MergeFrom(const AutotuningLog& from);
1347 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1348 bool IsInitialized() const final;
1349
1350 size_t ByteSizeLong() const final;
1351 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
1352 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1353 #else
1354 bool MergePartialFromCodedStream(
1355 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
1356 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
1357 void SerializeWithCachedSizes(
1358 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
1359 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
1360 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
1361 int GetCachedSize() const final { return _cached_size_.Get(); }
1362
1363 private:
1364 inline void SharedCtor();
1365 inline void SharedDtor();
1366 void SetCachedSize(int size) const final;
1367 void InternalSwap(AutotuningLog* other);
1368 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1369 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1370 return "tensorflow.AutotuningLog";
1371 }
1372 private:
1373 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
1374 return nullptr;
1375 }
1376 inline void* MaybeArenaPtr() const {
1377 return nullptr;
1378 }
1379 public:
1380
1381 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
1382 private:
1383 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
1384 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fautotuning_2eproto);
1385 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fautotuning_2eproto.file_level_metadata[kIndexInFileMessages];
1386 }
1387
1388 public:
1389
1390 // nested types ----------------------------------------------------
1391
1392 // accessors -------------------------------------------------------
1393
1394 enum : int {
1395 kResultsFieldNumber = 2,
1396 kDevicePciBusIdFieldNumber = 5,
1397 kBlasVersionFieldNumber = 6,
1398 kInstrFieldNumber = 1,
1399 kCudnnVersionFieldNumber = 3,
1400 kComputeCapabilityFieldNumber = 4,
1401 };
1402 // repeated .tensorflow.AutotuneResult results = 2;
1403 int results_size() const;
1404 void clear_results();
1405 ::tensorflow::AutotuneResult* mutable_results(int index);
1406 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::AutotuneResult >*
1407 mutable_results();
1408 const ::tensorflow::AutotuneResult& results(int index) const;
1409 ::tensorflow::AutotuneResult* add_results();
1410 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::AutotuneResult >&
1411 results() const;
1412
1413 // string device_pci_bus_id = 5;
1414 void clear_device_pci_bus_id();
1415 const std::string& device_pci_bus_id() const;
1416 void set_device_pci_bus_id(const std::string& value);
1417 void set_device_pci_bus_id(std::string&& value);
1418 void set_device_pci_bus_id(const char* value);
1419 void set_device_pci_bus_id(const char* value, size_t size);
1420 std::string* mutable_device_pci_bus_id();
1421 std::string* release_device_pci_bus_id();
1422 void set_allocated_device_pci_bus_id(std::string* device_pci_bus_id);
1423
1424 // string blas_version = 6;
1425 void clear_blas_version();
1426 const std::string& blas_version() const;
1427 void set_blas_version(const std::string& value);
1428 void set_blas_version(std::string&& value);
1429 void set_blas_version(const char* value);
1430 void set_blas_version(const char* value, size_t size);
1431 std::string* mutable_blas_version();
1432 std::string* release_blas_version();
1433 void set_allocated_blas_version(std::string* blas_version);
1434
1435 // .google.protobuf.Any instr = 1;
1436 bool has_instr() const;
1437 void clear_instr();
1438 const PROTOBUF_NAMESPACE_ID::Any& instr() const;
1439 PROTOBUF_NAMESPACE_ID::Any* release_instr();
1440 PROTOBUF_NAMESPACE_ID::Any* mutable_instr();
1441 void set_allocated_instr(PROTOBUF_NAMESPACE_ID::Any* instr);
1442
1443 // .tensorflow.CudnnVersion cudnn_version = 3;
1444 bool has_cudnn_version() const;
1445 void clear_cudnn_version();
1446 const ::tensorflow::CudnnVersion& cudnn_version() const;
1447 ::tensorflow::CudnnVersion* release_cudnn_version();
1448 ::tensorflow::CudnnVersion* mutable_cudnn_version();
1449 void set_allocated_cudnn_version(::tensorflow::CudnnVersion* cudnn_version);
1450
1451 // .tensorflow.ComputeCapability compute_capability = 4;
1452 bool has_compute_capability() const;
1453 void clear_compute_capability();
1454 const ::tensorflow::ComputeCapability& compute_capability() const;
1455 ::tensorflow::ComputeCapability* release_compute_capability();
1456 ::tensorflow::ComputeCapability* mutable_compute_capability();
1457 void set_allocated_compute_capability(::tensorflow::ComputeCapability* compute_capability);
1458
1459 // @@protoc_insertion_point(class_scope:tensorflow.AutotuningLog)
1460 private:
1461 class _Internal;
1462
1463 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
1464 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::AutotuneResult > results_;
1465 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_pci_bus_id_;
1466 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr blas_version_;
1467 PROTOBUF_NAMESPACE_ID::Any* instr_;
1468 ::tensorflow::CudnnVersion* cudnn_version_;
1469 ::tensorflow::ComputeCapability* compute_capability_;
1470 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1471 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fautotuning_2eproto;
1472};
1473// ===================================================================
1474
1475
1476// ===================================================================
1477
1478#ifdef __GNUC__
1479 #pragma GCC diagnostic push
1480 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
1481#endif // __GNUC__
1482// CudnnVersion
1483
1484// int32 major = 1;
1485inline void CudnnVersion::clear_major() {
1486 major_ = 0;
1487}
1488inline ::PROTOBUF_NAMESPACE_ID::int32 CudnnVersion::major() const {
1489 // @@protoc_insertion_point(field_get:tensorflow.CudnnVersion.major)
1490 return major_;
1491}
1492inline void CudnnVersion::set_major(::PROTOBUF_NAMESPACE_ID::int32 value) {
1493
1494 major_ = value;
1495 // @@protoc_insertion_point(field_set:tensorflow.CudnnVersion.major)
1496}
1497
1498// int32 minor = 2;
1499inline void CudnnVersion::clear_minor() {
1500 minor_ = 0;
1501}
1502inline ::PROTOBUF_NAMESPACE_ID::int32 CudnnVersion::minor() const {
1503 // @@protoc_insertion_point(field_get:tensorflow.CudnnVersion.minor)
1504 return minor_;
1505}
1506inline void CudnnVersion::set_minor(::PROTOBUF_NAMESPACE_ID::int32 value) {
1507
1508 minor_ = value;
1509 // @@protoc_insertion_point(field_set:tensorflow.CudnnVersion.minor)
1510}
1511
1512// int32 patch = 3;
1513inline void CudnnVersion::clear_patch() {
1514 patch_ = 0;
1515}
1516inline ::PROTOBUF_NAMESPACE_ID::int32 CudnnVersion::patch() const {
1517 // @@protoc_insertion_point(field_get:tensorflow.CudnnVersion.patch)
1518 return patch_;
1519}
1520inline void CudnnVersion::set_patch(::PROTOBUF_NAMESPACE_ID::int32 value) {
1521
1522 patch_ = value;
1523 // @@protoc_insertion_point(field_set:tensorflow.CudnnVersion.patch)
1524}
1525
1526// -------------------------------------------------------------------
1527
1528// ComputeCapability
1529
1530// int32 major = 1;
1531inline void ComputeCapability::clear_major() {
1532 major_ = 0;
1533}
1534inline ::PROTOBUF_NAMESPACE_ID::int32 ComputeCapability::major() const {
1535 // @@protoc_insertion_point(field_get:tensorflow.ComputeCapability.major)
1536 return major_;
1537}
1538inline void ComputeCapability::set_major(::PROTOBUF_NAMESPACE_ID::int32 value) {
1539
1540 major_ = value;
1541 // @@protoc_insertion_point(field_set:tensorflow.ComputeCapability.major)
1542}
1543
1544// int32 minor = 2;
1545inline void ComputeCapability::clear_minor() {
1546 minor_ = 0;
1547}
1548inline ::PROTOBUF_NAMESPACE_ID::int32 ComputeCapability::minor() const {
1549 // @@protoc_insertion_point(field_get:tensorflow.ComputeCapability.minor)
1550 return minor_;
1551}
1552inline void ComputeCapability::set_minor(::PROTOBUF_NAMESPACE_ID::int32 value) {
1553
1554 minor_ = value;
1555 // @@protoc_insertion_point(field_set:tensorflow.ComputeCapability.minor)
1556}
1557
1558// -------------------------------------------------------------------
1559
1560// AutotuneResult_FailureResult
1561
1562// .tensorflow.AutotuneResult.FailureKind kind = 1;
1563inline void AutotuneResult_FailureResult::clear_kind() {
1564 kind_ = 0;
1565}
1566inline ::tensorflow::AutotuneResult_FailureKind AutotuneResult_FailureResult::kind() const {
1567 // @@protoc_insertion_point(field_get:tensorflow.AutotuneResult.FailureResult.kind)
1568 return static_cast< ::tensorflow::AutotuneResult_FailureKind >(kind_);
1569}
1570inline void AutotuneResult_FailureResult::set_kind(::tensorflow::AutotuneResult_FailureKind value) {
1571
1572 kind_ = value;
1573 // @@protoc_insertion_point(field_set:tensorflow.AutotuneResult.FailureResult.kind)
1574}
1575
1576// string msg = 2;
1577inline void AutotuneResult_FailureResult::clear_msg() {
1578 msg_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
1579}
1580inline const std::string& AutotuneResult_FailureResult::msg() const {
1581 // @@protoc_insertion_point(field_get:tensorflow.AutotuneResult.FailureResult.msg)
1582 return msg_.GetNoArena();
1583}
1584inline void AutotuneResult_FailureResult::set_msg(const std::string& value) {
1585
1586 msg_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
1587 // @@protoc_insertion_point(field_set:tensorflow.AutotuneResult.FailureResult.msg)
1588}
1589inline void AutotuneResult_FailureResult::set_msg(std::string&& value) {
1590
1591 msg_.SetNoArena(
1592 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
1593 // @@protoc_insertion_point(field_set_rvalue:tensorflow.AutotuneResult.FailureResult.msg)
1594}
1595inline void AutotuneResult_FailureResult::set_msg(const char* value) {
1596 GOOGLE_DCHECK(value != nullptr);
1597
1598 msg_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
1599 // @@protoc_insertion_point(field_set_char:tensorflow.AutotuneResult.FailureResult.msg)
1600}
1601inline void AutotuneResult_FailureResult::set_msg(const char* value, size_t size) {
1602
1603 msg_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
1604 ::std::string(reinterpret_cast<const char*>(value), size));
1605 // @@protoc_insertion_point(field_set_pointer:tensorflow.AutotuneResult.FailureResult.msg)
1606}
1607inline std::string* AutotuneResult_FailureResult::mutable_msg() {
1608
1609 // @@protoc_insertion_point(field_mutable:tensorflow.AutotuneResult.FailureResult.msg)
1610 return msg_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
1611}
1612inline std::string* AutotuneResult_FailureResult::release_msg() {
1613 // @@protoc_insertion_point(field_release:tensorflow.AutotuneResult.FailureResult.msg)
1614
1615 return msg_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
1616}
1617inline void AutotuneResult_FailureResult::set_allocated_msg(std::string* msg) {
1618 if (msg != nullptr) {
1619
1620 } else {
1621
1622 }
1623 msg_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), msg);
1624 // @@protoc_insertion_point(field_set_allocated:tensorflow.AutotuneResult.FailureResult.msg)
1625}
1626
1627// .tensorflow.AutotuneResult.ConvKey reference_conv = 11;
1628inline bool AutotuneResult_FailureResult::has_reference_conv() const {
1629 return key_case() == kReferenceConv;
1630}
1631inline void AutotuneResult_FailureResult::set_has_reference_conv() {
1632 _oneof_case_[0] = kReferenceConv;
1633}
1634inline void AutotuneResult_FailureResult::clear_reference_conv() {
1635 if (has_reference_conv()) {
1636 delete key_.reference_conv_;
1637 clear_has_key();
1638 }
1639}
1640inline ::tensorflow::AutotuneResult_ConvKey* AutotuneResult_FailureResult::release_reference_conv() {
1641 // @@protoc_insertion_point(field_release:tensorflow.AutotuneResult.FailureResult.reference_conv)
1642 if (has_reference_conv()) {
1643 clear_has_key();
1644 ::tensorflow::AutotuneResult_ConvKey* temp = key_.reference_conv_;
1645 key_.reference_conv_ = nullptr;
1646 return temp;
1647 } else {
1648 return nullptr;
1649 }
1650}
1651inline const ::tensorflow::AutotuneResult_ConvKey& AutotuneResult_FailureResult::reference_conv() const {
1652 // @@protoc_insertion_point(field_get:tensorflow.AutotuneResult.FailureResult.reference_conv)
1653 return has_reference_conv()
1654 ? *key_.reference_conv_
1655 : *reinterpret_cast< ::tensorflow::AutotuneResult_ConvKey*>(&::tensorflow::_AutotuneResult_ConvKey_default_instance_);
1656}
1657inline ::tensorflow::AutotuneResult_ConvKey* AutotuneResult_FailureResult::mutable_reference_conv() {
1658 if (!has_reference_conv()) {
1659 clear_key();
1660 set_has_reference_conv();
1661 key_.reference_conv_ = CreateMaybeMessage< ::tensorflow::AutotuneResult_ConvKey >(
1662 GetArenaNoVirtual());
1663 }
1664 // @@protoc_insertion_point(field_mutable:tensorflow.AutotuneResult.FailureResult.reference_conv)
1665 return key_.reference_conv_;
1666}
1667
1668// .tensorflow.AutotuneResult.GemmKey reference_gemm = 12;
1669inline bool AutotuneResult_FailureResult::has_reference_gemm() const {
1670 return key_case() == kReferenceGemm;
1671}
1672inline void AutotuneResult_FailureResult::set_has_reference_gemm() {
1673 _oneof_case_[0] = kReferenceGemm;
1674}
1675inline void AutotuneResult_FailureResult::clear_reference_gemm() {
1676 if (has_reference_gemm()) {
1677 delete key_.reference_gemm_;
1678 clear_has_key();
1679 }
1680}
1681inline ::tensorflow::AutotuneResult_GemmKey* AutotuneResult_FailureResult::release_reference_gemm() {
1682 // @@protoc_insertion_point(field_release:tensorflow.AutotuneResult.FailureResult.reference_gemm)
1683 if (has_reference_gemm()) {
1684 clear_has_key();
1685 ::tensorflow::AutotuneResult_GemmKey* temp = key_.reference_gemm_;
1686 key_.reference_gemm_ = nullptr;
1687 return temp;
1688 } else {
1689 return nullptr;
1690 }
1691}
1692inline const ::tensorflow::AutotuneResult_GemmKey& AutotuneResult_FailureResult::reference_gemm() const {
1693 // @@protoc_insertion_point(field_get:tensorflow.AutotuneResult.FailureResult.reference_gemm)
1694 return has_reference_gemm()
1695 ? *key_.reference_gemm_
1696 : *reinterpret_cast< ::tensorflow::AutotuneResult_GemmKey*>(&::tensorflow::_AutotuneResult_GemmKey_default_instance_);
1697}
1698inline ::tensorflow::AutotuneResult_GemmKey* AutotuneResult_FailureResult::mutable_reference_gemm() {
1699 if (!has_reference_gemm()) {
1700 clear_key();
1701 set_has_reference_gemm();
1702 key_.reference_gemm_ = CreateMaybeMessage< ::tensorflow::AutotuneResult_GemmKey >(
1703 GetArenaNoVirtual());
1704 }
1705 // @@protoc_insertion_point(field_mutable:tensorflow.AutotuneResult.FailureResult.reference_gemm)
1706 return key_.reference_gemm_;
1707}
1708
1709// .tensorflow.AutotuneResult.CudaConvPlanKey reference_cuda_conv_plan = 14;
1710inline bool AutotuneResult_FailureResult::has_reference_cuda_conv_plan() const {
1711 return key_case() == kReferenceCudaConvPlan;
1712}
1713inline void AutotuneResult_FailureResult::set_has_reference_cuda_conv_plan() {
1714 _oneof_case_[0] = kReferenceCudaConvPlan;
1715}
1716inline void AutotuneResult_FailureResult::clear_reference_cuda_conv_plan() {
1717 if (has_reference_cuda_conv_plan()) {
1718 delete key_.reference_cuda_conv_plan_;
1719 clear_has_key();
1720 }
1721}
1722inline ::tensorflow::AutotuneResult_CudaConvPlanKey* AutotuneResult_FailureResult::release_reference_cuda_conv_plan() {
1723 // @@protoc_insertion_point(field_release:tensorflow.AutotuneResult.FailureResult.reference_cuda_conv_plan)
1724 if (has_reference_cuda_conv_plan()) {
1725 clear_has_key();
1726 ::tensorflow::AutotuneResult_CudaConvPlanKey* temp = key_.reference_cuda_conv_plan_;
1727 key_.reference_cuda_conv_plan_ = nullptr;
1728 return temp;
1729 } else {
1730 return nullptr;
1731 }
1732}
1733inline const ::tensorflow::AutotuneResult_CudaConvPlanKey& AutotuneResult_FailureResult::reference_cuda_conv_plan() const {
1734 // @@protoc_insertion_point(field_get:tensorflow.AutotuneResult.FailureResult.reference_cuda_conv_plan)
1735 return has_reference_cuda_conv_plan()
1736 ? *key_.reference_cuda_conv_plan_
1737 : *reinterpret_cast< ::tensorflow::AutotuneResult_CudaConvPlanKey*>(&::tensorflow::_AutotuneResult_CudaConvPlanKey_default_instance_);
1738}
1739inline ::tensorflow::AutotuneResult_CudaConvPlanKey* AutotuneResult_FailureResult::mutable_reference_cuda_conv_plan() {
1740 if (!has_reference_cuda_conv_plan()) {
1741 clear_key();
1742 set_has_reference_cuda_conv_plan();
1743 key_.reference_cuda_conv_plan_ = CreateMaybeMessage< ::tensorflow::AutotuneResult_CudaConvPlanKey >(
1744 GetArenaNoVirtual());
1745 }
1746 // @@protoc_insertion_point(field_mutable:tensorflow.AutotuneResult.FailureResult.reference_cuda_conv_plan)
1747 return key_.reference_cuda_conv_plan_;
1748}
1749
1750// .stream_executor.dnn.AlgorithmProto reference_algorithm = 15;
1751inline bool AutotuneResult_FailureResult::has_reference_algorithm() const {
1752 return key_case() == kReferenceAlgorithm;
1753}
1754inline void AutotuneResult_FailureResult::set_has_reference_algorithm() {
1755 _oneof_case_[0] = kReferenceAlgorithm;
1756}
1757inline ::stream_executor::dnn::AlgorithmProto* AutotuneResult_FailureResult::release_reference_algorithm() {
1758 // @@protoc_insertion_point(field_release:tensorflow.AutotuneResult.FailureResult.reference_algorithm)
1759 if (has_reference_algorithm()) {
1760 clear_has_key();
1761 ::stream_executor::dnn::AlgorithmProto* temp = key_.reference_algorithm_;
1762 key_.reference_algorithm_ = nullptr;
1763 return temp;
1764 } else {
1765 return nullptr;
1766 }
1767}
1768inline const ::stream_executor::dnn::AlgorithmProto& AutotuneResult_FailureResult::reference_algorithm() const {
1769 // @@protoc_insertion_point(field_get:tensorflow.AutotuneResult.FailureResult.reference_algorithm)
1770 return has_reference_algorithm()
1771 ? *key_.reference_algorithm_
1772 : *reinterpret_cast< ::stream_executor::dnn::AlgorithmProto*>(&::stream_executor::dnn::_AlgorithmProto_default_instance_);
1773}
1774inline ::stream_executor::dnn::AlgorithmProto* AutotuneResult_FailureResult::mutable_reference_algorithm() {
1775 if (!has_reference_algorithm()) {
1776 clear_key();
1777 set_has_reference_algorithm();
1778 key_.reference_algorithm_ = CreateMaybeMessage< ::stream_executor::dnn::AlgorithmProto >(
1779 GetArenaNoVirtual());
1780 }
1781 // @@protoc_insertion_point(field_mutable:tensorflow.AutotuneResult.FailureResult.reference_algorithm)
1782 return key_.reference_algorithm_;
1783}
1784
1785// int64 buffer_address = 13;
1786inline void AutotuneResult_FailureResult::clear_buffer_address() {
1787 buffer_address_ = PROTOBUF_LONGLONG(0);
1788}
1789inline ::PROTOBUF_NAMESPACE_ID::int64 AutotuneResult_FailureResult::buffer_address() const {
1790 // @@protoc_insertion_point(field_get:tensorflow.AutotuneResult.FailureResult.buffer_address)
1791 return buffer_address_;
1792}
1793inline void AutotuneResult_FailureResult::set_buffer_address(::PROTOBUF_NAMESPACE_ID::int64 value) {
1794
1795 buffer_address_ = value;
1796 // @@protoc_insertion_point(field_set:tensorflow.AutotuneResult.FailureResult.buffer_address)
1797}
1798
1799inline bool AutotuneResult_FailureResult::has_key() const {
1800 return key_case() != KEY_NOT_SET;
1801}
1802inline void AutotuneResult_FailureResult::clear_has_key() {
1803 _oneof_case_[0] = KEY_NOT_SET;
1804}
1805inline AutotuneResult_FailureResult::KeyCase AutotuneResult_FailureResult::key_case() const {
1806 return AutotuneResult_FailureResult::KeyCase(_oneof_case_[0]);
1807}
1808// -------------------------------------------------------------------
1809
1810// AutotuneResult_ConvKey
1811
1812// int64 algorithm = 1;
1813inline void AutotuneResult_ConvKey::clear_algorithm() {
1814 algorithm_ = PROTOBUF_LONGLONG(0);
1815}
1816inline ::PROTOBUF_NAMESPACE_ID::int64 AutotuneResult_ConvKey::algorithm() const {
1817 // @@protoc_insertion_point(field_get:tensorflow.AutotuneResult.ConvKey.algorithm)
1818 return algorithm_;
1819}
1820inline void AutotuneResult_ConvKey::set_algorithm(::PROTOBUF_NAMESPACE_ID::int64 value) {
1821
1822 algorithm_ = value;
1823 // @@protoc_insertion_point(field_set:tensorflow.AutotuneResult.ConvKey.algorithm)
1824}
1825
1826// bool tensor_ops_enabled = 2;
1827inline void AutotuneResult_ConvKey::clear_tensor_ops_enabled() {
1828 tensor_ops_enabled_ = false;
1829}
1830inline bool AutotuneResult_ConvKey::tensor_ops_enabled() const {
1831 // @@protoc_insertion_point(field_get:tensorflow.AutotuneResult.ConvKey.tensor_ops_enabled)
1832 return tensor_ops_enabled_;
1833}
1834inline void AutotuneResult_ConvKey::set_tensor_ops_enabled(bool value) {
1835
1836 tensor_ops_enabled_ = value;
1837 // @@protoc_insertion_point(field_set:tensorflow.AutotuneResult.ConvKey.tensor_ops_enabled)
1838}
1839
1840// -------------------------------------------------------------------
1841
1842// AutotuneResult_GemmKey
1843
1844// int64 algorithm = 1;
1845inline void AutotuneResult_GemmKey::clear_algorithm() {
1846 algorithm_ = PROTOBUF_LONGLONG(0);
1847}
1848inline ::PROTOBUF_NAMESPACE_ID::int64 AutotuneResult_GemmKey::algorithm() const {
1849 // @@protoc_insertion_point(field_get:tensorflow.AutotuneResult.GemmKey.algorithm)
1850 return algorithm_;
1851}
1852inline void AutotuneResult_GemmKey::set_algorithm(::PROTOBUF_NAMESPACE_ID::int64 value) {
1853
1854 algorithm_ = value;
1855 // @@protoc_insertion_point(field_set:tensorflow.AutotuneResult.GemmKey.algorithm)
1856}
1857
1858// -------------------------------------------------------------------
1859
1860// AutotuneResult_CudaConvPlanKey
1861
1862// string exec_plan_id = 1;
1863inline void AutotuneResult_CudaConvPlanKey::clear_exec_plan_id() {
1864 exec_plan_id_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
1865}
1866inline const std::string& AutotuneResult_CudaConvPlanKey::exec_plan_id() const {
1867 // @@protoc_insertion_point(field_get:tensorflow.AutotuneResult.CudaConvPlanKey.exec_plan_id)
1868 return exec_plan_id_.GetNoArena();
1869}
1870inline void AutotuneResult_CudaConvPlanKey::set_exec_plan_id(const std::string& value) {
1871
1872 exec_plan_id_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
1873 // @@protoc_insertion_point(field_set:tensorflow.AutotuneResult.CudaConvPlanKey.exec_plan_id)
1874}
1875inline void AutotuneResult_CudaConvPlanKey::set_exec_plan_id(std::string&& value) {
1876
1877 exec_plan_id_.SetNoArena(
1878 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
1879 // @@protoc_insertion_point(field_set_rvalue:tensorflow.AutotuneResult.CudaConvPlanKey.exec_plan_id)
1880}
1881inline void AutotuneResult_CudaConvPlanKey::set_exec_plan_id(const char* value) {
1882 GOOGLE_DCHECK(value != nullptr);
1883
1884 exec_plan_id_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
1885 // @@protoc_insertion_point(field_set_char:tensorflow.AutotuneResult.CudaConvPlanKey.exec_plan_id)
1886}
1887inline void AutotuneResult_CudaConvPlanKey::set_exec_plan_id(const char* value, size_t size) {
1888
1889 exec_plan_id_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
1890 ::std::string(reinterpret_cast<const char*>(value), size));
1891 // @@protoc_insertion_point(field_set_pointer:tensorflow.AutotuneResult.CudaConvPlanKey.exec_plan_id)
1892}
1893inline std::string* AutotuneResult_CudaConvPlanKey::mutable_exec_plan_id() {
1894
1895 // @@protoc_insertion_point(field_mutable:tensorflow.AutotuneResult.CudaConvPlanKey.exec_plan_id)
1896 return exec_plan_id_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
1897}
1898inline std::string* AutotuneResult_CudaConvPlanKey::release_exec_plan_id() {
1899 // @@protoc_insertion_point(field_release:tensorflow.AutotuneResult.CudaConvPlanKey.exec_plan_id)
1900
1901 return exec_plan_id_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
1902}
1903inline void AutotuneResult_CudaConvPlanKey::set_allocated_exec_plan_id(std::string* exec_plan_id) {
1904 if (exec_plan_id != nullptr) {
1905
1906 } else {
1907
1908 }
1909 exec_plan_id_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), exec_plan_id);
1910 // @@protoc_insertion_point(field_set_allocated:tensorflow.AutotuneResult.CudaConvPlanKey.exec_plan_id)
1911}
1912
1913// -------------------------------------------------------------------
1914
1915// AutotuneResult
1916
1917// int64 scratch_bytes = 8;
1918inline void AutotuneResult::clear_scratch_bytes() {
1919 scratch_bytes_ = PROTOBUF_LONGLONG(0);
1920}
1921inline ::PROTOBUF_NAMESPACE_ID::int64 AutotuneResult::scratch_bytes() const {
1922 // @@protoc_insertion_point(field_get:tensorflow.AutotuneResult.scratch_bytes)
1923 return scratch_bytes_;
1924}
1925inline void AutotuneResult::set_scratch_bytes(::PROTOBUF_NAMESPACE_ID::int64 value) {
1926
1927 scratch_bytes_ = value;
1928 // @@protoc_insertion_point(field_set:tensorflow.AutotuneResult.scratch_bytes)
1929}
1930
1931// .google.protobuf.Duration run_time = 9;
1932inline bool AutotuneResult::has_run_time() const {
1933 return this != internal_default_instance() && run_time_ != nullptr;
1934}
1935inline const PROTOBUF_NAMESPACE_ID::Duration& AutotuneResult::run_time() const {
1936 const PROTOBUF_NAMESPACE_ID::Duration* p = run_time_;
1937 // @@protoc_insertion_point(field_get:tensorflow.AutotuneResult.run_time)
1938 return p != nullptr ? *p : *reinterpret_cast<const PROTOBUF_NAMESPACE_ID::Duration*>(
1939 &PROTOBUF_NAMESPACE_ID::_Duration_default_instance_);
1940}
1941inline PROTOBUF_NAMESPACE_ID::Duration* AutotuneResult::release_run_time() {
1942 // @@protoc_insertion_point(field_release:tensorflow.AutotuneResult.run_time)
1943
1944 PROTOBUF_NAMESPACE_ID::Duration* temp = run_time_;
1945 run_time_ = nullptr;
1946 return temp;
1947}
1948inline PROTOBUF_NAMESPACE_ID::Duration* AutotuneResult::mutable_run_time() {
1949
1950 if (run_time_ == nullptr) {
1951 auto* p = CreateMaybeMessage<PROTOBUF_NAMESPACE_ID::Duration>(GetArenaNoVirtual());
1952 run_time_ = p;
1953 }
1954 // @@protoc_insertion_point(field_mutable:tensorflow.AutotuneResult.run_time)
1955 return run_time_;
1956}
1957inline void AutotuneResult::set_allocated_run_time(PROTOBUF_NAMESPACE_ID::Duration* run_time) {
1958 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
1959 if (message_arena == nullptr) {
1960 delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(run_time_);
1961 }
1962 if (run_time) {
1963 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
1964 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(run_time)->GetArena();
1965 if (message_arena != submessage_arena) {
1966 run_time = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
1967 message_arena, run_time, submessage_arena);
1968 }
1969
1970 } else {
1971
1972 }
1973 run_time_ = run_time;
1974 // @@protoc_insertion_point(field_set_allocated:tensorflow.AutotuneResult.run_time)
1975}
1976
1977// .tensorflow.AutotuneResult.FailureResult failure = 7;
1978inline bool AutotuneResult::has_failure() const {
1979 return this != internal_default_instance() && failure_ != nullptr;
1980}
1981inline void AutotuneResult::clear_failure() {
1982 if (GetArenaNoVirtual() == nullptr && failure_ != nullptr) {
1983 delete failure_;
1984 }
1985 failure_ = nullptr;
1986}
1987inline const ::tensorflow::AutotuneResult_FailureResult& AutotuneResult::failure() const {
1988 const ::tensorflow::AutotuneResult_FailureResult* p = failure_;
1989 // @@protoc_insertion_point(field_get:tensorflow.AutotuneResult.failure)
1990 return p != nullptr ? *p : *reinterpret_cast<const ::tensorflow::AutotuneResult_FailureResult*>(
1991 &::tensorflow::_AutotuneResult_FailureResult_default_instance_);
1992}
1993inline ::tensorflow::AutotuneResult_FailureResult* AutotuneResult::release_failure() {
1994 // @@protoc_insertion_point(field_release:tensorflow.AutotuneResult.failure)
1995
1996 ::tensorflow::AutotuneResult_FailureResult* temp = failure_;
1997 failure_ = nullptr;
1998 return temp;
1999}
2000inline ::tensorflow::AutotuneResult_FailureResult* AutotuneResult::mutable_failure() {
2001
2002 if (failure_ == nullptr) {
2003 auto* p = CreateMaybeMessage<::tensorflow::AutotuneResult_FailureResult>(GetArenaNoVirtual());
2004 failure_ = p;
2005 }
2006 // @@protoc_insertion_point(field_mutable:tensorflow.AutotuneResult.failure)
2007 return failure_;
2008}
2009inline void AutotuneResult::set_allocated_failure(::tensorflow::AutotuneResult_FailureResult* failure) {
2010 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
2011 if (message_arena == nullptr) {
2012 delete failure_;
2013 }
2014 if (failure) {
2015 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
2016 if (message_arena != submessage_arena) {
2017 failure = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
2018 message_arena, failure, submessage_arena);
2019 }
2020
2021 } else {
2022
2023 }
2024 failure_ = failure;
2025 // @@protoc_insertion_point(field_set_allocated:tensorflow.AutotuneResult.failure)
2026}
2027
2028// .tensorflow.AutotuneResult.ConvKey conv = 5;
2029inline bool AutotuneResult::has_conv() const {
2030 return key_case() == kConv;
2031}
2032inline void AutotuneResult::set_has_conv() {
2033 _oneof_case_[0] = kConv;
2034}
2035inline void AutotuneResult::clear_conv() {
2036 if (has_conv()) {
2037 delete key_.conv_;
2038 clear_has_key();
2039 }
2040}
2041inline ::tensorflow::AutotuneResult_ConvKey* AutotuneResult::release_conv() {
2042 // @@protoc_insertion_point(field_release:tensorflow.AutotuneResult.conv)
2043 if (has_conv()) {
2044 clear_has_key();
2045 ::tensorflow::AutotuneResult_ConvKey* temp = key_.conv_;
2046 key_.conv_ = nullptr;
2047 return temp;
2048 } else {
2049 return nullptr;
2050 }
2051}
2052inline const ::tensorflow::AutotuneResult_ConvKey& AutotuneResult::conv() const {
2053 // @@protoc_insertion_point(field_get:tensorflow.AutotuneResult.conv)
2054 return has_conv()
2055 ? *key_.conv_
2056 : *reinterpret_cast< ::tensorflow::AutotuneResult_ConvKey*>(&::tensorflow::_AutotuneResult_ConvKey_default_instance_);
2057}
2058inline ::tensorflow::AutotuneResult_ConvKey* AutotuneResult::mutable_conv() {
2059 if (!has_conv()) {
2060 clear_key();
2061 set_has_conv();
2062 key_.conv_ = CreateMaybeMessage< ::tensorflow::AutotuneResult_ConvKey >(
2063 GetArenaNoVirtual());
2064 }
2065 // @@protoc_insertion_point(field_mutable:tensorflow.AutotuneResult.conv)
2066 return key_.conv_;
2067}
2068
2069// .tensorflow.AutotuneResult.GemmKey gemm = 6;
2070inline bool AutotuneResult::has_gemm() const {
2071 return key_case() == kGemm;
2072}
2073inline void AutotuneResult::set_has_gemm() {
2074 _oneof_case_[0] = kGemm;
2075}
2076inline void AutotuneResult::clear_gemm() {
2077 if (has_gemm()) {
2078 delete key_.gemm_;
2079 clear_has_key();
2080 }
2081}
2082inline ::tensorflow::AutotuneResult_GemmKey* AutotuneResult::release_gemm() {
2083 // @@protoc_insertion_point(field_release:tensorflow.AutotuneResult.gemm)
2084 if (has_gemm()) {
2085 clear_has_key();
2086 ::tensorflow::AutotuneResult_GemmKey* temp = key_.gemm_;
2087 key_.gemm_ = nullptr;
2088 return temp;
2089 } else {
2090 return nullptr;
2091 }
2092}
2093inline const ::tensorflow::AutotuneResult_GemmKey& AutotuneResult::gemm() const {
2094 // @@protoc_insertion_point(field_get:tensorflow.AutotuneResult.gemm)
2095 return has_gemm()
2096 ? *key_.gemm_
2097 : *reinterpret_cast< ::tensorflow::AutotuneResult_GemmKey*>(&::tensorflow::_AutotuneResult_GemmKey_default_instance_);
2098}
2099inline ::tensorflow::AutotuneResult_GemmKey* AutotuneResult::mutable_gemm() {
2100 if (!has_gemm()) {
2101 clear_key();
2102 set_has_gemm();
2103 key_.gemm_ = CreateMaybeMessage< ::tensorflow::AutotuneResult_GemmKey >(
2104 GetArenaNoVirtual());
2105 }
2106 // @@protoc_insertion_point(field_mutable:tensorflow.AutotuneResult.gemm)
2107 return key_.gemm_;
2108}
2109
2110// .tensorflow.AutotuneResult.CudaConvPlanKey cuda_conv_plan = 15;
2111inline bool AutotuneResult::has_cuda_conv_plan() const {
2112 return key_case() == kCudaConvPlan;
2113}
2114inline void AutotuneResult::set_has_cuda_conv_plan() {
2115 _oneof_case_[0] = kCudaConvPlan;
2116}
2117inline void AutotuneResult::clear_cuda_conv_plan() {
2118 if (has_cuda_conv_plan()) {
2119 delete key_.cuda_conv_plan_;
2120 clear_has_key();
2121 }
2122}
2123inline ::tensorflow::AutotuneResult_CudaConvPlanKey* AutotuneResult::release_cuda_conv_plan() {
2124 // @@protoc_insertion_point(field_release:tensorflow.AutotuneResult.cuda_conv_plan)
2125 if (has_cuda_conv_plan()) {
2126 clear_has_key();
2127 ::tensorflow::AutotuneResult_CudaConvPlanKey* temp = key_.cuda_conv_plan_;
2128 key_.cuda_conv_plan_ = nullptr;
2129 return temp;
2130 } else {
2131 return nullptr;
2132 }
2133}
2134inline const ::tensorflow::AutotuneResult_CudaConvPlanKey& AutotuneResult::cuda_conv_plan() const {
2135 // @@protoc_insertion_point(field_get:tensorflow.AutotuneResult.cuda_conv_plan)
2136 return has_cuda_conv_plan()
2137 ? *key_.cuda_conv_plan_
2138 : *reinterpret_cast< ::tensorflow::AutotuneResult_CudaConvPlanKey*>(&::tensorflow::_AutotuneResult_CudaConvPlanKey_default_instance_);
2139}
2140inline ::tensorflow::AutotuneResult_CudaConvPlanKey* AutotuneResult::mutable_cuda_conv_plan() {
2141 if (!has_cuda_conv_plan()) {
2142 clear_key();
2143 set_has_cuda_conv_plan();
2144 key_.cuda_conv_plan_ = CreateMaybeMessage< ::tensorflow::AutotuneResult_CudaConvPlanKey >(
2145 GetArenaNoVirtual());
2146 }
2147 // @@protoc_insertion_point(field_mutable:tensorflow.AutotuneResult.cuda_conv_plan)
2148 return key_.cuda_conv_plan_;
2149}
2150
2151// .stream_executor.dnn.AlgorithmProto algorithm = 16;
2152inline bool AutotuneResult::has_algorithm() const {
2153 return key_case() == kAlgorithm;
2154}
2155inline void AutotuneResult::set_has_algorithm() {
2156 _oneof_case_[0] = kAlgorithm;
2157}
2158inline ::stream_executor::dnn::AlgorithmProto* AutotuneResult::release_algorithm() {
2159 // @@protoc_insertion_point(field_release:tensorflow.AutotuneResult.algorithm)
2160 if (has_algorithm()) {
2161 clear_has_key();
2162 ::stream_executor::dnn::AlgorithmProto* temp = key_.algorithm_;
2163 key_.algorithm_ = nullptr;
2164 return temp;
2165 } else {
2166 return nullptr;
2167 }
2168}
2169inline const ::stream_executor::dnn::AlgorithmProto& AutotuneResult::algorithm() const {
2170 // @@protoc_insertion_point(field_get:tensorflow.AutotuneResult.algorithm)
2171 return has_algorithm()
2172 ? *key_.algorithm_
2173 : *reinterpret_cast< ::stream_executor::dnn::AlgorithmProto*>(&::stream_executor::dnn::_AlgorithmProto_default_instance_);
2174}
2175inline ::stream_executor::dnn::AlgorithmProto* AutotuneResult::mutable_algorithm() {
2176 if (!has_algorithm()) {
2177 clear_key();
2178 set_has_algorithm();
2179 key_.algorithm_ = CreateMaybeMessage< ::stream_executor::dnn::AlgorithmProto >(
2180 GetArenaNoVirtual());
2181 }
2182 // @@protoc_insertion_point(field_mutable:tensorflow.AutotuneResult.algorithm)
2183 return key_.algorithm_;
2184}
2185
2186inline bool AutotuneResult::has_key() const {
2187 return key_case() != KEY_NOT_SET;
2188}
2189inline void AutotuneResult::clear_has_key() {
2190 _oneof_case_[0] = KEY_NOT_SET;
2191}
2192inline AutotuneResult::KeyCase AutotuneResult::key_case() const {
2193 return AutotuneResult::KeyCase(_oneof_case_[0]);
2194}
2195// -------------------------------------------------------------------
2196
2197// AutotuningLog
2198
2199// .google.protobuf.Any instr = 1;
2200inline bool AutotuningLog::has_instr() const {
2201 return this != internal_default_instance() && instr_ != nullptr;
2202}
2203inline const PROTOBUF_NAMESPACE_ID::Any& AutotuningLog::instr() const {
2204 const PROTOBUF_NAMESPACE_ID::Any* p = instr_;
2205 // @@protoc_insertion_point(field_get:tensorflow.AutotuningLog.instr)
2206 return p != nullptr ? *p : *reinterpret_cast<const PROTOBUF_NAMESPACE_ID::Any*>(
2207 &PROTOBUF_NAMESPACE_ID::_Any_default_instance_);
2208}
2209inline PROTOBUF_NAMESPACE_ID::Any* AutotuningLog::release_instr() {
2210 // @@protoc_insertion_point(field_release:tensorflow.AutotuningLog.instr)
2211
2212 PROTOBUF_NAMESPACE_ID::Any* temp = instr_;
2213 instr_ = nullptr;
2214 return temp;
2215}
2216inline PROTOBUF_NAMESPACE_ID::Any* AutotuningLog::mutable_instr() {
2217
2218 if (instr_ == nullptr) {
2219 auto* p = CreateMaybeMessage<PROTOBUF_NAMESPACE_ID::Any>(GetArenaNoVirtual());
2220 instr_ = p;
2221 }
2222 // @@protoc_insertion_point(field_mutable:tensorflow.AutotuningLog.instr)
2223 return instr_;
2224}
2225inline void AutotuningLog::set_allocated_instr(PROTOBUF_NAMESPACE_ID::Any* instr) {
2226 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
2227 if (message_arena == nullptr) {
2228 delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(instr_);
2229 }
2230 if (instr) {
2231 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
2232 if (message_arena != submessage_arena) {
2233 instr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
2234 message_arena, instr, submessage_arena);
2235 }
2236
2237 } else {
2238
2239 }
2240 instr_ = instr;
2241 // @@protoc_insertion_point(field_set_allocated:tensorflow.AutotuningLog.instr)
2242}
2243
2244// repeated .tensorflow.AutotuneResult results = 2;
2245inline int AutotuningLog::results_size() const {
2246 return results_.size();
2247}
2248inline void AutotuningLog::clear_results() {
2249 results_.Clear();
2250}
2251inline ::tensorflow::AutotuneResult* AutotuningLog::mutable_results(int index) {
2252 // @@protoc_insertion_point(field_mutable:tensorflow.AutotuningLog.results)
2253 return results_.Mutable(index);
2254}
2255inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::AutotuneResult >*
2256AutotuningLog::mutable_results() {
2257 // @@protoc_insertion_point(field_mutable_list:tensorflow.AutotuningLog.results)
2258 return &results_;
2259}
2260inline const ::tensorflow::AutotuneResult& AutotuningLog::results(int index) const {
2261 // @@protoc_insertion_point(field_get:tensorflow.AutotuningLog.results)
2262 return results_.Get(index);
2263}
2264inline ::tensorflow::AutotuneResult* AutotuningLog::add_results() {
2265 // @@protoc_insertion_point(field_add:tensorflow.AutotuningLog.results)
2266 return results_.Add();
2267}
2268inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::AutotuneResult >&
2269AutotuningLog::results() const {
2270 // @@protoc_insertion_point(field_list:tensorflow.AutotuningLog.results)
2271 return results_;
2272}
2273
2274// .tensorflow.CudnnVersion cudnn_version = 3;
2275inline bool AutotuningLog::has_cudnn_version() const {
2276 return this != internal_default_instance() && cudnn_version_ != nullptr;
2277}
2278inline void AutotuningLog::clear_cudnn_version() {
2279 if (GetArenaNoVirtual() == nullptr && cudnn_version_ != nullptr) {
2280 delete cudnn_version_;
2281 }
2282 cudnn_version_ = nullptr;
2283}
2284inline const ::tensorflow::CudnnVersion& AutotuningLog::cudnn_version() const {
2285 const ::tensorflow::CudnnVersion* p = cudnn_version_;
2286 // @@protoc_insertion_point(field_get:tensorflow.AutotuningLog.cudnn_version)
2287 return p != nullptr ? *p : *reinterpret_cast<const ::tensorflow::CudnnVersion*>(
2288 &::tensorflow::_CudnnVersion_default_instance_);
2289}
2290inline ::tensorflow::CudnnVersion* AutotuningLog::release_cudnn_version() {
2291 // @@protoc_insertion_point(field_release:tensorflow.AutotuningLog.cudnn_version)
2292
2293 ::tensorflow::CudnnVersion* temp = cudnn_version_;
2294 cudnn_version_ = nullptr;
2295 return temp;
2296}
2297inline ::tensorflow::CudnnVersion* AutotuningLog::mutable_cudnn_version() {
2298
2299 if (cudnn_version_ == nullptr) {
2300 auto* p = CreateMaybeMessage<::tensorflow::CudnnVersion>(GetArenaNoVirtual());
2301 cudnn_version_ = p;
2302 }
2303 // @@protoc_insertion_point(field_mutable:tensorflow.AutotuningLog.cudnn_version)
2304 return cudnn_version_;
2305}
2306inline void AutotuningLog::set_allocated_cudnn_version(::tensorflow::CudnnVersion* cudnn_version) {
2307 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
2308 if (message_arena == nullptr) {
2309 delete cudnn_version_;
2310 }
2311 if (cudnn_version) {
2312 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
2313 if (message_arena != submessage_arena) {
2314 cudnn_version = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
2315 message_arena, cudnn_version, submessage_arena);
2316 }
2317
2318 } else {
2319
2320 }
2321 cudnn_version_ = cudnn_version;
2322 // @@protoc_insertion_point(field_set_allocated:tensorflow.AutotuningLog.cudnn_version)
2323}
2324
2325// .tensorflow.ComputeCapability compute_capability = 4;
2326inline bool AutotuningLog::has_compute_capability() const {
2327 return this != internal_default_instance() && compute_capability_ != nullptr;
2328}
2329inline void AutotuningLog::clear_compute_capability() {
2330 if (GetArenaNoVirtual() == nullptr && compute_capability_ != nullptr) {
2331 delete compute_capability_;
2332 }
2333 compute_capability_ = nullptr;
2334}
2335inline const ::tensorflow::ComputeCapability& AutotuningLog::compute_capability() const {
2336 const ::tensorflow::ComputeCapability* p = compute_capability_;
2337 // @@protoc_insertion_point(field_get:tensorflow.AutotuningLog.compute_capability)
2338 return p != nullptr ? *p : *reinterpret_cast<const ::tensorflow::ComputeCapability*>(
2339 &::tensorflow::_ComputeCapability_default_instance_);
2340}
2341inline ::tensorflow::ComputeCapability* AutotuningLog::release_compute_capability() {
2342 // @@protoc_insertion_point(field_release:tensorflow.AutotuningLog.compute_capability)
2343
2344 ::tensorflow::ComputeCapability* temp = compute_capability_;
2345 compute_capability_ = nullptr;
2346 return temp;
2347}
2348inline ::tensorflow::ComputeCapability* AutotuningLog::mutable_compute_capability() {
2349
2350 if (compute_capability_ == nullptr) {
2351 auto* p = CreateMaybeMessage<::tensorflow::ComputeCapability>(GetArenaNoVirtual());
2352 compute_capability_ = p;
2353 }
2354 // @@protoc_insertion_point(field_mutable:tensorflow.AutotuningLog.compute_capability)
2355 return compute_capability_;
2356}
2357inline void AutotuningLog::set_allocated_compute_capability(::tensorflow::ComputeCapability* compute_capability) {
2358 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
2359 if (message_arena == nullptr) {
2360 delete compute_capability_;
2361 }
2362 if (compute_capability) {
2363 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
2364 if (message_arena != submessage_arena) {
2365 compute_capability = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
2366 message_arena, compute_capability, submessage_arena);
2367 }
2368
2369 } else {
2370
2371 }
2372 compute_capability_ = compute_capability;
2373 // @@protoc_insertion_point(field_set_allocated:tensorflow.AutotuningLog.compute_capability)
2374}
2375
2376// string device_pci_bus_id = 5;
2377inline void AutotuningLog::clear_device_pci_bus_id() {
2378 device_pci_bus_id_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
2379}
2380inline const std::string& AutotuningLog::device_pci_bus_id() const {
2381 // @@protoc_insertion_point(field_get:tensorflow.AutotuningLog.device_pci_bus_id)
2382 return device_pci_bus_id_.GetNoArena();
2383}
2384inline void AutotuningLog::set_device_pci_bus_id(const std::string& value) {
2385
2386 device_pci_bus_id_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
2387 // @@protoc_insertion_point(field_set:tensorflow.AutotuningLog.device_pci_bus_id)
2388}
2389inline void AutotuningLog::set_device_pci_bus_id(std::string&& value) {
2390
2391 device_pci_bus_id_.SetNoArena(
2392 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
2393 // @@protoc_insertion_point(field_set_rvalue:tensorflow.AutotuningLog.device_pci_bus_id)
2394}
2395inline void AutotuningLog::set_device_pci_bus_id(const char* value) {
2396 GOOGLE_DCHECK(value != nullptr);
2397
2398 device_pci_bus_id_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
2399 // @@protoc_insertion_point(field_set_char:tensorflow.AutotuningLog.device_pci_bus_id)
2400}
2401inline void AutotuningLog::set_device_pci_bus_id(const char* value, size_t size) {
2402
2403 device_pci_bus_id_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
2404 ::std::string(reinterpret_cast<const char*>(value), size));
2405 // @@protoc_insertion_point(field_set_pointer:tensorflow.AutotuningLog.device_pci_bus_id)
2406}
2407inline std::string* AutotuningLog::mutable_device_pci_bus_id() {
2408
2409 // @@protoc_insertion_point(field_mutable:tensorflow.AutotuningLog.device_pci_bus_id)
2410 return device_pci_bus_id_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
2411}
2412inline std::string* AutotuningLog::release_device_pci_bus_id() {
2413 // @@protoc_insertion_point(field_release:tensorflow.AutotuningLog.device_pci_bus_id)
2414
2415 return device_pci_bus_id_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
2416}
2417inline void AutotuningLog::set_allocated_device_pci_bus_id(std::string* device_pci_bus_id) {
2418 if (device_pci_bus_id != nullptr) {
2419
2420 } else {
2421
2422 }
2423 device_pci_bus_id_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), device_pci_bus_id);
2424 // @@protoc_insertion_point(field_set_allocated:tensorflow.AutotuningLog.device_pci_bus_id)
2425}
2426
2427// string blas_version = 6;
2428inline void AutotuningLog::clear_blas_version() {
2429 blas_version_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
2430}
2431inline const std::string& AutotuningLog::blas_version() const {
2432 // @@protoc_insertion_point(field_get:tensorflow.AutotuningLog.blas_version)
2433 return blas_version_.GetNoArena();
2434}
2435inline void AutotuningLog::set_blas_version(const std::string& value) {
2436
2437 blas_version_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
2438 // @@protoc_insertion_point(field_set:tensorflow.AutotuningLog.blas_version)
2439}
2440inline void AutotuningLog::set_blas_version(std::string&& value) {
2441
2442 blas_version_.SetNoArena(
2443 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
2444 // @@protoc_insertion_point(field_set_rvalue:tensorflow.AutotuningLog.blas_version)
2445}
2446inline void AutotuningLog::set_blas_version(const char* value) {
2447 GOOGLE_DCHECK(value != nullptr);
2448
2449 blas_version_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
2450 // @@protoc_insertion_point(field_set_char:tensorflow.AutotuningLog.blas_version)
2451}
2452inline void AutotuningLog::set_blas_version(const char* value, size_t size) {
2453
2454 blas_version_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
2455 ::std::string(reinterpret_cast<const char*>(value), size));
2456 // @@protoc_insertion_point(field_set_pointer:tensorflow.AutotuningLog.blas_version)
2457}
2458inline std::string* AutotuningLog::mutable_blas_version() {
2459
2460 // @@protoc_insertion_point(field_mutable:tensorflow.AutotuningLog.blas_version)
2461 return blas_version_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
2462}
2463inline std::string* AutotuningLog::release_blas_version() {
2464 // @@protoc_insertion_point(field_release:tensorflow.AutotuningLog.blas_version)
2465
2466 return blas_version_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
2467}
2468inline void AutotuningLog::set_allocated_blas_version(std::string* blas_version) {
2469 if (blas_version != nullptr) {
2470
2471 } else {
2472
2473 }
2474 blas_version_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), blas_version);
2475 // @@protoc_insertion_point(field_set_allocated:tensorflow.AutotuningLog.blas_version)
2476}
2477
2478#ifdef __GNUC__
2479 #pragma GCC diagnostic pop
2480#endif // __GNUC__
2481// -------------------------------------------------------------------
2482
2483// -------------------------------------------------------------------
2484
2485// -------------------------------------------------------------------
2486
2487// -------------------------------------------------------------------
2488
2489// -------------------------------------------------------------------
2490
2491// -------------------------------------------------------------------
2492
2493// -------------------------------------------------------------------
2494
2495
2496// @@protoc_insertion_point(namespace_scope)
2497
2498} // namespace tensorflow
2499
2500PROTOBUF_NAMESPACE_OPEN
2501
2502template <> struct is_proto_enum< ::tensorflow::AutotuneResult_FailureKind> : ::std::true_type {};
2503template <>
2504inline const EnumDescriptor* GetEnumDescriptor< ::tensorflow::AutotuneResult_FailureKind>() {
2505 return ::tensorflow::AutotuneResult_FailureKind_descriptor();
2506}
2507
2508PROTOBUF_NAMESPACE_CLOSE
2509
2510// @@protoc_insertion_point(global_scope)
2511
2512#include <google/protobuf/port_undef.inc>
2513#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fprotobuf_2fautotuning_2eproto
2514