1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: tensorflow/compiler/xla/stream_executor/dnn.proto
3
4 #ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcompiler_2fxla_2fstream_5fexecutor_2fdnn_2eproto
5 #define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcompiler_2fxla_2fstream_5fexecutor_2fdnn_2eproto
6
7 #include <cstdint>
8 #include <limits>
9 #include <string>
10
11 #include <google/protobuf/port_def.inc>
12 #if PROTOBUF_VERSION < 3021000
13 #error This file was generated by a newer version of protoc which is
14 #error incompatible with your Protocol Buffer headers. Please update
15 #error your headers.
16 #endif
17 #if 3021012 < PROTOBUF_MIN_PROTOC_VERSION
18 #error This file was generated by an older version of protoc which is
19 #error incompatible with your Protocol Buffer headers. Please
20 #error regenerate this file with a newer version of protoc.
21 #endif
22
23 #include <google/protobuf/port_undef.inc>
24 #include <google/protobuf/io/coded_stream.h>
25 #include <google/protobuf/arena.h>
26 #include <google/protobuf/arenastring.h>
27 #include <google/protobuf/generated_message_util.h>
28 #include <google/protobuf/metadata_lite.h>
29 #include <google/protobuf/message_lite.h>
30 #include <google/protobuf/repeated_field.h> // IWYU pragma: export
31 #include <google/protobuf/extension_set.h> // IWYU pragma: export
32 #include <google/protobuf/map.h> // IWYU pragma: export
33 #include <google/protobuf/map_entry_lite.h>
34 #include <google/protobuf/map_field_lite.h>
35 #include <google/protobuf/generated_enum_util.h>
36 #include <google/protobuf/wrappers.pb.h>
37 // @@protoc_insertion_point(includes)
38 #include <google/protobuf/port_def.inc>
39 #define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcompiler_2fxla_2fstream_5fexecutor_2fdnn_2eproto
40 PROTOBUF_NAMESPACE_OPEN
41 namespace internal {
42 class AnyMetadata;
43 } // namespace internal
44 PROTOBUF_NAMESPACE_CLOSE
45
46 // Internal implementation detail -- do not use these members.
47 struct TableStruct_tensorflow_2fcompiler_2fxla_2fstream_5fexecutor_2fdnn_2eproto {
48 static const ::uint32_t offsets[];
49 };
50 namespace stream_executor {
51 namespace dnn {
52 class AlgorithmConfigProto;
53 struct AlgorithmConfigProtoDefaultTypeInternal;
54 extern AlgorithmConfigProtoDefaultTypeInternal _AlgorithmConfigProto_default_instance_;
55 class AlgorithmProto;
56 struct AlgorithmProtoDefaultTypeInternal;
57 extern AlgorithmProtoDefaultTypeInternal _AlgorithmProto_default_instance_;
58 class AlgorithmProto_TuningKnobsEntry_DoNotUse;
59 struct AlgorithmProto_TuningKnobsEntry_DoNotUseDefaultTypeInternal;
60 extern AlgorithmProto_TuningKnobsEntry_DoNotUseDefaultTypeInternal _AlgorithmProto_TuningKnobsEntry_DoNotUse_default_instance_;
61 class ConvolutionDescriptorProto;
62 struct ConvolutionDescriptorProtoDefaultTypeInternal;
63 extern ConvolutionDescriptorProtoDefaultTypeInternal _ConvolutionDescriptorProto_default_instance_;
64 class TensorDescriptorProto;
65 struct TensorDescriptorProtoDefaultTypeInternal;
66 extern TensorDescriptorProtoDefaultTypeInternal _TensorDescriptorProto_default_instance_;
67 } // namespace dnn
68 } // namespace stream_executor
69 PROTOBUF_NAMESPACE_OPEN
70 template<> ::stream_executor::dnn::AlgorithmConfigProto* Arena::CreateMaybeMessage<::stream_executor::dnn::AlgorithmConfigProto>(Arena*);
71 template<> ::stream_executor::dnn::AlgorithmProto* Arena::CreateMaybeMessage<::stream_executor::dnn::AlgorithmProto>(Arena*);
72 template<> ::stream_executor::dnn::AlgorithmProto_TuningKnobsEntry_DoNotUse* Arena::CreateMaybeMessage<::stream_executor::dnn::AlgorithmProto_TuningKnobsEntry_DoNotUse>(Arena*);
73 template<> ::stream_executor::dnn::ConvolutionDescriptorProto* Arena::CreateMaybeMessage<::stream_executor::dnn::ConvolutionDescriptorProto>(Arena*);
74 template<> ::stream_executor::dnn::TensorDescriptorProto* Arena::CreateMaybeMessage<::stream_executor::dnn::TensorDescriptorProto>(Arena*);
75 PROTOBUF_NAMESPACE_CLOSE
76 namespace stream_executor {
77 namespace dnn {
78
79 enum AlgorithmProto_MathType : int {
80 AlgorithmProto_MathType_DEFAULT_MATH = 0,
81 AlgorithmProto_MathType_TENSOR_OP_MATH = 1,
82 AlgorithmProto_MathType_AlgorithmProto_MathType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::min(),
83 AlgorithmProto_MathType_AlgorithmProto_MathType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::max()
84 };
85 bool AlgorithmProto_MathType_IsValid(int value);
86 constexpr AlgorithmProto_MathType AlgorithmProto_MathType_MathType_MIN = AlgorithmProto_MathType_DEFAULT_MATH;
87 constexpr AlgorithmProto_MathType AlgorithmProto_MathType_MathType_MAX = AlgorithmProto_MathType_TENSOR_OP_MATH;
88 constexpr int AlgorithmProto_MathType_MathType_ARRAYSIZE = AlgorithmProto_MathType_MathType_MAX + 1;
89
90 const std::string& AlgorithmProto_MathType_Name(AlgorithmProto_MathType value);
91 template<typename T>
AlgorithmProto_MathType_Name(T enum_t_value)92 inline const std::string& AlgorithmProto_MathType_Name(T enum_t_value) {
93 static_assert(::std::is_same<T, AlgorithmProto_MathType>::value ||
94 ::std::is_integral<T>::value,
95 "Incorrect type passed to function AlgorithmProto_MathType_Name.");
96 return AlgorithmProto_MathType_Name(static_cast<AlgorithmProto_MathType>(enum_t_value));
97 }
98 bool AlgorithmProto_MathType_Parse(
99 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, AlgorithmProto_MathType* value);
100 enum DataType : int {
101 kFloat = 0,
102 kDouble = 1,
103 kHalf = 2,
104 kInt8 = 3,
105 kInt32 = 4,
106 kComplexFloat = 5,
107 kComplexDouble = 6,
108 kBF16 = 7,
109 DataType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::min(),
110 DataType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::max()
111 };
112 bool DataType_IsValid(int value);
113 constexpr DataType DataType_MIN = kFloat;
114 constexpr DataType DataType_MAX = kBF16;
115 constexpr int DataType_ARRAYSIZE = DataType_MAX + 1;
116
117 const std::string& DataType_Name(DataType value);
118 template<typename T>
DataType_Name(T enum_t_value)119 inline const std::string& DataType_Name(T enum_t_value) {
120 static_assert(::std::is_same<T, DataType>::value ||
121 ::std::is_integral<T>::value,
122 "Incorrect type passed to function DataType_Name.");
123 return DataType_Name(static_cast<DataType>(enum_t_value));
124 }
125 bool DataType_Parse(
126 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DataType* value);
127 enum DataLayout : int {
128 kYXDepthBatch = 0,
129 kYXBatchDepth = 1,
130 kBatchYXDepth = 2,
131 kBatchDepthYX = 3,
132 kBatchDepthYX4 = 4,
133 kBatchDepthYX32 = 5,
134 DataLayout_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::min(),
135 DataLayout_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::max()
136 };
137 bool DataLayout_IsValid(int value);
138 constexpr DataLayout DataLayout_MIN = kYXDepthBatch;
139 constexpr DataLayout DataLayout_MAX = kBatchDepthYX32;
140 constexpr int DataLayout_ARRAYSIZE = DataLayout_MAX + 1;
141
142 const std::string& DataLayout_Name(DataLayout value);
143 template<typename T>
DataLayout_Name(T enum_t_value)144 inline const std::string& DataLayout_Name(T enum_t_value) {
145 static_assert(::std::is_same<T, DataLayout>::value ||
146 ::std::is_integral<T>::value,
147 "Incorrect type passed to function DataLayout_Name.");
148 return DataLayout_Name(static_cast<DataLayout>(enum_t_value));
149 }
150 bool DataLayout_Parse(
151 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DataLayout* value);
152 enum FilterLayout : int {
153 kOutputInputYX = 0,
154 kOutputYXInput = 1,
155 kOutputInputYX4 = 2,
156 kOutputInputYX32 = 5,
157 kInputYXOutput = 3,
158 kYXInputOutput = 4,
159 FilterLayout_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::min(),
160 FilterLayout_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::max()
161 };
162 bool FilterLayout_IsValid(int value);
163 constexpr FilterLayout FilterLayout_MIN = kOutputInputYX;
164 constexpr FilterLayout FilterLayout_MAX = kOutputInputYX32;
165 constexpr int FilterLayout_ARRAYSIZE = FilterLayout_MAX + 1;
166
167 const std::string& FilterLayout_Name(FilterLayout value);
168 template<typename T>
FilterLayout_Name(T enum_t_value)169 inline const std::string& FilterLayout_Name(T enum_t_value) {
170 static_assert(::std::is_same<T, FilterLayout>::value ||
171 ::std::is_integral<T>::value,
172 "Incorrect type passed to function FilterLayout_Name.");
173 return FilterLayout_Name(static_cast<FilterLayout>(enum_t_value));
174 }
175 bool FilterLayout_Parse(
176 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FilterLayout* value);
177 enum ActivationMode : int {
178 kNone = 0,
179 kSigmoid = 1,
180 kRelu = 2,
181 kRelu6 = 3,
182 kReluX = 4,
183 kTanh = 5,
184 kBandPass = 6,
185 kElu = 7,
186 kLeakyRelu = 8,
187 ActivationMode_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::min(),
188 ActivationMode_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::max()
189 };
190 bool ActivationMode_IsValid(int value);
191 constexpr ActivationMode ActivationMode_MIN = kNone;
192 constexpr ActivationMode ActivationMode_MAX = kLeakyRelu;
193 constexpr int ActivationMode_ARRAYSIZE = ActivationMode_MAX + 1;
194
195 const std::string& ActivationMode_Name(ActivationMode value);
196 template<typename T>
ActivationMode_Name(T enum_t_value)197 inline const std::string& ActivationMode_Name(T enum_t_value) {
198 static_assert(::std::is_same<T, ActivationMode>::value ||
199 ::std::is_integral<T>::value,
200 "Incorrect type passed to function ActivationMode_Name.");
201 return ActivationMode_Name(static_cast<ActivationMode>(enum_t_value));
202 }
203 bool ActivationMode_Parse(
204 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ActivationMode* value);
205 enum ConvolutionMode : int {
206 CROSS_CORRELATION = 0,
207 CONVOLUTION = 1,
208 ConvolutionMode_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::min(),
209 ConvolutionMode_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::max()
210 };
211 bool ConvolutionMode_IsValid(int value);
212 constexpr ConvolutionMode ConvolutionMode_MIN = CROSS_CORRELATION;
213 constexpr ConvolutionMode ConvolutionMode_MAX = CONVOLUTION;
214 constexpr int ConvolutionMode_ARRAYSIZE = ConvolutionMode_MAX + 1;
215
216 const std::string& ConvolutionMode_Name(ConvolutionMode value);
217 template<typename T>
ConvolutionMode_Name(T enum_t_value)218 inline const std::string& ConvolutionMode_Name(T enum_t_value) {
219 static_assert(::std::is_same<T, ConvolutionMode>::value ||
220 ::std::is_integral<T>::value,
221 "Incorrect type passed to function ConvolutionMode_Name.");
222 return ConvolutionMode_Name(static_cast<ConvolutionMode>(enum_t_value));
223 }
224 bool ConvolutionMode_Parse(
225 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ConvolutionMode* value);
226 enum ConvolutionKind : int {
227 INVALID = 0,
228 FORWARD = 1,
229 BACKWARD_FILTER = 2,
230 BACKWARD_DATA = 3,
231 FORWARD_BIAS_ACTIVATION = 4,
232 ConvolutionKind_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::min(),
233 ConvolutionKind_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::max()
234 };
235 bool ConvolutionKind_IsValid(int value);
236 constexpr ConvolutionKind ConvolutionKind_MIN = INVALID;
237 constexpr ConvolutionKind ConvolutionKind_MAX = FORWARD_BIAS_ACTIVATION;
238 constexpr int ConvolutionKind_ARRAYSIZE = ConvolutionKind_MAX + 1;
239
240 const std::string& ConvolutionKind_Name(ConvolutionKind value);
241 template<typename T>
ConvolutionKind_Name(T enum_t_value)242 inline const std::string& ConvolutionKind_Name(T enum_t_value) {
243 static_assert(::std::is_same<T, ConvolutionKind>::value ||
244 ::std::is_integral<T>::value,
245 "Incorrect type passed to function ConvolutionKind_Name.");
246 return ConvolutionKind_Name(static_cast<ConvolutionKind>(enum_t_value));
247 }
248 bool ConvolutionKind_Parse(
249 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ConvolutionKind* value);
250 // ===================================================================
251
252 class TensorDescriptorProto final :
253 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:stream_executor.dnn.TensorDescriptorProto) */ {
254 public:
TensorDescriptorProto()255 inline TensorDescriptorProto() : TensorDescriptorProto(nullptr) {}
256 ~TensorDescriptorProto() override;
257 explicit PROTOBUF_CONSTEXPR TensorDescriptorProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
258
259 TensorDescriptorProto(const TensorDescriptorProto& from);
TensorDescriptorProto(TensorDescriptorProto && from)260 TensorDescriptorProto(TensorDescriptorProto&& from) noexcept
261 : TensorDescriptorProto() {
262 *this = ::std::move(from);
263 }
264
265 inline TensorDescriptorProto& operator=(const TensorDescriptorProto& from) {
266 if (this == &from) return *this;
267 CopyFrom(from);
268 return *this;
269 }
270 inline TensorDescriptorProto& operator=(TensorDescriptorProto&& from) noexcept {
271 if (this == &from) return *this;
272 if (GetOwningArena() == from.GetOwningArena()
273 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
274 && GetOwningArena() != nullptr
275 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
276 ) {
277 InternalSwap(&from);
278 } else {
279 CopyFrom(from);
280 }
281 return *this;
282 }
283
default_instance()284 static const TensorDescriptorProto& default_instance() {
285 return *internal_default_instance();
286 }
287 enum LayoutOneofCase {
288 kDataLayout = 3,
289 kFilterLayout = 4,
290 LAYOUT_ONEOF_NOT_SET = 0,
291 };
292
internal_default_instance()293 static inline const TensorDescriptorProto* internal_default_instance() {
294 return reinterpret_cast<const TensorDescriptorProto*>(
295 &_TensorDescriptorProto_default_instance_);
296 }
297 static constexpr int kIndexInFileMessages =
298 0;
299
swap(TensorDescriptorProto & a,TensorDescriptorProto & b)300 friend void swap(TensorDescriptorProto& a, TensorDescriptorProto& b) {
301 a.Swap(&b);
302 }
Swap(TensorDescriptorProto * other)303 inline void Swap(TensorDescriptorProto* other) {
304 if (other == this) return;
305 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
306 if (GetOwningArena() != nullptr &&
307 GetOwningArena() == other->GetOwningArena()) {
308 #else // PROTOBUF_FORCE_COPY_IN_SWAP
309 if (GetOwningArena() == other->GetOwningArena()) {
310 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
311 InternalSwap(other);
312 } else {
313 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
314 }
315 }
316 void UnsafeArenaSwap(TensorDescriptorProto* other) {
317 if (other == this) return;
318 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
319 InternalSwap(other);
320 }
321
322 // implements Message ----------------------------------------------
323
324 TensorDescriptorProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
325 return CreateMaybeMessage<TensorDescriptorProto>(arena);
326 }
327 TensorDescriptorProto* New() const {
328 return New(nullptr);
329 }
330 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
331 void CopyFrom(const TensorDescriptorProto& from);
332 void MergeFrom(const TensorDescriptorProto& from);
333 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
334 bool IsInitialized() const final;
335
336 size_t ByteSizeLong() const final;
337 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
338 ::uint8_t* _InternalSerialize(
339 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
340 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
341
342 private:
343 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
344 void SharedDtor();
345 void SetCachedSize(int size) const;
346 void InternalSwap(TensorDescriptorProto* other);
347
348 private:
349 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
350 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
351 return "stream_executor.dnn.TensorDescriptorProto";
352 }
353 protected:
354 explicit TensorDescriptorProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
355 bool is_message_owned = false);
356 public:
357
358 std::string GetTypeName() const final;
359
360 // nested types ----------------------------------------------------
361
362 // accessors -------------------------------------------------------
363
364 enum : int {
365 kDimensionsFieldNumber = 1,
366 kDataTypeFieldNumber = 2,
367 kDataLayoutFieldNumber = 3,
368 kFilterLayoutFieldNumber = 4,
369 };
370 // repeated int64 dimensions = 1;
371 int dimensions_size() const;
372 private:
373 int _internal_dimensions_size() const;
374 public:
375 void clear_dimensions();
376 private:
377 ::int64_t _internal_dimensions(int index) const;
378 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >&
379 _internal_dimensions() const;
380 void _internal_add_dimensions(::int64_t value);
381 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >*
382 _internal_mutable_dimensions();
383 public:
384 ::int64_t dimensions(int index) const;
385 void set_dimensions(int index, ::int64_t value);
386 void add_dimensions(::int64_t value);
387 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >&
388 dimensions() const;
389 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >*
390 mutable_dimensions();
391
392 // .stream_executor.dnn.DataType data_type = 2;
393 void clear_data_type();
394 ::stream_executor::dnn::DataType data_type() const;
395 void set_data_type(::stream_executor::dnn::DataType value);
396 private:
397 ::stream_executor::dnn::DataType _internal_data_type() const;
398 void _internal_set_data_type(::stream_executor::dnn::DataType value);
399 public:
400
401 // .stream_executor.dnn.DataLayout data_layout = 3;
402 bool has_data_layout() const;
403 private:
404 bool _internal_has_data_layout() const;
405 public:
406 void clear_data_layout();
407 ::stream_executor::dnn::DataLayout data_layout() const;
408 void set_data_layout(::stream_executor::dnn::DataLayout value);
409 private:
410 ::stream_executor::dnn::DataLayout _internal_data_layout() const;
411 void _internal_set_data_layout(::stream_executor::dnn::DataLayout value);
412 public:
413
414 // .stream_executor.dnn.FilterLayout filter_layout = 4;
415 bool has_filter_layout() const;
416 private:
417 bool _internal_has_filter_layout() const;
418 public:
419 void clear_filter_layout();
420 ::stream_executor::dnn::FilterLayout filter_layout() const;
421 void set_filter_layout(::stream_executor::dnn::FilterLayout value);
422 private:
423 ::stream_executor::dnn::FilterLayout _internal_filter_layout() const;
424 void _internal_set_filter_layout(::stream_executor::dnn::FilterLayout value);
425 public:
426
427 void clear_layout_oneof();
428 LayoutOneofCase layout_oneof_case() const;
429 // @@protoc_insertion_point(class_scope:stream_executor.dnn.TensorDescriptorProto)
430 private:
431 class _Internal;
432 void set_has_data_layout();
433 void set_has_filter_layout();
434
435 inline bool has_layout_oneof() const;
436 inline void clear_has_layout_oneof();
437
438 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
439 typedef void InternalArenaConstructable_;
440 typedef void DestructorSkippable_;
441 struct Impl_ {
442 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t > dimensions_;
443 mutable std::atomic<int> _dimensions_cached_byte_size_;
444 int data_type_;
445 union LayoutOneofUnion {
446 constexpr LayoutOneofUnion() : _constinit_{} {}
447 ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
448 int data_layout_;
449 int filter_layout_;
450 } layout_oneof_;
451 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
452 ::uint32_t _oneof_case_[1];
453
454 };
455 union { Impl_ _impl_; };
456 friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fstream_5fexecutor_2fdnn_2eproto;
457 };
458 // -------------------------------------------------------------------
459
460 class AlgorithmProto_TuningKnobsEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntryLite<AlgorithmProto_TuningKnobsEntry_DoNotUse,
461 ::int64_t, ::int64_t,
462 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64,
463 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64> {
464 public:
465 typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntryLite<AlgorithmProto_TuningKnobsEntry_DoNotUse,
466 ::int64_t, ::int64_t,
467 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64,
468 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64> SuperType;
469 AlgorithmProto_TuningKnobsEntry_DoNotUse();
470 explicit PROTOBUF_CONSTEXPR AlgorithmProto_TuningKnobsEntry_DoNotUse(
471 ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
472 explicit AlgorithmProto_TuningKnobsEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
473 void MergeFrom(const AlgorithmProto_TuningKnobsEntry_DoNotUse& other);
internal_default_instance()474 static const AlgorithmProto_TuningKnobsEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const AlgorithmProto_TuningKnobsEntry_DoNotUse*>(&_AlgorithmProto_TuningKnobsEntry_DoNotUse_default_instance_); }
ValidateKey(void *)475 static bool ValidateKey(void*) { return true; }
ValidateValue(void *)476 static bool ValidateValue(void*) { return true; }
477 friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fstream_5fexecutor_2fdnn_2eproto;
478 };
479
480 // -------------------------------------------------------------------
481
482 class AlgorithmProto final :
483 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:stream_executor.dnn.AlgorithmProto) */ {
484 public:
AlgorithmProto()485 inline AlgorithmProto() : AlgorithmProto(nullptr) {}
486 ~AlgorithmProto() override;
487 explicit PROTOBUF_CONSTEXPR AlgorithmProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
488
489 AlgorithmProto(const AlgorithmProto& from);
AlgorithmProto(AlgorithmProto && from)490 AlgorithmProto(AlgorithmProto&& from) noexcept
491 : AlgorithmProto() {
492 *this = ::std::move(from);
493 }
494
495 inline AlgorithmProto& operator=(const AlgorithmProto& from) {
496 if (this == &from) return *this;
497 CopyFrom(from);
498 return *this;
499 }
500 inline AlgorithmProto& operator=(AlgorithmProto&& from) noexcept {
501 if (this == &from) return *this;
502 if (GetOwningArena() == from.GetOwningArena()
503 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
504 && GetOwningArena() != nullptr
505 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
506 ) {
507 InternalSwap(&from);
508 } else {
509 CopyFrom(from);
510 }
511 return *this;
512 }
513
default_instance()514 static const AlgorithmProto& default_instance() {
515 return *internal_default_instance();
516 }
internal_default_instance()517 static inline const AlgorithmProto* internal_default_instance() {
518 return reinterpret_cast<const AlgorithmProto*>(
519 &_AlgorithmProto_default_instance_);
520 }
521 static constexpr int kIndexInFileMessages =
522 2;
523
swap(AlgorithmProto & a,AlgorithmProto & b)524 friend void swap(AlgorithmProto& a, AlgorithmProto& b) {
525 a.Swap(&b);
526 }
Swap(AlgorithmProto * other)527 inline void Swap(AlgorithmProto* other) {
528 if (other == this) return;
529 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
530 if (GetOwningArena() != nullptr &&
531 GetOwningArena() == other->GetOwningArena()) {
532 #else // PROTOBUF_FORCE_COPY_IN_SWAP
533 if (GetOwningArena() == other->GetOwningArena()) {
534 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
535 InternalSwap(other);
536 } else {
537 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
538 }
539 }
540 void UnsafeArenaSwap(AlgorithmProto* other) {
541 if (other == this) return;
542 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
543 InternalSwap(other);
544 }
545
546 // implements Message ----------------------------------------------
547
548 AlgorithmProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
549 return CreateMaybeMessage<AlgorithmProto>(arena);
550 }
551 AlgorithmProto* New() const {
552 return New(nullptr);
553 }
554 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
555 void CopyFrom(const AlgorithmProto& from);
556 void MergeFrom(const AlgorithmProto& from);
557 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
558 bool IsInitialized() const final;
559
560 size_t ByteSizeLong() const final;
561 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
562 ::uint8_t* _InternalSerialize(
563 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
564 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
565
566 private:
567 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
568 void SharedDtor();
569 void SetCachedSize(int size) const;
570 void InternalSwap(AlgorithmProto* other);
571
572 private:
573 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
574 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
575 return "stream_executor.dnn.AlgorithmProto";
576 }
577 protected:
578 explicit AlgorithmProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
579 bool is_message_owned = false);
580 public:
581
582 std::string GetTypeName() const final;
583
584 // nested types ----------------------------------------------------
585
586
587 typedef AlgorithmProto_MathType MathType;
588 static constexpr MathType DEFAULT_MATH =
589 AlgorithmProto_MathType_DEFAULT_MATH;
590 static constexpr MathType TENSOR_OP_MATH =
591 AlgorithmProto_MathType_TENSOR_OP_MATH;
592 static inline bool MathType_IsValid(int value) {
593 return AlgorithmProto_MathType_IsValid(value);
594 }
595 static constexpr MathType MathType_MIN =
596 AlgorithmProto_MathType_MathType_MIN;
597 static constexpr MathType MathType_MAX =
598 AlgorithmProto_MathType_MathType_MAX;
599 static constexpr int MathType_ARRAYSIZE =
600 AlgorithmProto_MathType_MathType_ARRAYSIZE;
601 template<typename T>
602 static inline const std::string& MathType_Name(T enum_t_value) {
603 static_assert(::std::is_same<T, MathType>::value ||
604 ::std::is_integral<T>::value,
605 "Incorrect type passed to function MathType_Name.");
606 return AlgorithmProto_MathType_Name(enum_t_value);
607 }
608 static inline bool MathType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
609 MathType* value) {
610 return AlgorithmProto_MathType_Parse(name, value);
611 }
612
613 // accessors -------------------------------------------------------
614
615 enum : int {
616 kTuningKnobsFieldNumber = 4,
617 kWorkspaceSizeFieldNumber = 6,
618 kAlgoIdFieldNumber = 1,
619 kMathTypeFieldNumber = 2,
620 kIsCudnnFrontendFieldNumber = 5,
621 };
622 // map<int64, int64> tuning_knobs = 4;
623 int tuning_knobs_size() const;
624 private:
625 int _internal_tuning_knobs_size() const;
626 public:
627 void clear_tuning_knobs();
628 private:
629 const ::PROTOBUF_NAMESPACE_ID::Map< ::int64_t, ::int64_t >&
630 _internal_tuning_knobs() const;
631 ::PROTOBUF_NAMESPACE_ID::Map< ::int64_t, ::int64_t >*
632 _internal_mutable_tuning_knobs();
633 public:
634 const ::PROTOBUF_NAMESPACE_ID::Map< ::int64_t, ::int64_t >&
635 tuning_knobs() const;
636 ::PROTOBUF_NAMESPACE_ID::Map< ::int64_t, ::int64_t >*
637 mutable_tuning_knobs();
638
639 // .google.protobuf.UInt64Value workspace_size = 6;
640 bool has_workspace_size() const;
641 private:
642 bool _internal_has_workspace_size() const;
643 public:
644 void clear_workspace_size();
645 const ::PROTOBUF_NAMESPACE_ID::UInt64Value& workspace_size() const;
646 PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::UInt64Value* release_workspace_size();
647 ::PROTOBUF_NAMESPACE_ID::UInt64Value* mutable_workspace_size();
648 void set_allocated_workspace_size(::PROTOBUF_NAMESPACE_ID::UInt64Value* workspace_size);
649 private:
650 const ::PROTOBUF_NAMESPACE_ID::UInt64Value& _internal_workspace_size() const;
651 ::PROTOBUF_NAMESPACE_ID::UInt64Value* _internal_mutable_workspace_size();
652 public:
653 void unsafe_arena_set_allocated_workspace_size(
654 ::PROTOBUF_NAMESPACE_ID::UInt64Value* workspace_size);
655 ::PROTOBUF_NAMESPACE_ID::UInt64Value* unsafe_arena_release_workspace_size();
656
657 // int64 algo_id = 1;
658 void clear_algo_id();
659 ::int64_t algo_id() const;
660 void set_algo_id(::int64_t value);
661 private:
662 ::int64_t _internal_algo_id() const;
663 void _internal_set_algo_id(::int64_t value);
664 public:
665
666 // .stream_executor.dnn.AlgorithmProto.MathType math_type = 2;
667 void clear_math_type();
668 ::stream_executor::dnn::AlgorithmProto_MathType math_type() const;
669 void set_math_type(::stream_executor::dnn::AlgorithmProto_MathType value);
670 private:
671 ::stream_executor::dnn::AlgorithmProto_MathType _internal_math_type() const;
672 void _internal_set_math_type(::stream_executor::dnn::AlgorithmProto_MathType value);
673 public:
674
675 // bool is_cudnn_frontend = 5;
676 void clear_is_cudnn_frontend();
677 bool is_cudnn_frontend() const;
678 void set_is_cudnn_frontend(bool value);
679 private:
680 bool _internal_is_cudnn_frontend() const;
681 void _internal_set_is_cudnn_frontend(bool value);
682 public:
683
684 // @@protoc_insertion_point(class_scope:stream_executor.dnn.AlgorithmProto)
685 private:
686 class _Internal;
687
688 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
689 typedef void InternalArenaConstructable_;
690 typedef void DestructorSkippable_;
691 struct Impl_ {
692 ::PROTOBUF_NAMESPACE_ID::internal::MapFieldLite<
693 AlgorithmProto_TuningKnobsEntry_DoNotUse,
694 ::int64_t, ::int64_t,
695 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64,
696 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64> tuning_knobs_;
697 ::PROTOBUF_NAMESPACE_ID::UInt64Value* workspace_size_;
698 ::int64_t algo_id_;
699 int math_type_;
700 bool is_cudnn_frontend_;
701 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
702 };
703 union { Impl_ _impl_; };
704 friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fstream_5fexecutor_2fdnn_2eproto;
705 };
706 // -------------------------------------------------------------------
707
708 class AlgorithmConfigProto final :
709 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:stream_executor.dnn.AlgorithmConfigProto) */ {
710 public:
AlgorithmConfigProto()711 inline AlgorithmConfigProto() : AlgorithmConfigProto(nullptr) {}
712 ~AlgorithmConfigProto() override;
713 explicit PROTOBUF_CONSTEXPR AlgorithmConfigProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
714
715 AlgorithmConfigProto(const AlgorithmConfigProto& from);
AlgorithmConfigProto(AlgorithmConfigProto && from)716 AlgorithmConfigProto(AlgorithmConfigProto&& from) noexcept
717 : AlgorithmConfigProto() {
718 *this = ::std::move(from);
719 }
720
721 inline AlgorithmConfigProto& operator=(const AlgorithmConfigProto& from) {
722 if (this == &from) return *this;
723 CopyFrom(from);
724 return *this;
725 }
726 inline AlgorithmConfigProto& operator=(AlgorithmConfigProto&& from) noexcept {
727 if (this == &from) return *this;
728 if (GetOwningArena() == from.GetOwningArena()
729 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
730 && GetOwningArena() != nullptr
731 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
732 ) {
733 InternalSwap(&from);
734 } else {
735 CopyFrom(from);
736 }
737 return *this;
738 }
739
default_instance()740 static const AlgorithmConfigProto& default_instance() {
741 return *internal_default_instance();
742 }
743 enum OptionalAlgorithmCase {
744 kAlgorithm = 1,
745 OPTIONAL_ALGORITHM_NOT_SET = 0,
746 };
747
748 enum OptionalAlgorithmNoScratchCase {
749 kAlgorithmNoScratch = 2,
750 OPTIONAL_ALGORITHM_NO_SCRATCH_NOT_SET = 0,
751 };
752
753 enum OptionalScratchSizeCase {
754 kScratchSize = 3,
755 OPTIONAL_SCRATCH_SIZE_NOT_SET = 0,
756 };
757
internal_default_instance()758 static inline const AlgorithmConfigProto* internal_default_instance() {
759 return reinterpret_cast<const AlgorithmConfigProto*>(
760 &_AlgorithmConfigProto_default_instance_);
761 }
762 static constexpr int kIndexInFileMessages =
763 3;
764
swap(AlgorithmConfigProto & a,AlgorithmConfigProto & b)765 friend void swap(AlgorithmConfigProto& a, AlgorithmConfigProto& b) {
766 a.Swap(&b);
767 }
Swap(AlgorithmConfigProto * other)768 inline void Swap(AlgorithmConfigProto* other) {
769 if (other == this) return;
770 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
771 if (GetOwningArena() != nullptr &&
772 GetOwningArena() == other->GetOwningArena()) {
773 #else // PROTOBUF_FORCE_COPY_IN_SWAP
774 if (GetOwningArena() == other->GetOwningArena()) {
775 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
776 InternalSwap(other);
777 } else {
778 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
779 }
780 }
781 void UnsafeArenaSwap(AlgorithmConfigProto* other) {
782 if (other == this) return;
783 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
784 InternalSwap(other);
785 }
786
787 // implements Message ----------------------------------------------
788
789 AlgorithmConfigProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
790 return CreateMaybeMessage<AlgorithmConfigProto>(arena);
791 }
792 AlgorithmConfigProto* New() const {
793 return New(nullptr);
794 }
795 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
796 void CopyFrom(const AlgorithmConfigProto& from);
797 void MergeFrom(const AlgorithmConfigProto& from);
798 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
799 bool IsInitialized() const final;
800
801 size_t ByteSizeLong() const final;
802 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
803 ::uint8_t* _InternalSerialize(
804 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
805 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
806
807 private:
808 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
809 void SharedDtor();
810 void SetCachedSize(int size) const;
811 void InternalSwap(AlgorithmConfigProto* other);
812
813 private:
814 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
815 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
816 return "stream_executor.dnn.AlgorithmConfigProto";
817 }
818 protected:
819 explicit AlgorithmConfigProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
820 bool is_message_owned = false);
821 public:
822
823 std::string GetTypeName() const final;
824
825 // nested types ----------------------------------------------------
826
827 // accessors -------------------------------------------------------
828
829 enum : int {
830 kAlgorithmFieldNumber = 1,
831 kAlgorithmNoScratchFieldNumber = 2,
832 kScratchSizeFieldNumber = 3,
833 };
834 // .stream_executor.dnn.AlgorithmProto algorithm = 1;
835 bool has_algorithm() const;
836 private:
837 bool _internal_has_algorithm() const;
838 public:
839 void clear_algorithm();
840 const ::stream_executor::dnn::AlgorithmProto& algorithm() const;
841 PROTOBUF_NODISCARD ::stream_executor::dnn::AlgorithmProto* release_algorithm();
842 ::stream_executor::dnn::AlgorithmProto* mutable_algorithm();
843 void set_allocated_algorithm(::stream_executor::dnn::AlgorithmProto* algorithm);
844 private:
845 const ::stream_executor::dnn::AlgorithmProto& _internal_algorithm() const;
846 ::stream_executor::dnn::AlgorithmProto* _internal_mutable_algorithm();
847 public:
848 void unsafe_arena_set_allocated_algorithm(
849 ::stream_executor::dnn::AlgorithmProto* algorithm);
850 ::stream_executor::dnn::AlgorithmProto* unsafe_arena_release_algorithm();
851
852 // .stream_executor.dnn.AlgorithmProto algorithm_no_scratch = 2;
853 bool has_algorithm_no_scratch() const;
854 private:
855 bool _internal_has_algorithm_no_scratch() const;
856 public:
857 void clear_algorithm_no_scratch();
858 const ::stream_executor::dnn::AlgorithmProto& algorithm_no_scratch() const;
859 PROTOBUF_NODISCARD ::stream_executor::dnn::AlgorithmProto* release_algorithm_no_scratch();
860 ::stream_executor::dnn::AlgorithmProto* mutable_algorithm_no_scratch();
861 void set_allocated_algorithm_no_scratch(::stream_executor::dnn::AlgorithmProto* algorithm_no_scratch);
862 private:
863 const ::stream_executor::dnn::AlgorithmProto& _internal_algorithm_no_scratch() const;
864 ::stream_executor::dnn::AlgorithmProto* _internal_mutable_algorithm_no_scratch();
865 public:
866 void unsafe_arena_set_allocated_algorithm_no_scratch(
867 ::stream_executor::dnn::AlgorithmProto* algorithm_no_scratch);
868 ::stream_executor::dnn::AlgorithmProto* unsafe_arena_release_algorithm_no_scratch();
869
870 // int64 scratch_size = 3;
871 bool has_scratch_size() const;
872 private:
873 bool _internal_has_scratch_size() const;
874 public:
875 void clear_scratch_size();
876 ::int64_t scratch_size() const;
877 void set_scratch_size(::int64_t value);
878 private:
879 ::int64_t _internal_scratch_size() const;
880 void _internal_set_scratch_size(::int64_t value);
881 public:
882
883 void clear_optional_algorithm();
884 OptionalAlgorithmCase optional_algorithm_case() const;
885 void clear_optional_algorithm_no_scratch();
886 OptionalAlgorithmNoScratchCase optional_algorithm_no_scratch_case() const;
887 void clear_optional_scratch_size();
888 OptionalScratchSizeCase optional_scratch_size_case() const;
889 // @@protoc_insertion_point(class_scope:stream_executor.dnn.AlgorithmConfigProto)
890 private:
891 class _Internal;
892 void set_has_algorithm();
893 void set_has_algorithm_no_scratch();
894 void set_has_scratch_size();
895
896 inline bool has_optional_algorithm() const;
897 inline void clear_has_optional_algorithm();
898
899 inline bool has_optional_algorithm_no_scratch() const;
900 inline void clear_has_optional_algorithm_no_scratch();
901
902 inline bool has_optional_scratch_size() const;
903 inline void clear_has_optional_scratch_size();
904
905 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
906 typedef void InternalArenaConstructable_;
907 typedef void DestructorSkippable_;
908 struct Impl_ {
909 union OptionalAlgorithmUnion {
910 constexpr OptionalAlgorithmUnion() : _constinit_{} {}
911 ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
912 ::stream_executor::dnn::AlgorithmProto* algorithm_;
913 } optional_algorithm_;
914 union OptionalAlgorithmNoScratchUnion {
915 constexpr OptionalAlgorithmNoScratchUnion() : _constinit_{} {}
916 ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
917 ::stream_executor::dnn::AlgorithmProto* algorithm_no_scratch_;
918 } optional_algorithm_no_scratch_;
919 union OptionalScratchSizeUnion {
920 constexpr OptionalScratchSizeUnion() : _constinit_{} {}
921 ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
922 ::int64_t scratch_size_;
923 } optional_scratch_size_;
924 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
925 ::uint32_t _oneof_case_[3];
926
927 };
928 union { Impl_ _impl_; };
929 friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fstream_5fexecutor_2fdnn_2eproto;
930 };
931 // -------------------------------------------------------------------
932
933 class ConvolutionDescriptorProto final :
934 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:stream_executor.dnn.ConvolutionDescriptorProto) */ {
935 public:
ConvolutionDescriptorProto()936 inline ConvolutionDescriptorProto() : ConvolutionDescriptorProto(nullptr) {}
937 ~ConvolutionDescriptorProto() override;
938 explicit PROTOBUF_CONSTEXPR ConvolutionDescriptorProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
939
940 ConvolutionDescriptorProto(const ConvolutionDescriptorProto& from);
ConvolutionDescriptorProto(ConvolutionDescriptorProto && from)941 ConvolutionDescriptorProto(ConvolutionDescriptorProto&& from) noexcept
942 : ConvolutionDescriptorProto() {
943 *this = ::std::move(from);
944 }
945
946 inline ConvolutionDescriptorProto& operator=(const ConvolutionDescriptorProto& from) {
947 if (this == &from) return *this;
948 CopyFrom(from);
949 return *this;
950 }
951 inline ConvolutionDescriptorProto& operator=(ConvolutionDescriptorProto&& from) noexcept {
952 if (this == &from) return *this;
953 if (GetOwningArena() == from.GetOwningArena()
954 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
955 && GetOwningArena() != nullptr
956 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
957 ) {
958 InternalSwap(&from);
959 } else {
960 CopyFrom(from);
961 }
962 return *this;
963 }
964
default_instance()965 static const ConvolutionDescriptorProto& default_instance() {
966 return *internal_default_instance();
967 }
internal_default_instance()968 static inline const ConvolutionDescriptorProto* internal_default_instance() {
969 return reinterpret_cast<const ConvolutionDescriptorProto*>(
970 &_ConvolutionDescriptorProto_default_instance_);
971 }
972 static constexpr int kIndexInFileMessages =
973 4;
974
swap(ConvolutionDescriptorProto & a,ConvolutionDescriptorProto & b)975 friend void swap(ConvolutionDescriptorProto& a, ConvolutionDescriptorProto& b) {
976 a.Swap(&b);
977 }
Swap(ConvolutionDescriptorProto * other)978 inline void Swap(ConvolutionDescriptorProto* other) {
979 if (other == this) return;
980 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
981 if (GetOwningArena() != nullptr &&
982 GetOwningArena() == other->GetOwningArena()) {
983 #else // PROTOBUF_FORCE_COPY_IN_SWAP
984 if (GetOwningArena() == other->GetOwningArena()) {
985 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
986 InternalSwap(other);
987 } else {
988 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
989 }
990 }
991 void UnsafeArenaSwap(ConvolutionDescriptorProto* other) {
992 if (other == this) return;
993 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
994 InternalSwap(other);
995 }
996
997 // implements Message ----------------------------------------------
998
999 ConvolutionDescriptorProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1000 return CreateMaybeMessage<ConvolutionDescriptorProto>(arena);
1001 }
1002 ConvolutionDescriptorProto* New() const {
1003 return New(nullptr);
1004 }
1005 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1006 void CopyFrom(const ConvolutionDescriptorProto& from);
1007 void MergeFrom(const ConvolutionDescriptorProto& from);
1008 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1009 bool IsInitialized() const final;
1010
1011 size_t ByteSizeLong() const final;
1012 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1013 ::uint8_t* _InternalSerialize(
1014 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1015 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1016
1017 private:
1018 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1019 void SharedDtor();
1020 void SetCachedSize(int size) const;
1021 void InternalSwap(ConvolutionDescriptorProto* other);
1022
1023 private:
1024 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1025 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1026 return "stream_executor.dnn.ConvolutionDescriptorProto";
1027 }
1028 protected:
1029 explicit ConvolutionDescriptorProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1030 bool is_message_owned = false);
1031 public:
1032
1033 std::string GetTypeName() const final;
1034
1035 // nested types ----------------------------------------------------
1036
1037 // accessors -------------------------------------------------------
1038
1039 enum : int {
1040 kPaddingsFieldNumber = 1,
1041 kStridesFieldNumber = 2,
1042 kDilationsFieldNumber = 3,
1043 kNameFieldNumber = 7,
1044 kComputeModeFieldNumber = 4,
1045 kGroupCountFieldNumber = 5,
1046 kConvolutionModeFieldNumber = 6,
1047 };
1048 // repeated int64 paddings = 1;
1049 int paddings_size() const;
1050 private:
1051 int _internal_paddings_size() const;
1052 public:
1053 void clear_paddings();
1054 private:
1055 ::int64_t _internal_paddings(int index) const;
1056 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >&
1057 _internal_paddings() const;
1058 void _internal_add_paddings(::int64_t value);
1059 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >*
1060 _internal_mutable_paddings();
1061 public:
1062 ::int64_t paddings(int index) const;
1063 void set_paddings(int index, ::int64_t value);
1064 void add_paddings(::int64_t value);
1065 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >&
1066 paddings() const;
1067 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >*
1068 mutable_paddings();
1069
1070 // repeated int64 strides = 2;
1071 int strides_size() const;
1072 private:
1073 int _internal_strides_size() const;
1074 public:
1075 void clear_strides();
1076 private:
1077 ::int64_t _internal_strides(int index) const;
1078 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >&
1079 _internal_strides() const;
1080 void _internal_add_strides(::int64_t value);
1081 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >*
1082 _internal_mutable_strides();
1083 public:
1084 ::int64_t strides(int index) const;
1085 void set_strides(int index, ::int64_t value);
1086 void add_strides(::int64_t value);
1087 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >&
1088 strides() const;
1089 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >*
1090 mutable_strides();
1091
1092 // repeated int64 dilations = 3;
1093 int dilations_size() const;
1094 private:
1095 int _internal_dilations_size() const;
1096 public:
1097 void clear_dilations();
1098 private:
1099 ::int64_t _internal_dilations(int index) const;
1100 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >&
1101 _internal_dilations() const;
1102 void _internal_add_dilations(::int64_t value);
1103 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >*
1104 _internal_mutable_dilations();
1105 public:
1106 ::int64_t dilations(int index) const;
1107 void set_dilations(int index, ::int64_t value);
1108 void add_dilations(::int64_t value);
1109 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >&
1110 dilations() const;
1111 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >*
1112 mutable_dilations();
1113
1114 // string name = 7;
1115 void clear_name();
1116 const std::string& name() const;
1117 template <typename ArgT0 = const std::string&, typename... ArgT>
1118 void set_name(ArgT0&& arg0, ArgT... args);
1119 std::string* mutable_name();
1120 PROTOBUF_NODISCARD std::string* release_name();
1121 void set_allocated_name(std::string* name);
1122 private:
1123 const std::string& _internal_name() const;
1124 inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
1125 std::string* _internal_mutable_name();
1126 public:
1127
1128 // .stream_executor.dnn.DataType compute_mode = 4;
1129 void clear_compute_mode();
1130 ::stream_executor::dnn::DataType compute_mode() const;
1131 void set_compute_mode(::stream_executor::dnn::DataType value);
1132 private:
1133 ::stream_executor::dnn::DataType _internal_compute_mode() const;
1134 void _internal_set_compute_mode(::stream_executor::dnn::DataType value);
1135 public:
1136
1137 // int32 group_count = 5;
1138 void clear_group_count();
1139 ::int32_t group_count() const;
1140 void set_group_count(::int32_t value);
1141 private:
1142 ::int32_t _internal_group_count() const;
1143 void _internal_set_group_count(::int32_t value);
1144 public:
1145
1146 // .stream_executor.dnn.ConvolutionMode convolution_mode = 6;
1147 void clear_convolution_mode();
1148 ::stream_executor::dnn::ConvolutionMode convolution_mode() const;
1149 void set_convolution_mode(::stream_executor::dnn::ConvolutionMode value);
1150 private:
1151 ::stream_executor::dnn::ConvolutionMode _internal_convolution_mode() const;
1152 void _internal_set_convolution_mode(::stream_executor::dnn::ConvolutionMode value);
1153 public:
1154
1155 // @@protoc_insertion_point(class_scope:stream_executor.dnn.ConvolutionDescriptorProto)
1156 private:
1157 class _Internal;
1158
1159 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1160 typedef void InternalArenaConstructable_;
1161 typedef void DestructorSkippable_;
1162 struct Impl_ {
1163 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t > paddings_;
1164 mutable std::atomic<int> _paddings_cached_byte_size_;
1165 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t > strides_;
1166 mutable std::atomic<int> _strides_cached_byte_size_;
1167 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t > dilations_;
1168 mutable std::atomic<int> _dilations_cached_byte_size_;
1169 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
1170 int compute_mode_;
1171 ::int32_t group_count_;
1172 int convolution_mode_;
1173 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1174 };
1175 union { Impl_ _impl_; };
1176 friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fstream_5fexecutor_2fdnn_2eproto;
1177 };
1178 // ===================================================================
1179
1180
1181 // ===================================================================
1182
1183 #ifdef __GNUC__
1184 #pragma GCC diagnostic push
1185 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
1186 #endif // __GNUC__
1187 // TensorDescriptorProto
1188
1189 // repeated int64 dimensions = 1;
_internal_dimensions_size()1190 inline int TensorDescriptorProto::_internal_dimensions_size() const {
1191 return _impl_.dimensions_.size();
1192 }
dimensions_size()1193 inline int TensorDescriptorProto::dimensions_size() const {
1194 return _internal_dimensions_size();
1195 }
clear_dimensions()1196 inline void TensorDescriptorProto::clear_dimensions() {
1197 _impl_.dimensions_.Clear();
1198 }
_internal_dimensions(int index)1199 inline ::int64_t TensorDescriptorProto::_internal_dimensions(int index) const {
1200 return _impl_.dimensions_.Get(index);
1201 }
dimensions(int index)1202 inline ::int64_t TensorDescriptorProto::dimensions(int index) const {
1203 // @@protoc_insertion_point(field_get:stream_executor.dnn.TensorDescriptorProto.dimensions)
1204 return _internal_dimensions(index);
1205 }
set_dimensions(int index,::int64_t value)1206 inline void TensorDescriptorProto::set_dimensions(int index, ::int64_t value) {
1207 _impl_.dimensions_.Set(index, value);
1208 // @@protoc_insertion_point(field_set:stream_executor.dnn.TensorDescriptorProto.dimensions)
1209 }
_internal_add_dimensions(::int64_t value)1210 inline void TensorDescriptorProto::_internal_add_dimensions(::int64_t value) {
1211 _impl_.dimensions_.Add(value);
1212 }
add_dimensions(::int64_t value)1213 inline void TensorDescriptorProto::add_dimensions(::int64_t value) {
1214 _internal_add_dimensions(value);
1215 // @@protoc_insertion_point(field_add:stream_executor.dnn.TensorDescriptorProto.dimensions)
1216 }
1217 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >&
_internal_dimensions()1218 TensorDescriptorProto::_internal_dimensions() const {
1219 return _impl_.dimensions_;
1220 }
1221 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >&
dimensions()1222 TensorDescriptorProto::dimensions() const {
1223 // @@protoc_insertion_point(field_list:stream_executor.dnn.TensorDescriptorProto.dimensions)
1224 return _internal_dimensions();
1225 }
1226 inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >*
_internal_mutable_dimensions()1227 TensorDescriptorProto::_internal_mutable_dimensions() {
1228 return &_impl_.dimensions_;
1229 }
1230 inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >*
mutable_dimensions()1231 TensorDescriptorProto::mutable_dimensions() {
1232 // @@protoc_insertion_point(field_mutable_list:stream_executor.dnn.TensorDescriptorProto.dimensions)
1233 return _internal_mutable_dimensions();
1234 }
1235
1236 // .stream_executor.dnn.DataType data_type = 2;
clear_data_type()1237 inline void TensorDescriptorProto::clear_data_type() {
1238 _impl_.data_type_ = 0;
1239 }
_internal_data_type()1240 inline ::stream_executor::dnn::DataType TensorDescriptorProto::_internal_data_type() const {
1241 return static_cast< ::stream_executor::dnn::DataType >(_impl_.data_type_);
1242 }
data_type()1243 inline ::stream_executor::dnn::DataType TensorDescriptorProto::data_type() const {
1244 // @@protoc_insertion_point(field_get:stream_executor.dnn.TensorDescriptorProto.data_type)
1245 return _internal_data_type();
1246 }
_internal_set_data_type(::stream_executor::dnn::DataType value)1247 inline void TensorDescriptorProto::_internal_set_data_type(::stream_executor::dnn::DataType value) {
1248
1249 _impl_.data_type_ = value;
1250 }
set_data_type(::stream_executor::dnn::DataType value)1251 inline void TensorDescriptorProto::set_data_type(::stream_executor::dnn::DataType value) {
1252 _internal_set_data_type(value);
1253 // @@protoc_insertion_point(field_set:stream_executor.dnn.TensorDescriptorProto.data_type)
1254 }
1255
1256 // .stream_executor.dnn.DataLayout data_layout = 3;
_internal_has_data_layout()1257 inline bool TensorDescriptorProto::_internal_has_data_layout() const {
1258 return layout_oneof_case() == kDataLayout;
1259 }
has_data_layout()1260 inline bool TensorDescriptorProto::has_data_layout() const {
1261 return _internal_has_data_layout();
1262 }
set_has_data_layout()1263 inline void TensorDescriptorProto::set_has_data_layout() {
1264 _impl_._oneof_case_[0] = kDataLayout;
1265 }
clear_data_layout()1266 inline void TensorDescriptorProto::clear_data_layout() {
1267 if (_internal_has_data_layout()) {
1268 _impl_.layout_oneof_.data_layout_ = 0;
1269 clear_has_layout_oneof();
1270 }
1271 }
_internal_data_layout()1272 inline ::stream_executor::dnn::DataLayout TensorDescriptorProto::_internal_data_layout() const {
1273 if (_internal_has_data_layout()) {
1274 return static_cast< ::stream_executor::dnn::DataLayout >(_impl_.layout_oneof_.data_layout_);
1275 }
1276 return static_cast< ::stream_executor::dnn::DataLayout >(0);
1277 }
data_layout()1278 inline ::stream_executor::dnn::DataLayout TensorDescriptorProto::data_layout() const {
1279 // @@protoc_insertion_point(field_get:stream_executor.dnn.TensorDescriptorProto.data_layout)
1280 return _internal_data_layout();
1281 }
_internal_set_data_layout(::stream_executor::dnn::DataLayout value)1282 inline void TensorDescriptorProto::_internal_set_data_layout(::stream_executor::dnn::DataLayout value) {
1283 if (!_internal_has_data_layout()) {
1284 clear_layout_oneof();
1285 set_has_data_layout();
1286 }
1287 _impl_.layout_oneof_.data_layout_ = value;
1288 }
set_data_layout(::stream_executor::dnn::DataLayout value)1289 inline void TensorDescriptorProto::set_data_layout(::stream_executor::dnn::DataLayout value) {
1290 _internal_set_data_layout(value);
1291 // @@protoc_insertion_point(field_set:stream_executor.dnn.TensorDescriptorProto.data_layout)
1292 }
1293
1294 // .stream_executor.dnn.FilterLayout filter_layout = 4;
_internal_has_filter_layout()1295 inline bool TensorDescriptorProto::_internal_has_filter_layout() const {
1296 return layout_oneof_case() == kFilterLayout;
1297 }
has_filter_layout()1298 inline bool TensorDescriptorProto::has_filter_layout() const {
1299 return _internal_has_filter_layout();
1300 }
set_has_filter_layout()1301 inline void TensorDescriptorProto::set_has_filter_layout() {
1302 _impl_._oneof_case_[0] = kFilterLayout;
1303 }
clear_filter_layout()1304 inline void TensorDescriptorProto::clear_filter_layout() {
1305 if (_internal_has_filter_layout()) {
1306 _impl_.layout_oneof_.filter_layout_ = 0;
1307 clear_has_layout_oneof();
1308 }
1309 }
_internal_filter_layout()1310 inline ::stream_executor::dnn::FilterLayout TensorDescriptorProto::_internal_filter_layout() const {
1311 if (_internal_has_filter_layout()) {
1312 return static_cast< ::stream_executor::dnn::FilterLayout >(_impl_.layout_oneof_.filter_layout_);
1313 }
1314 return static_cast< ::stream_executor::dnn::FilterLayout >(0);
1315 }
filter_layout()1316 inline ::stream_executor::dnn::FilterLayout TensorDescriptorProto::filter_layout() const {
1317 // @@protoc_insertion_point(field_get:stream_executor.dnn.TensorDescriptorProto.filter_layout)
1318 return _internal_filter_layout();
1319 }
_internal_set_filter_layout(::stream_executor::dnn::FilterLayout value)1320 inline void TensorDescriptorProto::_internal_set_filter_layout(::stream_executor::dnn::FilterLayout value) {
1321 if (!_internal_has_filter_layout()) {
1322 clear_layout_oneof();
1323 set_has_filter_layout();
1324 }
1325 _impl_.layout_oneof_.filter_layout_ = value;
1326 }
set_filter_layout(::stream_executor::dnn::FilterLayout value)1327 inline void TensorDescriptorProto::set_filter_layout(::stream_executor::dnn::FilterLayout value) {
1328 _internal_set_filter_layout(value);
1329 // @@protoc_insertion_point(field_set:stream_executor.dnn.TensorDescriptorProto.filter_layout)
1330 }
1331
has_layout_oneof()1332 inline bool TensorDescriptorProto::has_layout_oneof() const {
1333 return layout_oneof_case() != LAYOUT_ONEOF_NOT_SET;
1334 }
clear_has_layout_oneof()1335 inline void TensorDescriptorProto::clear_has_layout_oneof() {
1336 _impl_._oneof_case_[0] = LAYOUT_ONEOF_NOT_SET;
1337 }
layout_oneof_case()1338 inline TensorDescriptorProto::LayoutOneofCase TensorDescriptorProto::layout_oneof_case() const {
1339 return TensorDescriptorProto::LayoutOneofCase(_impl_._oneof_case_[0]);
1340 }
1341 // -------------------------------------------------------------------
1342
1343 // -------------------------------------------------------------------
1344
1345 // AlgorithmProto
1346
1347 // int64 algo_id = 1;
clear_algo_id()1348 inline void AlgorithmProto::clear_algo_id() {
1349 _impl_.algo_id_ = ::int64_t{0};
1350 }
_internal_algo_id()1351 inline ::int64_t AlgorithmProto::_internal_algo_id() const {
1352 return _impl_.algo_id_;
1353 }
algo_id()1354 inline ::int64_t AlgorithmProto::algo_id() const {
1355 // @@protoc_insertion_point(field_get:stream_executor.dnn.AlgorithmProto.algo_id)
1356 return _internal_algo_id();
1357 }
_internal_set_algo_id(::int64_t value)1358 inline void AlgorithmProto::_internal_set_algo_id(::int64_t value) {
1359
1360 _impl_.algo_id_ = value;
1361 }
set_algo_id(::int64_t value)1362 inline void AlgorithmProto::set_algo_id(::int64_t value) {
1363 _internal_set_algo_id(value);
1364 // @@protoc_insertion_point(field_set:stream_executor.dnn.AlgorithmProto.algo_id)
1365 }
1366
1367 // .stream_executor.dnn.AlgorithmProto.MathType math_type = 2;
clear_math_type()1368 inline void AlgorithmProto::clear_math_type() {
1369 _impl_.math_type_ = 0;
1370 }
_internal_math_type()1371 inline ::stream_executor::dnn::AlgorithmProto_MathType AlgorithmProto::_internal_math_type() const {
1372 return static_cast< ::stream_executor::dnn::AlgorithmProto_MathType >(_impl_.math_type_);
1373 }
math_type()1374 inline ::stream_executor::dnn::AlgorithmProto_MathType AlgorithmProto::math_type() const {
1375 // @@protoc_insertion_point(field_get:stream_executor.dnn.AlgorithmProto.math_type)
1376 return _internal_math_type();
1377 }
_internal_set_math_type(::stream_executor::dnn::AlgorithmProto_MathType value)1378 inline void AlgorithmProto::_internal_set_math_type(::stream_executor::dnn::AlgorithmProto_MathType value) {
1379
1380 _impl_.math_type_ = value;
1381 }
set_math_type(::stream_executor::dnn::AlgorithmProto_MathType value)1382 inline void AlgorithmProto::set_math_type(::stream_executor::dnn::AlgorithmProto_MathType value) {
1383 _internal_set_math_type(value);
1384 // @@protoc_insertion_point(field_set:stream_executor.dnn.AlgorithmProto.math_type)
1385 }
1386
1387 // map<int64, int64> tuning_knobs = 4;
_internal_tuning_knobs_size()1388 inline int AlgorithmProto::_internal_tuning_knobs_size() const {
1389 return _impl_.tuning_knobs_.size();
1390 }
tuning_knobs_size()1391 inline int AlgorithmProto::tuning_knobs_size() const {
1392 return _internal_tuning_knobs_size();
1393 }
clear_tuning_knobs()1394 inline void AlgorithmProto::clear_tuning_knobs() {
1395 _impl_.tuning_knobs_.Clear();
1396 }
1397 inline const ::PROTOBUF_NAMESPACE_ID::Map< ::int64_t, ::int64_t >&
_internal_tuning_knobs()1398 AlgorithmProto::_internal_tuning_knobs() const {
1399 return _impl_.tuning_knobs_.GetMap();
1400 }
1401 inline const ::PROTOBUF_NAMESPACE_ID::Map< ::int64_t, ::int64_t >&
tuning_knobs()1402 AlgorithmProto::tuning_knobs() const {
1403 // @@protoc_insertion_point(field_map:stream_executor.dnn.AlgorithmProto.tuning_knobs)
1404 return _internal_tuning_knobs();
1405 }
1406 inline ::PROTOBUF_NAMESPACE_ID::Map< ::int64_t, ::int64_t >*
_internal_mutable_tuning_knobs()1407 AlgorithmProto::_internal_mutable_tuning_knobs() {
1408 return _impl_.tuning_knobs_.MutableMap();
1409 }
1410 inline ::PROTOBUF_NAMESPACE_ID::Map< ::int64_t, ::int64_t >*
mutable_tuning_knobs()1411 AlgorithmProto::mutable_tuning_knobs() {
1412 // @@protoc_insertion_point(field_mutable_map:stream_executor.dnn.AlgorithmProto.tuning_knobs)
1413 return _internal_mutable_tuning_knobs();
1414 }
1415
1416 // bool is_cudnn_frontend = 5;
clear_is_cudnn_frontend()1417 inline void AlgorithmProto::clear_is_cudnn_frontend() {
1418 _impl_.is_cudnn_frontend_ = false;
1419 }
_internal_is_cudnn_frontend()1420 inline bool AlgorithmProto::_internal_is_cudnn_frontend() const {
1421 return _impl_.is_cudnn_frontend_;
1422 }
is_cudnn_frontend()1423 inline bool AlgorithmProto::is_cudnn_frontend() const {
1424 // @@protoc_insertion_point(field_get:stream_executor.dnn.AlgorithmProto.is_cudnn_frontend)
1425 return _internal_is_cudnn_frontend();
1426 }
_internal_set_is_cudnn_frontend(bool value)1427 inline void AlgorithmProto::_internal_set_is_cudnn_frontend(bool value) {
1428
1429 _impl_.is_cudnn_frontend_ = value;
1430 }
set_is_cudnn_frontend(bool value)1431 inline void AlgorithmProto::set_is_cudnn_frontend(bool value) {
1432 _internal_set_is_cudnn_frontend(value);
1433 // @@protoc_insertion_point(field_set:stream_executor.dnn.AlgorithmProto.is_cudnn_frontend)
1434 }
1435
1436 // .google.protobuf.UInt64Value workspace_size = 6;
_internal_has_workspace_size()1437 inline bool AlgorithmProto::_internal_has_workspace_size() const {
1438 return this != internal_default_instance() && _impl_.workspace_size_ != nullptr;
1439 }
has_workspace_size()1440 inline bool AlgorithmProto::has_workspace_size() const {
1441 return _internal_has_workspace_size();
1442 }
_internal_workspace_size()1443 inline const ::PROTOBUF_NAMESPACE_ID::UInt64Value& AlgorithmProto::_internal_workspace_size() const {
1444 const ::PROTOBUF_NAMESPACE_ID::UInt64Value* p = _impl_.workspace_size_;
1445 return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::UInt64Value&>(
1446 ::PROTOBUF_NAMESPACE_ID::_UInt64Value_default_instance_);
1447 }
workspace_size()1448 inline const ::PROTOBUF_NAMESPACE_ID::UInt64Value& AlgorithmProto::workspace_size() const {
1449 // @@protoc_insertion_point(field_get:stream_executor.dnn.AlgorithmProto.workspace_size)
1450 return _internal_workspace_size();
1451 }
unsafe_arena_set_allocated_workspace_size(::PROTOBUF_NAMESPACE_ID::UInt64Value * workspace_size)1452 inline void AlgorithmProto::unsafe_arena_set_allocated_workspace_size(
1453 ::PROTOBUF_NAMESPACE_ID::UInt64Value* workspace_size) {
1454 if (GetArenaForAllocation() == nullptr) {
1455 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.workspace_size_);
1456 }
1457 _impl_.workspace_size_ = workspace_size;
1458 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:stream_executor.dnn.AlgorithmProto.workspace_size)
1459 }
release_workspace_size()1460 inline ::PROTOBUF_NAMESPACE_ID::UInt64Value* AlgorithmProto::release_workspace_size() {
1461
1462 ::PROTOBUF_NAMESPACE_ID::UInt64Value* temp = _impl_.workspace_size_;
1463 _impl_.workspace_size_ = nullptr;
1464 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
1465 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
1466 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1467 if (GetArenaForAllocation() == nullptr) { delete old; }
1468 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
1469 if (GetArenaForAllocation() != nullptr) {
1470 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1471 }
1472 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
1473 return temp;
1474 }
unsafe_arena_release_workspace_size()1475 inline ::PROTOBUF_NAMESPACE_ID::UInt64Value* AlgorithmProto::unsafe_arena_release_workspace_size() {
1476 // @@protoc_insertion_point(field_release:stream_executor.dnn.AlgorithmProto.workspace_size)
1477
1478 ::PROTOBUF_NAMESPACE_ID::UInt64Value* temp = _impl_.workspace_size_;
1479 _impl_.workspace_size_ = nullptr;
1480 return temp;
1481 }
_internal_mutable_workspace_size()1482 inline ::PROTOBUF_NAMESPACE_ID::UInt64Value* AlgorithmProto::_internal_mutable_workspace_size() {
1483
1484 if (_impl_.workspace_size_ == nullptr) {
1485 auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::UInt64Value>(GetArenaForAllocation());
1486 _impl_.workspace_size_ = p;
1487 }
1488 return _impl_.workspace_size_;
1489 }
mutable_workspace_size()1490 inline ::PROTOBUF_NAMESPACE_ID::UInt64Value* AlgorithmProto::mutable_workspace_size() {
1491 ::PROTOBUF_NAMESPACE_ID::UInt64Value* _msg = _internal_mutable_workspace_size();
1492 // @@protoc_insertion_point(field_mutable:stream_executor.dnn.AlgorithmProto.workspace_size)
1493 return _msg;
1494 }
set_allocated_workspace_size(::PROTOBUF_NAMESPACE_ID::UInt64Value * workspace_size)1495 inline void AlgorithmProto::set_allocated_workspace_size(::PROTOBUF_NAMESPACE_ID::UInt64Value* workspace_size) {
1496 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
1497 if (message_arena == nullptr) {
1498 delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.workspace_size_);
1499 }
1500 if (workspace_size) {
1501 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
1502 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
1503 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(workspace_size));
1504 if (message_arena != submessage_arena) {
1505 workspace_size = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
1506 message_arena, workspace_size, submessage_arena);
1507 }
1508
1509 } else {
1510
1511 }
1512 _impl_.workspace_size_ = workspace_size;
1513 // @@protoc_insertion_point(field_set_allocated:stream_executor.dnn.AlgorithmProto.workspace_size)
1514 }
1515
1516 // -------------------------------------------------------------------
1517
1518 // AlgorithmConfigProto
1519
1520 // .stream_executor.dnn.AlgorithmProto algorithm = 1;
_internal_has_algorithm()1521 inline bool AlgorithmConfigProto::_internal_has_algorithm() const {
1522 return optional_algorithm_case() == kAlgorithm;
1523 }
has_algorithm()1524 inline bool AlgorithmConfigProto::has_algorithm() const {
1525 return _internal_has_algorithm();
1526 }
set_has_algorithm()1527 inline void AlgorithmConfigProto::set_has_algorithm() {
1528 _impl_._oneof_case_[0] = kAlgorithm;
1529 }
clear_algorithm()1530 inline void AlgorithmConfigProto::clear_algorithm() {
1531 if (_internal_has_algorithm()) {
1532 if (GetArenaForAllocation() == nullptr) {
1533 delete _impl_.optional_algorithm_.algorithm_;
1534 }
1535 clear_has_optional_algorithm();
1536 }
1537 }
release_algorithm()1538 inline ::stream_executor::dnn::AlgorithmProto* AlgorithmConfigProto::release_algorithm() {
1539 // @@protoc_insertion_point(field_release:stream_executor.dnn.AlgorithmConfigProto.algorithm)
1540 if (_internal_has_algorithm()) {
1541 clear_has_optional_algorithm();
1542 ::stream_executor::dnn::AlgorithmProto* temp = _impl_.optional_algorithm_.algorithm_;
1543 if (GetArenaForAllocation() != nullptr) {
1544 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1545 }
1546 _impl_.optional_algorithm_.algorithm_ = nullptr;
1547 return temp;
1548 } else {
1549 return nullptr;
1550 }
1551 }
_internal_algorithm()1552 inline const ::stream_executor::dnn::AlgorithmProto& AlgorithmConfigProto::_internal_algorithm() const {
1553 return _internal_has_algorithm()
1554 ? *_impl_.optional_algorithm_.algorithm_
1555 : reinterpret_cast< ::stream_executor::dnn::AlgorithmProto&>(::stream_executor::dnn::_AlgorithmProto_default_instance_);
1556 }
algorithm()1557 inline const ::stream_executor::dnn::AlgorithmProto& AlgorithmConfigProto::algorithm() const {
1558 // @@protoc_insertion_point(field_get:stream_executor.dnn.AlgorithmConfigProto.algorithm)
1559 return _internal_algorithm();
1560 }
unsafe_arena_release_algorithm()1561 inline ::stream_executor::dnn::AlgorithmProto* AlgorithmConfigProto::unsafe_arena_release_algorithm() {
1562 // @@protoc_insertion_point(field_unsafe_arena_release:stream_executor.dnn.AlgorithmConfigProto.algorithm)
1563 if (_internal_has_algorithm()) {
1564 clear_has_optional_algorithm();
1565 ::stream_executor::dnn::AlgorithmProto* temp = _impl_.optional_algorithm_.algorithm_;
1566 _impl_.optional_algorithm_.algorithm_ = nullptr;
1567 return temp;
1568 } else {
1569 return nullptr;
1570 }
1571 }
unsafe_arena_set_allocated_algorithm(::stream_executor::dnn::AlgorithmProto * algorithm)1572 inline void AlgorithmConfigProto::unsafe_arena_set_allocated_algorithm(::stream_executor::dnn::AlgorithmProto* algorithm) {
1573 clear_optional_algorithm();
1574 if (algorithm) {
1575 set_has_algorithm();
1576 _impl_.optional_algorithm_.algorithm_ = algorithm;
1577 }
1578 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:stream_executor.dnn.AlgorithmConfigProto.algorithm)
1579 }
_internal_mutable_algorithm()1580 inline ::stream_executor::dnn::AlgorithmProto* AlgorithmConfigProto::_internal_mutable_algorithm() {
1581 if (!_internal_has_algorithm()) {
1582 clear_optional_algorithm();
1583 set_has_algorithm();
1584 _impl_.optional_algorithm_.algorithm_ = CreateMaybeMessage< ::stream_executor::dnn::AlgorithmProto >(GetArenaForAllocation());
1585 }
1586 return _impl_.optional_algorithm_.algorithm_;
1587 }
mutable_algorithm()1588 inline ::stream_executor::dnn::AlgorithmProto* AlgorithmConfigProto::mutable_algorithm() {
1589 ::stream_executor::dnn::AlgorithmProto* _msg = _internal_mutable_algorithm();
1590 // @@protoc_insertion_point(field_mutable:stream_executor.dnn.AlgorithmConfigProto.algorithm)
1591 return _msg;
1592 }
1593
1594 // .stream_executor.dnn.AlgorithmProto algorithm_no_scratch = 2;
_internal_has_algorithm_no_scratch()1595 inline bool AlgorithmConfigProto::_internal_has_algorithm_no_scratch() const {
1596 return optional_algorithm_no_scratch_case() == kAlgorithmNoScratch;
1597 }
has_algorithm_no_scratch()1598 inline bool AlgorithmConfigProto::has_algorithm_no_scratch() const {
1599 return _internal_has_algorithm_no_scratch();
1600 }
set_has_algorithm_no_scratch()1601 inline void AlgorithmConfigProto::set_has_algorithm_no_scratch() {
1602 _impl_._oneof_case_[1] = kAlgorithmNoScratch;
1603 }
clear_algorithm_no_scratch()1604 inline void AlgorithmConfigProto::clear_algorithm_no_scratch() {
1605 if (_internal_has_algorithm_no_scratch()) {
1606 if (GetArenaForAllocation() == nullptr) {
1607 delete _impl_.optional_algorithm_no_scratch_.algorithm_no_scratch_;
1608 }
1609 clear_has_optional_algorithm_no_scratch();
1610 }
1611 }
release_algorithm_no_scratch()1612 inline ::stream_executor::dnn::AlgorithmProto* AlgorithmConfigProto::release_algorithm_no_scratch() {
1613 // @@protoc_insertion_point(field_release:stream_executor.dnn.AlgorithmConfigProto.algorithm_no_scratch)
1614 if (_internal_has_algorithm_no_scratch()) {
1615 clear_has_optional_algorithm_no_scratch();
1616 ::stream_executor::dnn::AlgorithmProto* temp = _impl_.optional_algorithm_no_scratch_.algorithm_no_scratch_;
1617 if (GetArenaForAllocation() != nullptr) {
1618 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1619 }
1620 _impl_.optional_algorithm_no_scratch_.algorithm_no_scratch_ = nullptr;
1621 return temp;
1622 } else {
1623 return nullptr;
1624 }
1625 }
_internal_algorithm_no_scratch()1626 inline const ::stream_executor::dnn::AlgorithmProto& AlgorithmConfigProto::_internal_algorithm_no_scratch() const {
1627 return _internal_has_algorithm_no_scratch()
1628 ? *_impl_.optional_algorithm_no_scratch_.algorithm_no_scratch_
1629 : reinterpret_cast< ::stream_executor::dnn::AlgorithmProto&>(::stream_executor::dnn::_AlgorithmProto_default_instance_);
1630 }
algorithm_no_scratch()1631 inline const ::stream_executor::dnn::AlgorithmProto& AlgorithmConfigProto::algorithm_no_scratch() const {
1632 // @@protoc_insertion_point(field_get:stream_executor.dnn.AlgorithmConfigProto.algorithm_no_scratch)
1633 return _internal_algorithm_no_scratch();
1634 }
unsafe_arena_release_algorithm_no_scratch()1635 inline ::stream_executor::dnn::AlgorithmProto* AlgorithmConfigProto::unsafe_arena_release_algorithm_no_scratch() {
1636 // @@protoc_insertion_point(field_unsafe_arena_release:stream_executor.dnn.AlgorithmConfigProto.algorithm_no_scratch)
1637 if (_internal_has_algorithm_no_scratch()) {
1638 clear_has_optional_algorithm_no_scratch();
1639 ::stream_executor::dnn::AlgorithmProto* temp = _impl_.optional_algorithm_no_scratch_.algorithm_no_scratch_;
1640 _impl_.optional_algorithm_no_scratch_.algorithm_no_scratch_ = nullptr;
1641 return temp;
1642 } else {
1643 return nullptr;
1644 }
1645 }
unsafe_arena_set_allocated_algorithm_no_scratch(::stream_executor::dnn::AlgorithmProto * algorithm_no_scratch)1646 inline void AlgorithmConfigProto::unsafe_arena_set_allocated_algorithm_no_scratch(::stream_executor::dnn::AlgorithmProto* algorithm_no_scratch) {
1647 clear_optional_algorithm_no_scratch();
1648 if (algorithm_no_scratch) {
1649 set_has_algorithm_no_scratch();
1650 _impl_.optional_algorithm_no_scratch_.algorithm_no_scratch_ = algorithm_no_scratch;
1651 }
1652 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:stream_executor.dnn.AlgorithmConfigProto.algorithm_no_scratch)
1653 }
_internal_mutable_algorithm_no_scratch()1654 inline ::stream_executor::dnn::AlgorithmProto* AlgorithmConfigProto::_internal_mutable_algorithm_no_scratch() {
1655 if (!_internal_has_algorithm_no_scratch()) {
1656 clear_optional_algorithm_no_scratch();
1657 set_has_algorithm_no_scratch();
1658 _impl_.optional_algorithm_no_scratch_.algorithm_no_scratch_ = CreateMaybeMessage< ::stream_executor::dnn::AlgorithmProto >(GetArenaForAllocation());
1659 }
1660 return _impl_.optional_algorithm_no_scratch_.algorithm_no_scratch_;
1661 }
mutable_algorithm_no_scratch()1662 inline ::stream_executor::dnn::AlgorithmProto* AlgorithmConfigProto::mutable_algorithm_no_scratch() {
1663 ::stream_executor::dnn::AlgorithmProto* _msg = _internal_mutable_algorithm_no_scratch();
1664 // @@protoc_insertion_point(field_mutable:stream_executor.dnn.AlgorithmConfigProto.algorithm_no_scratch)
1665 return _msg;
1666 }
1667
1668 // int64 scratch_size = 3;
_internal_has_scratch_size()1669 inline bool AlgorithmConfigProto::_internal_has_scratch_size() const {
1670 return optional_scratch_size_case() == kScratchSize;
1671 }
has_scratch_size()1672 inline bool AlgorithmConfigProto::has_scratch_size() const {
1673 return _internal_has_scratch_size();
1674 }
set_has_scratch_size()1675 inline void AlgorithmConfigProto::set_has_scratch_size() {
1676 _impl_._oneof_case_[2] = kScratchSize;
1677 }
clear_scratch_size()1678 inline void AlgorithmConfigProto::clear_scratch_size() {
1679 if (_internal_has_scratch_size()) {
1680 _impl_.optional_scratch_size_.scratch_size_ = ::int64_t{0};
1681 clear_has_optional_scratch_size();
1682 }
1683 }
_internal_scratch_size()1684 inline ::int64_t AlgorithmConfigProto::_internal_scratch_size() const {
1685 if (_internal_has_scratch_size()) {
1686 return _impl_.optional_scratch_size_.scratch_size_;
1687 }
1688 return ::int64_t{0};
1689 }
_internal_set_scratch_size(::int64_t value)1690 inline void AlgorithmConfigProto::_internal_set_scratch_size(::int64_t value) {
1691 if (!_internal_has_scratch_size()) {
1692 clear_optional_scratch_size();
1693 set_has_scratch_size();
1694 }
1695 _impl_.optional_scratch_size_.scratch_size_ = value;
1696 }
scratch_size()1697 inline ::int64_t AlgorithmConfigProto::scratch_size() const {
1698 // @@protoc_insertion_point(field_get:stream_executor.dnn.AlgorithmConfigProto.scratch_size)
1699 return _internal_scratch_size();
1700 }
set_scratch_size(::int64_t value)1701 inline void AlgorithmConfigProto::set_scratch_size(::int64_t value) {
1702 _internal_set_scratch_size(value);
1703 // @@protoc_insertion_point(field_set:stream_executor.dnn.AlgorithmConfigProto.scratch_size)
1704 }
1705
has_optional_algorithm()1706 inline bool AlgorithmConfigProto::has_optional_algorithm() const {
1707 return optional_algorithm_case() != OPTIONAL_ALGORITHM_NOT_SET;
1708 }
clear_has_optional_algorithm()1709 inline void AlgorithmConfigProto::clear_has_optional_algorithm() {
1710 _impl_._oneof_case_[0] = OPTIONAL_ALGORITHM_NOT_SET;
1711 }
has_optional_algorithm_no_scratch()1712 inline bool AlgorithmConfigProto::has_optional_algorithm_no_scratch() const {
1713 return optional_algorithm_no_scratch_case() != OPTIONAL_ALGORITHM_NO_SCRATCH_NOT_SET;
1714 }
clear_has_optional_algorithm_no_scratch()1715 inline void AlgorithmConfigProto::clear_has_optional_algorithm_no_scratch() {
1716 _impl_._oneof_case_[1] = OPTIONAL_ALGORITHM_NO_SCRATCH_NOT_SET;
1717 }
has_optional_scratch_size()1718 inline bool AlgorithmConfigProto::has_optional_scratch_size() const {
1719 return optional_scratch_size_case() != OPTIONAL_SCRATCH_SIZE_NOT_SET;
1720 }
clear_has_optional_scratch_size()1721 inline void AlgorithmConfigProto::clear_has_optional_scratch_size() {
1722 _impl_._oneof_case_[2] = OPTIONAL_SCRATCH_SIZE_NOT_SET;
1723 }
optional_algorithm_case()1724 inline AlgorithmConfigProto::OptionalAlgorithmCase AlgorithmConfigProto::optional_algorithm_case() const {
1725 return AlgorithmConfigProto::OptionalAlgorithmCase(_impl_._oneof_case_[0]);
1726 }
optional_algorithm_no_scratch_case()1727 inline AlgorithmConfigProto::OptionalAlgorithmNoScratchCase AlgorithmConfigProto::optional_algorithm_no_scratch_case() const {
1728 return AlgorithmConfigProto::OptionalAlgorithmNoScratchCase(_impl_._oneof_case_[1]);
1729 }
optional_scratch_size_case()1730 inline AlgorithmConfigProto::OptionalScratchSizeCase AlgorithmConfigProto::optional_scratch_size_case() const {
1731 return AlgorithmConfigProto::OptionalScratchSizeCase(_impl_._oneof_case_[2]);
1732 }
1733 // -------------------------------------------------------------------
1734
1735 // ConvolutionDescriptorProto
1736
1737 // repeated int64 paddings = 1;
_internal_paddings_size()1738 inline int ConvolutionDescriptorProto::_internal_paddings_size() const {
1739 return _impl_.paddings_.size();
1740 }
paddings_size()1741 inline int ConvolutionDescriptorProto::paddings_size() const {
1742 return _internal_paddings_size();
1743 }
clear_paddings()1744 inline void ConvolutionDescriptorProto::clear_paddings() {
1745 _impl_.paddings_.Clear();
1746 }
_internal_paddings(int index)1747 inline ::int64_t ConvolutionDescriptorProto::_internal_paddings(int index) const {
1748 return _impl_.paddings_.Get(index);
1749 }
paddings(int index)1750 inline ::int64_t ConvolutionDescriptorProto::paddings(int index) const {
1751 // @@protoc_insertion_point(field_get:stream_executor.dnn.ConvolutionDescriptorProto.paddings)
1752 return _internal_paddings(index);
1753 }
set_paddings(int index,::int64_t value)1754 inline void ConvolutionDescriptorProto::set_paddings(int index, ::int64_t value) {
1755 _impl_.paddings_.Set(index, value);
1756 // @@protoc_insertion_point(field_set:stream_executor.dnn.ConvolutionDescriptorProto.paddings)
1757 }
_internal_add_paddings(::int64_t value)1758 inline void ConvolutionDescriptorProto::_internal_add_paddings(::int64_t value) {
1759 _impl_.paddings_.Add(value);
1760 }
add_paddings(::int64_t value)1761 inline void ConvolutionDescriptorProto::add_paddings(::int64_t value) {
1762 _internal_add_paddings(value);
1763 // @@protoc_insertion_point(field_add:stream_executor.dnn.ConvolutionDescriptorProto.paddings)
1764 }
1765 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >&
_internal_paddings()1766 ConvolutionDescriptorProto::_internal_paddings() const {
1767 return _impl_.paddings_;
1768 }
1769 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >&
paddings()1770 ConvolutionDescriptorProto::paddings() const {
1771 // @@protoc_insertion_point(field_list:stream_executor.dnn.ConvolutionDescriptorProto.paddings)
1772 return _internal_paddings();
1773 }
1774 inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >*
_internal_mutable_paddings()1775 ConvolutionDescriptorProto::_internal_mutable_paddings() {
1776 return &_impl_.paddings_;
1777 }
1778 inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >*
mutable_paddings()1779 ConvolutionDescriptorProto::mutable_paddings() {
1780 // @@protoc_insertion_point(field_mutable_list:stream_executor.dnn.ConvolutionDescriptorProto.paddings)
1781 return _internal_mutable_paddings();
1782 }
1783
1784 // repeated int64 strides = 2;
_internal_strides_size()1785 inline int ConvolutionDescriptorProto::_internal_strides_size() const {
1786 return _impl_.strides_.size();
1787 }
strides_size()1788 inline int ConvolutionDescriptorProto::strides_size() const {
1789 return _internal_strides_size();
1790 }
clear_strides()1791 inline void ConvolutionDescriptorProto::clear_strides() {
1792 _impl_.strides_.Clear();
1793 }
_internal_strides(int index)1794 inline ::int64_t ConvolutionDescriptorProto::_internal_strides(int index) const {
1795 return _impl_.strides_.Get(index);
1796 }
strides(int index)1797 inline ::int64_t ConvolutionDescriptorProto::strides(int index) const {
1798 // @@protoc_insertion_point(field_get:stream_executor.dnn.ConvolutionDescriptorProto.strides)
1799 return _internal_strides(index);
1800 }
set_strides(int index,::int64_t value)1801 inline void ConvolutionDescriptorProto::set_strides(int index, ::int64_t value) {
1802 _impl_.strides_.Set(index, value);
1803 // @@protoc_insertion_point(field_set:stream_executor.dnn.ConvolutionDescriptorProto.strides)
1804 }
_internal_add_strides(::int64_t value)1805 inline void ConvolutionDescriptorProto::_internal_add_strides(::int64_t value) {
1806 _impl_.strides_.Add(value);
1807 }
add_strides(::int64_t value)1808 inline void ConvolutionDescriptorProto::add_strides(::int64_t value) {
1809 _internal_add_strides(value);
1810 // @@protoc_insertion_point(field_add:stream_executor.dnn.ConvolutionDescriptorProto.strides)
1811 }
1812 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >&
_internal_strides()1813 ConvolutionDescriptorProto::_internal_strides() const {
1814 return _impl_.strides_;
1815 }
1816 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >&
strides()1817 ConvolutionDescriptorProto::strides() const {
1818 // @@protoc_insertion_point(field_list:stream_executor.dnn.ConvolutionDescriptorProto.strides)
1819 return _internal_strides();
1820 }
1821 inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >*
_internal_mutable_strides()1822 ConvolutionDescriptorProto::_internal_mutable_strides() {
1823 return &_impl_.strides_;
1824 }
1825 inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >*
mutable_strides()1826 ConvolutionDescriptorProto::mutable_strides() {
1827 // @@protoc_insertion_point(field_mutable_list:stream_executor.dnn.ConvolutionDescriptorProto.strides)
1828 return _internal_mutable_strides();
1829 }
1830
1831 // repeated int64 dilations = 3;
_internal_dilations_size()1832 inline int ConvolutionDescriptorProto::_internal_dilations_size() const {
1833 return _impl_.dilations_.size();
1834 }
dilations_size()1835 inline int ConvolutionDescriptorProto::dilations_size() const {
1836 return _internal_dilations_size();
1837 }
clear_dilations()1838 inline void ConvolutionDescriptorProto::clear_dilations() {
1839 _impl_.dilations_.Clear();
1840 }
_internal_dilations(int index)1841 inline ::int64_t ConvolutionDescriptorProto::_internal_dilations(int index) const {
1842 return _impl_.dilations_.Get(index);
1843 }
dilations(int index)1844 inline ::int64_t ConvolutionDescriptorProto::dilations(int index) const {
1845 // @@protoc_insertion_point(field_get:stream_executor.dnn.ConvolutionDescriptorProto.dilations)
1846 return _internal_dilations(index);
1847 }
set_dilations(int index,::int64_t value)1848 inline void ConvolutionDescriptorProto::set_dilations(int index, ::int64_t value) {
1849 _impl_.dilations_.Set(index, value);
1850 // @@protoc_insertion_point(field_set:stream_executor.dnn.ConvolutionDescriptorProto.dilations)
1851 }
_internal_add_dilations(::int64_t value)1852 inline void ConvolutionDescriptorProto::_internal_add_dilations(::int64_t value) {
1853 _impl_.dilations_.Add(value);
1854 }
add_dilations(::int64_t value)1855 inline void ConvolutionDescriptorProto::add_dilations(::int64_t value) {
1856 _internal_add_dilations(value);
1857 // @@protoc_insertion_point(field_add:stream_executor.dnn.ConvolutionDescriptorProto.dilations)
1858 }
1859 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >&
_internal_dilations()1860 ConvolutionDescriptorProto::_internal_dilations() const {
1861 return _impl_.dilations_;
1862 }
1863 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >&
dilations()1864 ConvolutionDescriptorProto::dilations() const {
1865 // @@protoc_insertion_point(field_list:stream_executor.dnn.ConvolutionDescriptorProto.dilations)
1866 return _internal_dilations();
1867 }
1868 inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >*
_internal_mutable_dilations()1869 ConvolutionDescriptorProto::_internal_mutable_dilations() {
1870 return &_impl_.dilations_;
1871 }
1872 inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >*
mutable_dilations()1873 ConvolutionDescriptorProto::mutable_dilations() {
1874 // @@protoc_insertion_point(field_mutable_list:stream_executor.dnn.ConvolutionDescriptorProto.dilations)
1875 return _internal_mutable_dilations();
1876 }
1877
1878 // .stream_executor.dnn.DataType compute_mode = 4;
clear_compute_mode()1879 inline void ConvolutionDescriptorProto::clear_compute_mode() {
1880 _impl_.compute_mode_ = 0;
1881 }
_internal_compute_mode()1882 inline ::stream_executor::dnn::DataType ConvolutionDescriptorProto::_internal_compute_mode() const {
1883 return static_cast< ::stream_executor::dnn::DataType >(_impl_.compute_mode_);
1884 }
compute_mode()1885 inline ::stream_executor::dnn::DataType ConvolutionDescriptorProto::compute_mode() const {
1886 // @@protoc_insertion_point(field_get:stream_executor.dnn.ConvolutionDescriptorProto.compute_mode)
1887 return _internal_compute_mode();
1888 }
_internal_set_compute_mode(::stream_executor::dnn::DataType value)1889 inline void ConvolutionDescriptorProto::_internal_set_compute_mode(::stream_executor::dnn::DataType value) {
1890
1891 _impl_.compute_mode_ = value;
1892 }
set_compute_mode(::stream_executor::dnn::DataType value)1893 inline void ConvolutionDescriptorProto::set_compute_mode(::stream_executor::dnn::DataType value) {
1894 _internal_set_compute_mode(value);
1895 // @@protoc_insertion_point(field_set:stream_executor.dnn.ConvolutionDescriptorProto.compute_mode)
1896 }
1897
1898 // int32 group_count = 5;
clear_group_count()1899 inline void ConvolutionDescriptorProto::clear_group_count() {
1900 _impl_.group_count_ = 0;
1901 }
_internal_group_count()1902 inline ::int32_t ConvolutionDescriptorProto::_internal_group_count() const {
1903 return _impl_.group_count_;
1904 }
group_count()1905 inline ::int32_t ConvolutionDescriptorProto::group_count() const {
1906 // @@protoc_insertion_point(field_get:stream_executor.dnn.ConvolutionDescriptorProto.group_count)
1907 return _internal_group_count();
1908 }
_internal_set_group_count(::int32_t value)1909 inline void ConvolutionDescriptorProto::_internal_set_group_count(::int32_t value) {
1910
1911 _impl_.group_count_ = value;
1912 }
set_group_count(::int32_t value)1913 inline void ConvolutionDescriptorProto::set_group_count(::int32_t value) {
1914 _internal_set_group_count(value);
1915 // @@protoc_insertion_point(field_set:stream_executor.dnn.ConvolutionDescriptorProto.group_count)
1916 }
1917
1918 // .stream_executor.dnn.ConvolutionMode convolution_mode = 6;
clear_convolution_mode()1919 inline void ConvolutionDescriptorProto::clear_convolution_mode() {
1920 _impl_.convolution_mode_ = 0;
1921 }
_internal_convolution_mode()1922 inline ::stream_executor::dnn::ConvolutionMode ConvolutionDescriptorProto::_internal_convolution_mode() const {
1923 return static_cast< ::stream_executor::dnn::ConvolutionMode >(_impl_.convolution_mode_);
1924 }
convolution_mode()1925 inline ::stream_executor::dnn::ConvolutionMode ConvolutionDescriptorProto::convolution_mode() const {
1926 // @@protoc_insertion_point(field_get:stream_executor.dnn.ConvolutionDescriptorProto.convolution_mode)
1927 return _internal_convolution_mode();
1928 }
_internal_set_convolution_mode(::stream_executor::dnn::ConvolutionMode value)1929 inline void ConvolutionDescriptorProto::_internal_set_convolution_mode(::stream_executor::dnn::ConvolutionMode value) {
1930
1931 _impl_.convolution_mode_ = value;
1932 }
set_convolution_mode(::stream_executor::dnn::ConvolutionMode value)1933 inline void ConvolutionDescriptorProto::set_convolution_mode(::stream_executor::dnn::ConvolutionMode value) {
1934 _internal_set_convolution_mode(value);
1935 // @@protoc_insertion_point(field_set:stream_executor.dnn.ConvolutionDescriptorProto.convolution_mode)
1936 }
1937
1938 // string name = 7;
clear_name()1939 inline void ConvolutionDescriptorProto::clear_name() {
1940 _impl_.name_.ClearToEmpty();
1941 }
name()1942 inline const std::string& ConvolutionDescriptorProto::name() const {
1943 // @@protoc_insertion_point(field_get:stream_executor.dnn.ConvolutionDescriptorProto.name)
1944 return _internal_name();
1945 }
1946 template <typename ArgT0, typename... ArgT>
1947 inline PROTOBUF_ALWAYS_INLINE
set_name(ArgT0 && arg0,ArgT...args)1948 void ConvolutionDescriptorProto::set_name(ArgT0&& arg0, ArgT... args) {
1949
1950 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1951 // @@protoc_insertion_point(field_set:stream_executor.dnn.ConvolutionDescriptorProto.name)
1952 }
mutable_name()1953 inline std::string* ConvolutionDescriptorProto::mutable_name() {
1954 std::string* _s = _internal_mutable_name();
1955 // @@protoc_insertion_point(field_mutable:stream_executor.dnn.ConvolutionDescriptorProto.name)
1956 return _s;
1957 }
_internal_name()1958 inline const std::string& ConvolutionDescriptorProto::_internal_name() const {
1959 return _impl_.name_.Get();
1960 }
_internal_set_name(const std::string & value)1961 inline void ConvolutionDescriptorProto::_internal_set_name(const std::string& value) {
1962
1963 _impl_.name_.Set(value, GetArenaForAllocation());
1964 }
_internal_mutable_name()1965 inline std::string* ConvolutionDescriptorProto::_internal_mutable_name() {
1966
1967 return _impl_.name_.Mutable(GetArenaForAllocation());
1968 }
release_name()1969 inline std::string* ConvolutionDescriptorProto::release_name() {
1970 // @@protoc_insertion_point(field_release:stream_executor.dnn.ConvolutionDescriptorProto.name)
1971 return _impl_.name_.Release();
1972 }
set_allocated_name(std::string * name)1973 inline void ConvolutionDescriptorProto::set_allocated_name(std::string* name) {
1974 _impl_.name_.SetAllocated(name, GetArenaForAllocation());
1975 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1976 if (_impl_.name_.IsDefault()) {
1977 _impl_.name_.Set("", GetArenaForAllocation());
1978 }
1979 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1980 // @@protoc_insertion_point(field_set_allocated:stream_executor.dnn.ConvolutionDescriptorProto.name)
1981 }
1982
1983 #ifdef __GNUC__
1984 #pragma GCC diagnostic pop
1985 #endif // __GNUC__
1986 // -------------------------------------------------------------------
1987
1988 // -------------------------------------------------------------------
1989
1990 // -------------------------------------------------------------------
1991
1992 // -------------------------------------------------------------------
1993
1994
1995 // @@protoc_insertion_point(namespace_scope)
1996
1997 } // namespace dnn
1998 } // namespace stream_executor
1999
2000 PROTOBUF_NAMESPACE_OPEN
2001
2002 template <> struct is_proto_enum< ::stream_executor::dnn::AlgorithmProto_MathType> : ::std::true_type {};
2003 template <> struct is_proto_enum< ::stream_executor::dnn::DataType> : ::std::true_type {};
2004 template <> struct is_proto_enum< ::stream_executor::dnn::DataLayout> : ::std::true_type {};
2005 template <> struct is_proto_enum< ::stream_executor::dnn::FilterLayout> : ::std::true_type {};
2006 template <> struct is_proto_enum< ::stream_executor::dnn::ActivationMode> : ::std::true_type {};
2007 template <> struct is_proto_enum< ::stream_executor::dnn::ConvolutionMode> : ::std::true_type {};
2008 template <> struct is_proto_enum< ::stream_executor::dnn::ConvolutionKind> : ::std::true_type {};
2009
2010 PROTOBUF_NAMESPACE_CLOSE
2011
2012 // @@protoc_insertion_point(global_scope)
2013
2014 #include <google/protobuf/port_undef.inc>
2015 #endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcompiler_2fxla_2fstream_5fexecutor_2fdnn_2eproto
2016