s464967/3RNN
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
main
3RNN/Lib/site-packages/tensorflow/include/xla/autotuning.pb.h
s464967 8af59a8246 1.0
2024-05-26 19:49:15 +02:00

3761 lines
139 KiB
C++
Raw Permalink Blame History

// Generated by the protocol buffer compiler. DO NOT EDIT!
// source: xla/autotuning.proto
#ifndef GOOGLE_PROTOBUF_INCLUDED_xla_2fautotuning_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_xla_2fautotuning_2eproto
#include <limits>
#include <string>
#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3021000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3021009 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif
#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h> // IWYU pragma: export
#include <google/protobuf/extension_set.h> // IWYU pragma: export
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
#include <google/protobuf/any.pb.h>
#include <google/protobuf/duration.pb.h>
#include "tsl/protobuf/dnn.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_xla_2fautotuning_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
} // namespace internal
PROTOBUF_NAMESPACE_CLOSE
// Internal implementation detail -- do not use these members.
struct TableStruct_xla_2fautotuning_2eproto {
static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_xla_2fautotuning_2eproto;
namespace xla {
class AutotuneResult;
struct AutotuneResultDefaultTypeInternal;
extern AutotuneResultDefaultTypeInternal _AutotuneResult_default_instance_;
class AutotuneResult_ConvKey;
struct AutotuneResult_ConvKeyDefaultTypeInternal;
extern AutotuneResult_ConvKeyDefaultTypeInternal _AutotuneResult_ConvKey_default_instance_;
class AutotuneResult_CudaConvPlanKey;
struct AutotuneResult_CudaConvPlanKeyDefaultTypeInternal;
extern AutotuneResult_CudaConvPlanKeyDefaultTypeInternal _AutotuneResult_CudaConvPlanKey_default_instance_;
class AutotuneResult_FailureResult;
struct AutotuneResult_FailureResultDefaultTypeInternal;
extern AutotuneResult_FailureResultDefaultTypeInternal _AutotuneResult_FailureResult_default_instance_;
class AutotuneResult_GemmKey;
struct AutotuneResult_GemmKeyDefaultTypeInternal;
extern AutotuneResult_GemmKeyDefaultTypeInternal _AutotuneResult_GemmKey_default_instance_;
class AutotuneResult_TritonGemmKey;
struct AutotuneResult_TritonGemmKeyDefaultTypeInternal;
extern AutotuneResult_TritonGemmKeyDefaultTypeInternal _AutotuneResult_TritonGemmKey_default_instance_;
class AutotuningLog;
struct AutotuningLogDefaultTypeInternal;
extern AutotuningLogDefaultTypeInternal _AutotuningLog_default_instance_;
class ComputeCapability;
struct ComputeCapabilityDefaultTypeInternal;
extern ComputeCapabilityDefaultTypeInternal _ComputeCapability_default_instance_;
class CudnnVersion;
struct CudnnVersionDefaultTypeInternal;
extern CudnnVersionDefaultTypeInternal _CudnnVersion_default_instance_;
} // namespace xla
PROTOBUF_NAMESPACE_OPEN
template<> ::xla::AutotuneResult* Arena::CreateMaybeMessage<::xla::AutotuneResult>(Arena*);
template<> ::xla::AutotuneResult_ConvKey* Arena::CreateMaybeMessage<::xla::AutotuneResult_ConvKey>(Arena*);
template<> ::xla::AutotuneResult_CudaConvPlanKey* Arena::CreateMaybeMessage<::xla::AutotuneResult_CudaConvPlanKey>(Arena*);
template<> ::xla::AutotuneResult_FailureResult* Arena::CreateMaybeMessage<::xla::AutotuneResult_FailureResult>(Arena*);
template<> ::xla::AutotuneResult_GemmKey* Arena::CreateMaybeMessage<::xla::AutotuneResult_GemmKey>(Arena*);
template<> ::xla::AutotuneResult_TritonGemmKey* Arena::CreateMaybeMessage<::xla::AutotuneResult_TritonGemmKey>(Arena*);
template<> ::xla::AutotuningLog* Arena::CreateMaybeMessage<::xla::AutotuningLog>(Arena*);
template<> ::xla::ComputeCapability* Arena::CreateMaybeMessage<::xla::ComputeCapability>(Arena*);
template<> ::xla::CudnnVersion* Arena::CreateMaybeMessage<::xla::CudnnVersion>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace xla {
enum AutotuneResult_FailureKind : int {
AutotuneResult_FailureKind_UNKNOWN = 0,
AutotuneResult_FailureKind_REDZONE_MODIFIED = 1,
AutotuneResult_FailureKind_WRONG_RESULT = 2,
AutotuneResult_FailureKind_DISQUALIFIED = 3,
AutotuneResult_FailureKind_AutotuneResult_FailureKind_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
AutotuneResult_FailureKind_AutotuneResult_FailureKind_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool AutotuneResult_FailureKind_IsValid(int value);
constexpr AutotuneResult_FailureKind AutotuneResult_FailureKind_FailureKind_MIN = AutotuneResult_FailureKind_UNKNOWN;
constexpr AutotuneResult_FailureKind AutotuneResult_FailureKind_FailureKind_MAX = AutotuneResult_FailureKind_DISQUALIFIED;
constexpr int AutotuneResult_FailureKind_FailureKind_ARRAYSIZE = AutotuneResult_FailureKind_FailureKind_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* AutotuneResult_FailureKind_descriptor();
template<typename T>
inline const std::string& AutotuneResult_FailureKind_Name(T enum_t_value) {
static_assert(::std::is_same<T, AutotuneResult_FailureKind>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function AutotuneResult_FailureKind_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
AutotuneResult_FailureKind_descriptor(), enum_t_value);
}
inline bool AutotuneResult_FailureKind_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, AutotuneResult_FailureKind* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<AutotuneResult_FailureKind>(
AutotuneResult_FailureKind_descriptor(), name, value);
}
// ===================================================================
class CudnnVersion final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.CudnnVersion) */ {
public:
inline CudnnVersion() : CudnnVersion(nullptr) {}
~CudnnVersion() override;
explicit PROTOBUF_CONSTEXPR CudnnVersion(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
CudnnVersion(const CudnnVersion& from);
CudnnVersion(CudnnVersion&& from) noexcept
: CudnnVersion() {
*this = ::std::move(from);
}
inline CudnnVersion& operator=(const CudnnVersion& from) {
CopyFrom(from);
return *this;
}
inline CudnnVersion& operator=(CudnnVersion&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const CudnnVersion& default_instance() {
return *internal_default_instance();
}
static inline const CudnnVersion* internal_default_instance() {
return reinterpret_cast<const CudnnVersion*>(
&_CudnnVersion_default_instance_);
}
static constexpr int kIndexInFileMessages =
0;
friend void swap(CudnnVersion& a, CudnnVersion& b) {
a.Swap(&b);
}
inline void Swap(CudnnVersion* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(CudnnVersion* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
CudnnVersion* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<CudnnVersion>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const CudnnVersion& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom( const CudnnVersion& from) {
CudnnVersion::MergeImpl(*this, from);
}
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
private:
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(CudnnVersion* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "xla.CudnnVersion";
}
protected:
explicit CudnnVersion(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kMajorFieldNumber = 1,
kMinorFieldNumber = 2,
kPatchFieldNumber = 3,
};
// int32 major = 1;
void clear_major();
int32_t major() const;
void set_major(int32_t value);
private:
int32_t _internal_major() const;
void _internal_set_major(int32_t value);
public:
// int32 minor = 2;
void clear_minor();
int32_t minor() const;
void set_minor(int32_t value);
private:
int32_t _internal_minor() const;
void _internal_set_minor(int32_t value);
public:
// int32 patch = 3;
void clear_patch();
int32_t patch() const;
void set_patch(int32_t value);
private:
int32_t _internal_patch() const;
void _internal_set_patch(int32_t value);
public:
// @@protoc_insertion_point(class_scope:xla.CudnnVersion)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
struct Impl_ {
int32_t major_;
int32_t minor_;
int32_t patch_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
};
union { Impl_ _impl_; };
friend struct ::TableStruct_xla_2fautotuning_2eproto;
};
// -------------------------------------------------------------------
class ComputeCapability final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.ComputeCapability) */ {
public:
inline ComputeCapability() : ComputeCapability(nullptr) {}
~ComputeCapability() override;
explicit PROTOBUF_CONSTEXPR ComputeCapability(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
ComputeCapability(const ComputeCapability& from);
ComputeCapability(ComputeCapability&& from) noexcept
: ComputeCapability() {
*this = ::std::move(from);
}
inline ComputeCapability& operator=(const ComputeCapability& from) {
CopyFrom(from);
return *this;
}
inline ComputeCapability& operator=(ComputeCapability&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const ComputeCapability& default_instance() {
return *internal_default_instance();
}
static inline const ComputeCapability* internal_default_instance() {
return reinterpret_cast<const ComputeCapability*>(
&_ComputeCapability_default_instance_);
}
static constexpr int kIndexInFileMessages =
1;
friend void swap(ComputeCapability& a, ComputeCapability& b) {
a.Swap(&b);
}
inline void Swap(ComputeCapability* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(ComputeCapability* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
ComputeCapability* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<ComputeCapability>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const ComputeCapability& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom( const ComputeCapability& from) {
ComputeCapability::MergeImpl(*this, from);
}
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
private:
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(ComputeCapability* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "xla.ComputeCapability";
}
protected:
explicit ComputeCapability(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kMajorFieldNumber = 1,
kMinorFieldNumber = 2,
};
// int32 major = 1;
void clear_major();
int32_t major() const;
void set_major(int32_t value);
private:
int32_t _internal_major() const;
void _internal_set_major(int32_t value);
public:
// int32 minor = 2;
void clear_minor();
int32_t minor() const;
void set_minor(int32_t value);
private:
int32_t _internal_minor() const;
void _internal_set_minor(int32_t value);
public:
// @@protoc_insertion_point(class_scope:xla.ComputeCapability)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
struct Impl_ {
int32_t major_;
int32_t minor_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
};
union { Impl_ _impl_; };
friend struct ::TableStruct_xla_2fautotuning_2eproto;
};
// -------------------------------------------------------------------
class AutotuneResult_FailureResult final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.AutotuneResult.FailureResult) */ {
public:
inline AutotuneResult_FailureResult() : AutotuneResult_FailureResult(nullptr) {}
~AutotuneResult_FailureResult() override;
explicit PROTOBUF_CONSTEXPR AutotuneResult_FailureResult(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
AutotuneResult_FailureResult(const AutotuneResult_FailureResult& from);
AutotuneResult_FailureResult(AutotuneResult_FailureResult&& from) noexcept
: AutotuneResult_FailureResult() {
*this = ::std::move(from);
}
inline AutotuneResult_FailureResult& operator=(const AutotuneResult_FailureResult& from) {
CopyFrom(from);
return *this;
}
inline AutotuneResult_FailureResult& operator=(AutotuneResult_FailureResult&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const AutotuneResult_FailureResult& default_instance() {
return *internal_default_instance();
}
enum KeyCase {
kReferenceConv = 11,
kReferenceGemm = 12,
kReferenceCudaConvPlan = 14,
kReferenceAlgorithm = 15,
KEY_NOT_SET = 0,
};
static inline const AutotuneResult_FailureResult* internal_default_instance() {
return reinterpret_cast<const AutotuneResult_FailureResult*>(
&_AutotuneResult_FailureResult_default_instance_);
}
static constexpr int kIndexInFileMessages =
2;
friend void swap(AutotuneResult_FailureResult& a, AutotuneResult_FailureResult& b) {
a.Swap(&b);
}
inline void Swap(AutotuneResult_FailureResult* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(AutotuneResult_FailureResult* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
AutotuneResult_FailureResult* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<AutotuneResult_FailureResult>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const AutotuneResult_FailureResult& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom( const AutotuneResult_FailureResult& from) {
AutotuneResult_FailureResult::MergeImpl(*this, from);
}
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
private:
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(AutotuneResult_FailureResult* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "xla.AutotuneResult.FailureResult";
}
protected:
explicit AutotuneResult_FailureResult(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kMsgFieldNumber = 2,
kBufferAddressFieldNumber = 13,
kKindFieldNumber = 1,
kReferenceConvFieldNumber = 11,
kReferenceGemmFieldNumber = 12,
kReferenceCudaConvPlanFieldNumber = 14,
kReferenceAlgorithmFieldNumber = 15,
};
// string msg = 2;
void clear_msg();
const std::string& msg() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_msg(ArgT0&& arg0, ArgT... args);
std::string* mutable_msg();
PROTOBUF_NODISCARD std::string* release_msg();
void set_allocated_msg(std::string* msg);
private:
const std::string& _internal_msg() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_msg(const std::string& value);
std::string* _internal_mutable_msg();
public:
// int64 buffer_address = 13;
void clear_buffer_address();
int64_t buffer_address() const;
void set_buffer_address(int64_t value);
private:
int64_t _internal_buffer_address() const;
void _internal_set_buffer_address(int64_t value);
public:
// .xla.AutotuneResult.FailureKind kind = 1;
void clear_kind();
::xla::AutotuneResult_FailureKind kind() const;
void set_kind(::xla::AutotuneResult_FailureKind value);
private:
::xla::AutotuneResult_FailureKind _internal_kind() const;
void _internal_set_kind(::xla::AutotuneResult_FailureKind value);
public:
// .xla.AutotuneResult.ConvKey reference_conv = 11;
bool has_reference_conv() const;
private:
bool _internal_has_reference_conv() const;
public:
void clear_reference_conv();
const ::xla::AutotuneResult_ConvKey& reference_conv() const;
PROTOBUF_NODISCARD ::xla::AutotuneResult_ConvKey* release_reference_conv();
::xla::AutotuneResult_ConvKey* mutable_reference_conv();
void set_allocated_reference_conv(::xla::AutotuneResult_ConvKey* reference_conv);
private:
const ::xla::AutotuneResult_ConvKey& _internal_reference_conv() const;
::xla::AutotuneResult_ConvKey* _internal_mutable_reference_conv();
public:
void unsafe_arena_set_allocated_reference_conv(
::xla::AutotuneResult_ConvKey* reference_conv);
::xla::AutotuneResult_ConvKey* unsafe_arena_release_reference_conv();
// .xla.AutotuneResult.GemmKey reference_gemm = 12;
bool has_reference_gemm() const;
private:
bool _internal_has_reference_gemm() const;
public:
void clear_reference_gemm();
const ::xla::AutotuneResult_GemmKey& reference_gemm() const;
PROTOBUF_NODISCARD ::xla::AutotuneResult_GemmKey* release_reference_gemm();
::xla::AutotuneResult_GemmKey* mutable_reference_gemm();
void set_allocated_reference_gemm(::xla::AutotuneResult_GemmKey* reference_gemm);
private:
const ::xla::AutotuneResult_GemmKey& _internal_reference_gemm() const;
::xla::AutotuneResult_GemmKey* _internal_mutable_reference_gemm();
public:
void unsafe_arena_set_allocated_reference_gemm(
::xla::AutotuneResult_GemmKey* reference_gemm);
::xla::AutotuneResult_GemmKey* unsafe_arena_release_reference_gemm();
// .xla.AutotuneResult.CudaConvPlanKey reference_cuda_conv_plan = 14;
bool has_reference_cuda_conv_plan() const;
private:
bool _internal_has_reference_cuda_conv_plan() const;
public:
void clear_reference_cuda_conv_plan();
const ::xla::AutotuneResult_CudaConvPlanKey& reference_cuda_conv_plan() const;
PROTOBUF_NODISCARD ::xla::AutotuneResult_CudaConvPlanKey* release_reference_cuda_conv_plan();
::xla::AutotuneResult_CudaConvPlanKey* mutable_reference_cuda_conv_plan();
void set_allocated_reference_cuda_conv_plan(::xla::AutotuneResult_CudaConvPlanKey* reference_cuda_conv_plan);
private:
const ::xla::AutotuneResult_CudaConvPlanKey& _internal_reference_cuda_conv_plan() const;
::xla::AutotuneResult_CudaConvPlanKey* _internal_mutable_reference_cuda_conv_plan();
public:
void unsafe_arena_set_allocated_reference_cuda_conv_plan(
::xla::AutotuneResult_CudaConvPlanKey* reference_cuda_conv_plan);
::xla::AutotuneResult_CudaConvPlanKey* unsafe_arena_release_reference_cuda_conv_plan();
// .stream_executor.dnn.AlgorithmProto reference_algorithm = 15;
bool has_reference_algorithm() const;
private:
bool _internal_has_reference_algorithm() const;
public:
void clear_reference_algorithm();
const ::stream_executor::dnn::AlgorithmProto& reference_algorithm() const;
PROTOBUF_NODISCARD ::stream_executor::dnn::AlgorithmProto* release_reference_algorithm();
::stream_executor::dnn::AlgorithmProto* mutable_reference_algorithm();
void set_allocated_reference_algorithm(::stream_executor::dnn::AlgorithmProto* reference_algorithm);
private:
const ::stream_executor::dnn::AlgorithmProto& _internal_reference_algorithm() const;
::stream_executor::dnn::AlgorithmProto* _internal_mutable_reference_algorithm();
public:
void unsafe_arena_set_allocated_reference_algorithm(
::stream_executor::dnn::AlgorithmProto* reference_algorithm);
::stream_executor::dnn::AlgorithmProto* unsafe_arena_release_reference_algorithm();
void clear_key();
KeyCase key_case() const;
// @@protoc_insertion_point(class_scope:xla.AutotuneResult.FailureResult)
private:
class _Internal;
void set_has_reference_conv();
void set_has_reference_gemm();
void set_has_reference_cuda_conv_plan();
void set_has_reference_algorithm();
inline bool has_key() const;
inline void clear_has_key();
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
struct Impl_ {
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr msg_;
int64_t buffer_address_;
int kind_;
union KeyUnion {
constexpr KeyUnion() : _constinit_{} {}
::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
::xla::AutotuneResult_ConvKey* reference_conv_;
::xla::AutotuneResult_GemmKey* reference_gemm_;
::xla::AutotuneResult_CudaConvPlanKey* reference_cuda_conv_plan_;
::stream_executor::dnn::AlgorithmProto* reference_algorithm_;
} key_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
uint32_t _oneof_case_[1];
};
union { Impl_ _impl_; };
friend struct ::TableStruct_xla_2fautotuning_2eproto;
};
// -------------------------------------------------------------------
class AutotuneResult_ConvKey final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.AutotuneResult.ConvKey) */ {
public:
inline AutotuneResult_ConvKey() : AutotuneResult_ConvKey(nullptr) {}
~AutotuneResult_ConvKey() override;
explicit PROTOBUF_CONSTEXPR AutotuneResult_ConvKey(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
AutotuneResult_ConvKey(const AutotuneResult_ConvKey& from);
AutotuneResult_ConvKey(AutotuneResult_ConvKey&& from) noexcept
: AutotuneResult_ConvKey() {
*this = ::std::move(from);
}
inline AutotuneResult_ConvKey& operator=(const AutotuneResult_ConvKey& from) {
CopyFrom(from);
return *this;
}
inline AutotuneResult_ConvKey& operator=(AutotuneResult_ConvKey&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const AutotuneResult_ConvKey& default_instance() {
return *internal_default_instance();
}
static inline const AutotuneResult_ConvKey* internal_default_instance() {
return reinterpret_cast<const AutotuneResult_ConvKey*>(
&_AutotuneResult_ConvKey_default_instance_);
}
static constexpr int kIndexInFileMessages =
3;
friend void swap(AutotuneResult_ConvKey& a, AutotuneResult_ConvKey& b) {
a.Swap(&b);
}
inline void Swap(AutotuneResult_ConvKey* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(AutotuneResult_ConvKey* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
AutotuneResult_ConvKey* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<AutotuneResult_ConvKey>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const AutotuneResult_ConvKey& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom( const AutotuneResult_ConvKey& from) {
AutotuneResult_ConvKey::MergeImpl(*this, from);
}
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
private:
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(AutotuneResult_ConvKey* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "xla.AutotuneResult.ConvKey";
}
protected:
explicit AutotuneResult_ConvKey(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kAlgorithmFieldNumber = 1,
kTensorOpsEnabledFieldNumber = 2,
};
// int64 algorithm = 1;
void clear_algorithm();
int64_t algorithm() const;
void set_algorithm(int64_t value);
private:
int64_t _internal_algorithm() const;
void _internal_set_algorithm(int64_t value);
public:
// bool tensor_ops_enabled = 2;
void clear_tensor_ops_enabled();
bool tensor_ops_enabled() const;
void set_tensor_ops_enabled(bool value);
private:
bool _internal_tensor_ops_enabled() const;
void _internal_set_tensor_ops_enabled(bool value);
public:
// @@protoc_insertion_point(class_scope:xla.AutotuneResult.ConvKey)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
struct Impl_ {
int64_t algorithm_;
bool tensor_ops_enabled_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
};
union { Impl_ _impl_; };
friend struct ::TableStruct_xla_2fautotuning_2eproto;
};
// -------------------------------------------------------------------
class AutotuneResult_GemmKey final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.AutotuneResult.GemmKey) */ {
public:
inline AutotuneResult_GemmKey() : AutotuneResult_GemmKey(nullptr) {}
~AutotuneResult_GemmKey() override;
explicit PROTOBUF_CONSTEXPR AutotuneResult_GemmKey(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
AutotuneResult_GemmKey(const AutotuneResult_GemmKey& from);
AutotuneResult_GemmKey(AutotuneResult_GemmKey&& from) noexcept
: AutotuneResult_GemmKey() {
*this = ::std::move(from);
}
inline AutotuneResult_GemmKey& operator=(const AutotuneResult_GemmKey& from) {
CopyFrom(from);
return *this;
}
inline AutotuneResult_GemmKey& operator=(AutotuneResult_GemmKey&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const AutotuneResult_GemmKey& default_instance() {
return *internal_default_instance();
}
static inline const AutotuneResult_GemmKey* internal_default_instance() {
return reinterpret_cast<const AutotuneResult_GemmKey*>(
&_AutotuneResult_GemmKey_default_instance_);
}
static constexpr int kIndexInFileMessages =
4;
friend void swap(AutotuneResult_GemmKey& a, AutotuneResult_GemmKey& b) {
a.Swap(&b);
}
inline void Swap(AutotuneResult_GemmKey* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(AutotuneResult_GemmKey* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
AutotuneResult_GemmKey* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<AutotuneResult_GemmKey>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const AutotuneResult_GemmKey& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom( const AutotuneResult_GemmKey& from) {
AutotuneResult_GemmKey::MergeImpl(*this, from);
}
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
private:
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(AutotuneResult_GemmKey* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "xla.AutotuneResult.GemmKey";
}
protected:
explicit AutotuneResult_GemmKey(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kAlgorithmFieldNumber = 1,
};
// int64 algorithm = 1;
void clear_algorithm();
int64_t algorithm() const;
void set_algorithm(int64_t value);
private:
int64_t _internal_algorithm() const;
void _internal_set_algorithm(int64_t value);
public:
// @@protoc_insertion_point(class_scope:xla.AutotuneResult.GemmKey)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
struct Impl_ {
int64_t algorithm_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
};
union { Impl_ _impl_; };
friend struct ::TableStruct_xla_2fautotuning_2eproto;
};
// -------------------------------------------------------------------
class AutotuneResult_CudaConvPlanKey final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.AutotuneResult.CudaConvPlanKey) */ {
public:
inline AutotuneResult_CudaConvPlanKey() : AutotuneResult_CudaConvPlanKey(nullptr) {}
~AutotuneResult_CudaConvPlanKey() override;
explicit PROTOBUF_CONSTEXPR AutotuneResult_CudaConvPlanKey(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
AutotuneResult_CudaConvPlanKey(const AutotuneResult_CudaConvPlanKey& from);
AutotuneResult_CudaConvPlanKey(AutotuneResult_CudaConvPlanKey&& from) noexcept
: AutotuneResult_CudaConvPlanKey() {
*this = ::std::move(from);
}
inline AutotuneResult_CudaConvPlanKey& operator=(const AutotuneResult_CudaConvPlanKey& from) {
CopyFrom(from);
return *this;
}
inline AutotuneResult_CudaConvPlanKey& operator=(AutotuneResult_CudaConvPlanKey&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const AutotuneResult_CudaConvPlanKey& default_instance() {
return *internal_default_instance();
}
static inline const AutotuneResult_CudaConvPlanKey* internal_default_instance() {
return reinterpret_cast<const AutotuneResult_CudaConvPlanKey*>(
&_AutotuneResult_CudaConvPlanKey_default_instance_);
}
static constexpr int kIndexInFileMessages =
5;
friend void swap(AutotuneResult_CudaConvPlanKey& a, AutotuneResult_CudaConvPlanKey& b) {
a.Swap(&b);
}
inline void Swap(AutotuneResult_CudaConvPlanKey* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(AutotuneResult_CudaConvPlanKey* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
AutotuneResult_CudaConvPlanKey* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<AutotuneResult_CudaConvPlanKey>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const AutotuneResult_CudaConvPlanKey& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom( const AutotuneResult_CudaConvPlanKey& from) {
AutotuneResult_CudaConvPlanKey::MergeImpl(*this, from);
}
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
private:
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(AutotuneResult_CudaConvPlanKey* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "xla.AutotuneResult.CudaConvPlanKey";
}
protected:
explicit AutotuneResult_CudaConvPlanKey(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kExecPlanIdFieldNumber = 1,
};
// string exec_plan_id = 1;
void clear_exec_plan_id();
const std::string& exec_plan_id() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_exec_plan_id(ArgT0&& arg0, ArgT... args);
std::string* mutable_exec_plan_id();
PROTOBUF_NODISCARD std::string* release_exec_plan_id();
void set_allocated_exec_plan_id(std::string* exec_plan_id);
private:
const std::string& _internal_exec_plan_id() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_exec_plan_id(const std::string& value);
std::string* _internal_mutable_exec_plan_id();
public:
// @@protoc_insertion_point(class_scope:xla.AutotuneResult.CudaConvPlanKey)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
struct Impl_ {
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr exec_plan_id_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
};
union { Impl_ _impl_; };
friend struct ::TableStruct_xla_2fautotuning_2eproto;
};
// -------------------------------------------------------------------
class AutotuneResult_TritonGemmKey final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.AutotuneResult.TritonGemmKey) */ {
public:
inline AutotuneResult_TritonGemmKey() : AutotuneResult_TritonGemmKey(nullptr) {}
~AutotuneResult_TritonGemmKey() override;
explicit PROTOBUF_CONSTEXPR AutotuneResult_TritonGemmKey(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
AutotuneResult_TritonGemmKey(const AutotuneResult_TritonGemmKey& from);
AutotuneResult_TritonGemmKey(AutotuneResult_TritonGemmKey&& from) noexcept
: AutotuneResult_TritonGemmKey() {
*this = ::std::move(from);
}
inline AutotuneResult_TritonGemmKey& operator=(const AutotuneResult_TritonGemmKey& from) {
CopyFrom(from);
return *this;
}
inline AutotuneResult_TritonGemmKey& operator=(AutotuneResult_TritonGemmKey&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const AutotuneResult_TritonGemmKey& default_instance() {
return *internal_default_instance();
}
static inline const AutotuneResult_TritonGemmKey* internal_default_instance() {
return reinterpret_cast<const AutotuneResult_TritonGemmKey*>(
&_AutotuneResult_TritonGemmKey_default_instance_);
}
static constexpr int kIndexInFileMessages =
6;
friend void swap(AutotuneResult_TritonGemmKey& a, AutotuneResult_TritonGemmKey& b) {
a.Swap(&b);
}
inline void Swap(AutotuneResult_TritonGemmKey* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(AutotuneResult_TritonGemmKey* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
AutotuneResult_TritonGemmKey* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<AutotuneResult_TritonGemmKey>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const AutotuneResult_TritonGemmKey& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom( const AutotuneResult_TritonGemmKey& from) {
AutotuneResult_TritonGemmKey::MergeImpl(*this, from);
}
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
private:
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(AutotuneResult_TritonGemmKey* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "xla.AutotuneResult.TritonGemmKey";
}
protected:
explicit AutotuneResult_TritonGemmKey(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kBlockMFieldNumber = 1,
kBlockNFieldNumber = 2,
kBlockKFieldNumber = 3,
kSplitKFieldNumber = 4,
kNumStagesFieldNumber = 5,
kNumWarpsFieldNumber = 6,
};
// int64 block_m = 1;
void clear_block_m();
int64_t block_m() const;
void set_block_m(int64_t value);
private:
int64_t _internal_block_m() const;
void _internal_set_block_m(int64_t value);
public:
// int64 block_n = 2;
void clear_block_n();
int64_t block_n() const;
void set_block_n(int64_t value);
private:
int64_t _internal_block_n() const;
void _internal_set_block_n(int64_t value);
public:
// int64 block_k = 3;
void clear_block_k();
int64_t block_k() const;
void set_block_k(int64_t value);
private:
int64_t _internal_block_k() const;
void _internal_set_block_k(int64_t value);
public:
// int64 split_k = 4;
void clear_split_k();
int64_t split_k() const;
void set_split_k(int64_t value);
private:
int64_t _internal_split_k() const;
void _internal_set_split_k(int64_t value);
public:
// int64 num_stages = 5;
void clear_num_stages();
int64_t num_stages() const;
void set_num_stages(int64_t value);
private:
int64_t _internal_num_stages() const;
void _internal_set_num_stages(int64_t value);
public:
// int64 num_warps = 6;
void clear_num_warps();
int64_t num_warps() const;
void set_num_warps(int64_t value);
private:
int64_t _internal_num_warps() const;
void _internal_set_num_warps(int64_t value);
public:
// @@protoc_insertion_point(class_scope:xla.AutotuneResult.TritonGemmKey)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
struct Impl_ {
int64_t block_m_;
int64_t block_n_;
int64_t block_k_;
int64_t split_k_;
int64_t num_stages_;
int64_t num_warps_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
};
union { Impl_ _impl_; };
friend struct ::TableStruct_xla_2fautotuning_2eproto;
};
// -------------------------------------------------------------------
class AutotuneResult final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.AutotuneResult) */ {
public:
inline AutotuneResult() : AutotuneResult(nullptr) {}
~AutotuneResult() override;
explicit PROTOBUF_CONSTEXPR AutotuneResult(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
AutotuneResult(const AutotuneResult& from);
AutotuneResult(AutotuneResult&& from) noexcept
: AutotuneResult() {
*this = ::std::move(from);
}
inline AutotuneResult& operator=(const AutotuneResult& from) {
CopyFrom(from);
return *this;
}
inline AutotuneResult& operator=(AutotuneResult&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const AutotuneResult& default_instance() {
return *internal_default_instance();
}
enum KeyCase {
kConv = 5,
kGemm = 6,
kTriton = 17,
kCudaConvPlan = 15,
kAlgorithm = 16,
KEY_NOT_SET = 0,
};
static inline const AutotuneResult* internal_default_instance() {
return reinterpret_cast<const AutotuneResult*>(
&_AutotuneResult_default_instance_);
}
static constexpr int kIndexInFileMessages =
7;
friend void swap(AutotuneResult& a, AutotuneResult& b) {
a.Swap(&b);
}
inline void Swap(AutotuneResult* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(AutotuneResult* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
AutotuneResult* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<AutotuneResult>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const AutotuneResult& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom( const AutotuneResult& from) {
AutotuneResult::MergeImpl(*this, from);
}
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
private:
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(AutotuneResult* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "xla.AutotuneResult";
}
protected:
explicit AutotuneResult(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
typedef AutotuneResult_FailureResult FailureResult;
typedef AutotuneResult_ConvKey ConvKey;
typedef AutotuneResult_GemmKey GemmKey;
typedef AutotuneResult_CudaConvPlanKey CudaConvPlanKey;
typedef AutotuneResult_TritonGemmKey TritonGemmKey;
typedef AutotuneResult_FailureKind FailureKind;
static constexpr FailureKind UNKNOWN =
AutotuneResult_FailureKind_UNKNOWN;
static constexpr FailureKind REDZONE_MODIFIED =
AutotuneResult_FailureKind_REDZONE_MODIFIED;
static constexpr FailureKind WRONG_RESULT =
AutotuneResult_FailureKind_WRONG_RESULT;
static constexpr FailureKind DISQUALIFIED =
AutotuneResult_FailureKind_DISQUALIFIED;
static inline bool FailureKind_IsValid(int value) {
return AutotuneResult_FailureKind_IsValid(value);
}
static constexpr FailureKind FailureKind_MIN =
AutotuneResult_FailureKind_FailureKind_MIN;
static constexpr FailureKind FailureKind_MAX =
AutotuneResult_FailureKind_FailureKind_MAX;
static constexpr int FailureKind_ARRAYSIZE =
AutotuneResult_FailureKind_FailureKind_ARRAYSIZE;
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
FailureKind_descriptor() {
return AutotuneResult_FailureKind_descriptor();
}
template<typename T>
static inline const std::string& FailureKind_Name(T enum_t_value) {
static_assert(::std::is_same<T, FailureKind>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function FailureKind_Name.");
return AutotuneResult_FailureKind_Name(enum_t_value);
}
static inline bool FailureKind_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
FailureKind* value) {
return AutotuneResult_FailureKind_Parse(name, value);
}
// accessors -------------------------------------------------------
enum : int {
kFailureFieldNumber = 7,
kRunTimeFieldNumber = 9,
kScratchBytesFieldNumber = 8,
kConvFieldNumber = 5,
kGemmFieldNumber = 6,
kTritonFieldNumber = 17,
kCudaConvPlanFieldNumber = 15,
kAlgorithmFieldNumber = 16,
};
// .xla.AutotuneResult.FailureResult failure = 7;
bool has_failure() const;
private:
bool _internal_has_failure() const;
public:
void clear_failure();
const ::xla::AutotuneResult_FailureResult& failure() const;
PROTOBUF_NODISCARD ::xla::AutotuneResult_FailureResult* release_failure();
::xla::AutotuneResult_FailureResult* mutable_failure();
void set_allocated_failure(::xla::AutotuneResult_FailureResult* failure);
private:
const ::xla::AutotuneResult_FailureResult& _internal_failure() const;
::xla::AutotuneResult_FailureResult* _internal_mutable_failure();
public:
void unsafe_arena_set_allocated_failure(
::xla::AutotuneResult_FailureResult* failure);
::xla::AutotuneResult_FailureResult* unsafe_arena_release_failure();
// .google.protobuf.Duration run_time = 9;
bool has_run_time() const;
private:
bool _internal_has_run_time() const;
public:
void clear_run_time();
const ::PROTOBUF_NAMESPACE_ID::Duration& run_time() const;
PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Duration* release_run_time();
::PROTOBUF_NAMESPACE_ID::Duration* mutable_run_time();
void set_allocated_run_time(::PROTOBUF_NAMESPACE_ID::Duration* run_time);
private:
const ::PROTOBUF_NAMESPACE_ID::Duration& _internal_run_time() const;
::PROTOBUF_NAMESPACE_ID::Duration* _internal_mutable_run_time();
public:
void unsafe_arena_set_allocated_run_time(
::PROTOBUF_NAMESPACE_ID::Duration* run_time);
::PROTOBUF_NAMESPACE_ID::Duration* unsafe_arena_release_run_time();
// int64 scratch_bytes = 8;
void clear_scratch_bytes();
int64_t scratch_bytes() const;
void set_scratch_bytes(int64_t value);
private:
int64_t _internal_scratch_bytes() const;
void _internal_set_scratch_bytes(int64_t value);
public:
// .xla.AutotuneResult.ConvKey conv = 5;
bool has_conv() const;
private:
bool _internal_has_conv() const;
public:
void clear_conv();
const ::xla::AutotuneResult_ConvKey& conv() const;
PROTOBUF_NODISCARD ::xla::AutotuneResult_ConvKey* release_conv();
::xla::AutotuneResult_ConvKey* mutable_conv();
void set_allocated_conv(::xla::AutotuneResult_ConvKey* conv);
private:
const ::xla::AutotuneResult_ConvKey& _internal_conv() const;
::xla::AutotuneResult_ConvKey* _internal_mutable_conv();
public:
void unsafe_arena_set_allocated_conv(
::xla::AutotuneResult_ConvKey* conv);
::xla::AutotuneResult_ConvKey* unsafe_arena_release_conv();
// .xla.AutotuneResult.GemmKey gemm = 6;
bool has_gemm() const;
private:
bool _internal_has_gemm() const;
public:
void clear_gemm();
const ::xla::AutotuneResult_GemmKey& gemm() const;
PROTOBUF_NODISCARD ::xla::AutotuneResult_GemmKey* release_gemm();
::xla::AutotuneResult_GemmKey* mutable_gemm();
void set_allocated_gemm(::xla::AutotuneResult_GemmKey* gemm);
private:
const ::xla::AutotuneResult_GemmKey& _internal_gemm() const;
::xla::AutotuneResult_GemmKey* _internal_mutable_gemm();
public:
void unsafe_arena_set_allocated_gemm(
::xla::AutotuneResult_GemmKey* gemm);
::xla::AutotuneResult_GemmKey* unsafe_arena_release_gemm();
// .xla.AutotuneResult.TritonGemmKey triton = 17;
bool has_triton() const;
private:
bool _internal_has_triton() const;
public:
void clear_triton();
const ::xla::AutotuneResult_TritonGemmKey& triton() const;
PROTOBUF_NODISCARD ::xla::AutotuneResult_TritonGemmKey* release_triton();
::xla::AutotuneResult_TritonGemmKey* mutable_triton();
void set_allocated_triton(::xla::AutotuneResult_TritonGemmKey* triton);
private:
const ::xla::AutotuneResult_TritonGemmKey& _internal_triton() const;
::xla::AutotuneResult_TritonGemmKey* _internal_mutable_triton();
public:
void unsafe_arena_set_allocated_triton(
::xla::AutotuneResult_TritonGemmKey* triton);
::xla::AutotuneResult_TritonGemmKey* unsafe_arena_release_triton();
// .xla.AutotuneResult.CudaConvPlanKey cuda_conv_plan = 15;
bool has_cuda_conv_plan() const;
private:
bool _internal_has_cuda_conv_plan() const;
public:
void clear_cuda_conv_plan();
const ::xla::AutotuneResult_CudaConvPlanKey& cuda_conv_plan() const;
PROTOBUF_NODISCARD ::xla::AutotuneResult_CudaConvPlanKey* release_cuda_conv_plan();
::xla::AutotuneResult_CudaConvPlanKey* mutable_cuda_conv_plan();
void set_allocated_cuda_conv_plan(::xla::AutotuneResult_CudaConvPlanKey* cuda_conv_plan);
private:
const ::xla::AutotuneResult_CudaConvPlanKey& _internal_cuda_conv_plan() const;
::xla::AutotuneResult_CudaConvPlanKey* _internal_mutable_cuda_conv_plan();
public:
void unsafe_arena_set_allocated_cuda_conv_plan(
::xla::AutotuneResult_CudaConvPlanKey* cuda_conv_plan);
::xla::AutotuneResult_CudaConvPlanKey* unsafe_arena_release_cuda_conv_plan();
// .stream_executor.dnn.AlgorithmProto algorithm = 16;
bool has_algorithm() const;
private:
bool _internal_has_algorithm() const;
public:
void clear_algorithm();
const ::stream_executor::dnn::AlgorithmProto& algorithm() const;
PROTOBUF_NODISCARD ::stream_executor::dnn::AlgorithmProto* release_algorithm();
::stream_executor::dnn::AlgorithmProto* mutable_algorithm();
void set_allocated_algorithm(::stream_executor::dnn::AlgorithmProto* algorithm);
private:
const ::stream_executor::dnn::AlgorithmProto& _internal_algorithm() const;
::stream_executor::dnn::AlgorithmProto* _internal_mutable_algorithm();
public:
void unsafe_arena_set_allocated_algorithm(
::stream_executor::dnn::AlgorithmProto* algorithm);
::stream_executor::dnn::AlgorithmProto* unsafe_arena_release_algorithm();
void clear_key();
KeyCase key_case() const;
// @@protoc_insertion_point(class_scope:xla.AutotuneResult)
private:
class _Internal;
void set_has_conv();
void set_has_gemm();
void set_has_triton();
void set_has_cuda_conv_plan();
void set_has_algorithm();
inline bool has_key() const;
inline void clear_has_key();
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
struct Impl_ {
::xla::AutotuneResult_FailureResult* failure_;
::PROTOBUF_NAMESPACE_ID::Duration* run_time_;
int64_t scratch_bytes_;
union KeyUnion {
constexpr KeyUnion() : _constinit_{} {}
::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
::xla::AutotuneResult_ConvKey* conv_;
::xla::AutotuneResult_GemmKey* gemm_;
::xla::AutotuneResult_TritonGemmKey* triton_;
::xla::AutotuneResult_CudaConvPlanKey* cuda_conv_plan_;
::stream_executor::dnn::AlgorithmProto* algorithm_;
} key_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
uint32_t _oneof_case_[1];
};
union { Impl_ _impl_; };
friend struct ::TableStruct_xla_2fautotuning_2eproto;
};
// -------------------------------------------------------------------
class AutotuningLog final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.AutotuningLog) */ {
public:
inline AutotuningLog() : AutotuningLog(nullptr) {}
~AutotuningLog() override;
explicit PROTOBUF_CONSTEXPR AutotuningLog(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
AutotuningLog(const AutotuningLog& from);
AutotuningLog(AutotuningLog&& from) noexcept
: AutotuningLog() {
*this = ::std::move(from);
}
inline AutotuningLog& operator=(const AutotuningLog& from) {
CopyFrom(from);
return *this;
}
inline AutotuningLog& operator=(AutotuningLog&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const AutotuningLog& default_instance() {
return *internal_default_instance();
}
static inline const AutotuningLog* internal_default_instance() {
return reinterpret_cast<const AutotuningLog*>(
&_AutotuningLog_default_instance_);
}
static constexpr int kIndexInFileMessages =
8;
friend void swap(AutotuningLog& a, AutotuningLog& b) {
a.Swap(&b);
}
inline void Swap(AutotuningLog* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(AutotuningLog* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
AutotuningLog* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<AutotuningLog>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const AutotuningLog& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom( const AutotuningLog& from) {
AutotuningLog::MergeImpl(*this, from);
}
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
private:
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(AutotuningLog* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "xla.AutotuningLog";
}
protected:
explicit AutotuningLog(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kResultsFieldNumber = 2,
kDevicePciBusIdFieldNumber = 5,
kBlasVersionFieldNumber = 6,
kInstrFieldNumber = 1,
kCudnnVersionFieldNumber = 3,
kComputeCapabilityFieldNumber = 4,
};
// repeated .xla.AutotuneResult results = 2;
int results_size() const;
private:
int _internal_results_size() const;
public:
void clear_results();
::xla::AutotuneResult* mutable_results(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::AutotuneResult >*
mutable_results();
private:
const ::xla::AutotuneResult& _internal_results(int index) const;
::xla::AutotuneResult* _internal_add_results();
public:
const ::xla::AutotuneResult& results(int index) const;
::xla::AutotuneResult* add_results();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::AutotuneResult >&
results() const;
// string device_pci_bus_id = 5;
void clear_device_pci_bus_id();
const std::string& device_pci_bus_id() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_device_pci_bus_id(ArgT0&& arg0, ArgT... args);
std::string* mutable_device_pci_bus_id();
PROTOBUF_NODISCARD std::string* release_device_pci_bus_id();
void set_allocated_device_pci_bus_id(std::string* device_pci_bus_id);
private:
const std::string& _internal_device_pci_bus_id() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_device_pci_bus_id(const std::string& value);
std::string* _internal_mutable_device_pci_bus_id();
public:
// string blas_version = 6;
void clear_blas_version();
const std::string& blas_version() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_blas_version(ArgT0&& arg0, ArgT... args);
std::string* mutable_blas_version();
PROTOBUF_NODISCARD std::string* release_blas_version();
void set_allocated_blas_version(std::string* blas_version);
private:
const std::string& _internal_blas_version() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_blas_version(const std::string& value);
std::string* _internal_mutable_blas_version();
public:
// .google.protobuf.Any instr = 1;
bool has_instr() const;
private:
bool _internal_has_instr() const;
public:
void clear_instr();
const ::PROTOBUF_NAMESPACE_ID::Any& instr() const;
PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Any* release_instr();
::PROTOBUF_NAMESPACE_ID::Any* mutable_instr();
void set_allocated_instr(::PROTOBUF_NAMESPACE_ID::Any* instr);
private:
const ::PROTOBUF_NAMESPACE_ID::Any& _internal_instr() const;
::PROTOBUF_NAMESPACE_ID::Any* _internal_mutable_instr();
public:
void unsafe_arena_set_allocated_instr(
::PROTOBUF_NAMESPACE_ID::Any* instr);
::PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_instr();
// .xla.CudnnVersion cudnn_version = 3;
bool has_cudnn_version() const;
private:
bool _internal_has_cudnn_version() const;
public:
void clear_cudnn_version();
const ::xla::CudnnVersion& cudnn_version() const;
PROTOBUF_NODISCARD ::xla::CudnnVersion* release_cudnn_version();
::xla::CudnnVersion* mutable_cudnn_version();
void set_allocated_cudnn_version(::xla::CudnnVersion* cudnn_version);
private:
const ::xla::CudnnVersion& _internal_cudnn_version() const;
::xla::CudnnVersion* _internal_mutable_cudnn_version();
public:
void unsafe_arena_set_allocated_cudnn_version(
::xla::CudnnVersion* cudnn_version);
::xla::CudnnVersion* unsafe_arena_release_cudnn_version();
// .xla.ComputeCapability compute_capability = 4;
bool has_compute_capability() const;
private:
bool _internal_has_compute_capability() const;
public:
void clear_compute_capability();
const ::xla::ComputeCapability& compute_capability() const;
PROTOBUF_NODISCARD ::xla::ComputeCapability* release_compute_capability();
::xla::ComputeCapability* mutable_compute_capability();
void set_allocated_compute_capability(::xla::ComputeCapability* compute_capability);
private:
const ::xla::ComputeCapability& _internal_compute_capability() const;
::xla::ComputeCapability* _internal_mutable_compute_capability();
public:
void unsafe_arena_set_allocated_compute_capability(
::xla::ComputeCapability* compute_capability);
::xla::ComputeCapability* unsafe_arena_release_compute_capability();
// @@protoc_insertion_point(class_scope:xla.AutotuningLog)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
struct Impl_ {
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::AutotuneResult > results_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_pci_bus_id_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr blas_version_;
::PROTOBUF_NAMESPACE_ID::Any* instr_;
::xla::CudnnVersion* cudnn_version_;
::xla::ComputeCapability* compute_capability_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
};
union { Impl_ _impl_; };
friend struct ::TableStruct_xla_2fautotuning_2eproto;
};
// ===================================================================
// ===================================================================
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif // __GNUC__
// CudnnVersion
// int32 major = 1;
inline void CudnnVersion::clear_major() {
_impl_.major_ = 0;
}
inline int32_t CudnnVersion::_internal_major() const {
return _impl_.major_;
}
inline int32_t CudnnVersion::major() const {
// @@protoc_insertion_point(field_get:xla.CudnnVersion.major)
return _internal_major();
}
inline void CudnnVersion::_internal_set_major(int32_t value) {
_impl_.major_ = value;
}
inline void CudnnVersion::set_major(int32_t value) {
_internal_set_major(value);
// @@protoc_insertion_point(field_set:xla.CudnnVersion.major)
}
// int32 minor = 2;
inline void CudnnVersion::clear_minor() {
_impl_.minor_ = 0;
}
inline int32_t CudnnVersion::_internal_minor() const {
return _impl_.minor_;
}
inline int32_t CudnnVersion::minor() const {
// @@protoc_insertion_point(field_get:xla.CudnnVersion.minor)
return _internal_minor();
}
inline void CudnnVersion::_internal_set_minor(int32_t value) {
_impl_.minor_ = value;
}
inline void CudnnVersion::set_minor(int32_t value) {
_internal_set_minor(value);
// @@protoc_insertion_point(field_set:xla.CudnnVersion.minor)
}
// int32 patch = 3;
inline void CudnnVersion::clear_patch() {
_impl_.patch_ = 0;
}
inline int32_t CudnnVersion::_internal_patch() const {
return _impl_.patch_;
}
inline int32_t CudnnVersion::patch() const {
// @@protoc_insertion_point(field_get:xla.CudnnVersion.patch)
return _internal_patch();
}
inline void CudnnVersion::_internal_set_patch(int32_t value) {
_impl_.patch_ = value;
}
inline void CudnnVersion::set_patch(int32_t value) {
_internal_set_patch(value);
// @@protoc_insertion_point(field_set:xla.CudnnVersion.patch)
}
// -------------------------------------------------------------------
// ComputeCapability
// int32 major = 1;
inline void ComputeCapability::clear_major() {
_impl_.major_ = 0;
}
inline int32_t ComputeCapability::_internal_major() const {
return _impl_.major_;
}
inline int32_t ComputeCapability::major() const {
// @@protoc_insertion_point(field_get:xla.ComputeCapability.major)
return _internal_major();
}
inline void ComputeCapability::_internal_set_major(int32_t value) {
_impl_.major_ = value;
}
inline void ComputeCapability::set_major(int32_t value) {
_internal_set_major(value);
// @@protoc_insertion_point(field_set:xla.ComputeCapability.major)
}
// int32 minor = 2;
inline void ComputeCapability::clear_minor() {
_impl_.minor_ = 0;
}
inline int32_t ComputeCapability::_internal_minor() const {
return _impl_.minor_;
}
inline int32_t ComputeCapability::minor() const {
// @@protoc_insertion_point(field_get:xla.ComputeCapability.minor)
return _internal_minor();
}
inline void ComputeCapability::_internal_set_minor(int32_t value) {
_impl_.minor_ = value;
}
inline void ComputeCapability::set_minor(int32_t value) {
_internal_set_minor(value);
// @@protoc_insertion_point(field_set:xla.ComputeCapability.minor)
}
// -------------------------------------------------------------------
// AutotuneResult_FailureResult
// .xla.AutotuneResult.FailureKind kind = 1;
inline void AutotuneResult_FailureResult::clear_kind() {
_impl_.kind_ = 0;
}
inline ::xla::AutotuneResult_FailureKind AutotuneResult_FailureResult::_internal_kind() const {
return static_cast< ::xla::AutotuneResult_FailureKind >(_impl_.kind_);
}
inline ::xla::AutotuneResult_FailureKind AutotuneResult_FailureResult::kind() const {
// @@protoc_insertion_point(field_get:xla.AutotuneResult.FailureResult.kind)
return _internal_kind();
}
inline void AutotuneResult_FailureResult::_internal_set_kind(::xla::AutotuneResult_FailureKind value) {
_impl_.kind_ = value;
}
inline void AutotuneResult_FailureResult::set_kind(::xla::AutotuneResult_FailureKind value) {
_internal_set_kind(value);
// @@protoc_insertion_point(field_set:xla.AutotuneResult.FailureResult.kind)
}
// string msg = 2;
inline void AutotuneResult_FailureResult::clear_msg() {
_impl_.msg_.ClearToEmpty();
}
inline const std::string& AutotuneResult_FailureResult::msg() const {
// @@protoc_insertion_point(field_get:xla.AutotuneResult.FailureResult.msg)
return _internal_msg();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void AutotuneResult_FailureResult::set_msg(ArgT0&& arg0, ArgT... args) {
_impl_.msg_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:xla.AutotuneResult.FailureResult.msg)
}
inline std::string* AutotuneResult_FailureResult::mutable_msg() {
std::string* _s = _internal_mutable_msg();
// @@protoc_insertion_point(field_mutable:xla.AutotuneResult.FailureResult.msg)
return _s;
}
inline const std::string& AutotuneResult_FailureResult::_internal_msg() const {
return _impl_.msg_.Get();
}
inline void AutotuneResult_FailureResult::_internal_set_msg(const std::string& value) {
_impl_.msg_.Set(value, GetArenaForAllocation());
}
inline std::string* AutotuneResult_FailureResult::_internal_mutable_msg() {
return _impl_.msg_.Mutable(GetArenaForAllocation());
}
inline std::string* AutotuneResult_FailureResult::release_msg() {
// @@protoc_insertion_point(field_release:xla.AutotuneResult.FailureResult.msg)
return _impl_.msg_.Release();
}
inline void AutotuneResult_FailureResult::set_allocated_msg(std::string* msg) {
if (msg != nullptr) {
} else {
}
_impl_.msg_.SetAllocated(msg, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (_impl_.msg_.IsDefault()) {
_impl_.msg_.Set("", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:xla.AutotuneResult.FailureResult.msg)
}
// .xla.AutotuneResult.ConvKey reference_conv = 11;
inline bool AutotuneResult_FailureResult::_internal_has_reference_conv() const {
return key_case() == kReferenceConv;
}
inline bool AutotuneResult_FailureResult::has_reference_conv() const {
return _internal_has_reference_conv();
}
inline void AutotuneResult_FailureResult::set_has_reference_conv() {
_impl_._oneof_case_[0] = kReferenceConv;
}
inline void AutotuneResult_FailureResult::clear_reference_conv() {
if (_internal_has_reference_conv()) {
if (GetArenaForAllocation() == nullptr) {
delete _impl_.key_.reference_conv_;
}
clear_has_key();
}
}
inline ::xla::AutotuneResult_ConvKey* AutotuneResult_FailureResult::release_reference_conv() {
// @@protoc_insertion_point(field_release:xla.AutotuneResult.FailureResult.reference_conv)
if (_internal_has_reference_conv()) {
clear_has_key();
::xla::AutotuneResult_ConvKey* temp = _impl_.key_.reference_conv_;
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
_impl_.key_.reference_conv_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline const ::xla::AutotuneResult_ConvKey& AutotuneResult_FailureResult::_internal_reference_conv() const {
return _internal_has_reference_conv()
? *_impl_.key_.reference_conv_
: reinterpret_cast< ::xla::AutotuneResult_ConvKey&>(::xla::_AutotuneResult_ConvKey_default_instance_);
}
inline const ::xla::AutotuneResult_ConvKey& AutotuneResult_FailureResult::reference_conv() const {
// @@protoc_insertion_point(field_get:xla.AutotuneResult.FailureResult.reference_conv)
return _internal_reference_conv();
}
inline ::xla::AutotuneResult_ConvKey* AutotuneResult_FailureResult::unsafe_arena_release_reference_conv() {
// @@protoc_insertion_point(field_unsafe_arena_release:xla.AutotuneResult.FailureResult.reference_conv)
if (_internal_has_reference_conv()) {
clear_has_key();
::xla::AutotuneResult_ConvKey* temp = _impl_.key_.reference_conv_;
_impl_.key_.reference_conv_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline void AutotuneResult_FailureResult::unsafe_arena_set_allocated_reference_conv(::xla::AutotuneResult_ConvKey* reference_conv) {
clear_key();
if (reference_conv) {
set_has_reference_conv();
_impl_.key_.reference_conv_ = reference_conv;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.AutotuneResult.FailureResult.reference_conv)
}
inline ::xla::AutotuneResult_ConvKey* AutotuneResult_FailureResult::_internal_mutable_reference_conv() {
if (!_internal_has_reference_conv()) {
clear_key();
set_has_reference_conv();
_impl_.key_.reference_conv_ = CreateMaybeMessage< ::xla::AutotuneResult_ConvKey >(GetArenaForAllocation());
}
return _impl_.key_.reference_conv_;
}
inline ::xla::AutotuneResult_ConvKey* AutotuneResult_FailureResult::mutable_reference_conv() {
::xla::AutotuneResult_ConvKey* _msg = _internal_mutable_reference_conv();
// @@protoc_insertion_point(field_mutable:xla.AutotuneResult.FailureResult.reference_conv)
return _msg;
}
// .xla.AutotuneResult.GemmKey reference_gemm = 12;
inline bool AutotuneResult_FailureResult::_internal_has_reference_gemm() const {
return key_case() == kReferenceGemm;
}
inline bool AutotuneResult_FailureResult::has_reference_gemm() const {
return _internal_has_reference_gemm();
}
inline void AutotuneResult_FailureResult::set_has_reference_gemm() {
_impl_._oneof_case_[0] = kReferenceGemm;
}
inline void AutotuneResult_FailureResult::clear_reference_gemm() {
if (_internal_has_reference_gemm()) {
if (GetArenaForAllocation() == nullptr) {
delete _impl_.key_.reference_gemm_;
}
clear_has_key();
}
}
inline ::xla::AutotuneResult_GemmKey* AutotuneResult_FailureResult::release_reference_gemm() {
// @@protoc_insertion_point(field_release:xla.AutotuneResult.FailureResult.reference_gemm)
if (_internal_has_reference_gemm()) {
clear_has_key();
::xla::AutotuneResult_GemmKey* temp = _impl_.key_.reference_gemm_;
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
_impl_.key_.reference_gemm_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline const ::xla::AutotuneResult_GemmKey& AutotuneResult_FailureResult::_internal_reference_gemm() const {
return _internal_has_reference_gemm()
? *_impl_.key_.reference_gemm_
: reinterpret_cast< ::xla::AutotuneResult_GemmKey&>(::xla::_AutotuneResult_GemmKey_default_instance_);
}
inline const ::xla::AutotuneResult_GemmKey& AutotuneResult_FailureResult::reference_gemm() const {
// @@protoc_insertion_point(field_get:xla.AutotuneResult.FailureResult.reference_gemm)
return _internal_reference_gemm();
}
inline ::xla::AutotuneResult_GemmKey* AutotuneResult_FailureResult::unsafe_arena_release_reference_gemm() {
// @@protoc_insertion_point(field_unsafe_arena_release:xla.AutotuneResult.FailureResult.reference_gemm)
if (_internal_has_reference_gemm()) {
clear_has_key();
::xla::AutotuneResult_GemmKey* temp = _impl_.key_.reference_gemm_;
_impl_.key_.reference_gemm_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline void AutotuneResult_FailureResult::unsafe_arena_set_allocated_reference_gemm(::xla::AutotuneResult_GemmKey* reference_gemm) {
clear_key();
if (reference_gemm) {
set_has_reference_gemm();
_impl_.key_.reference_gemm_ = reference_gemm;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.AutotuneResult.FailureResult.reference_gemm)
}
inline ::xla::AutotuneResult_GemmKey* AutotuneResult_FailureResult::_internal_mutable_reference_gemm() {
if (!_internal_has_reference_gemm()) {
clear_key();
set_has_reference_gemm();
_impl_.key_.reference_gemm_ = CreateMaybeMessage< ::xla::AutotuneResult_GemmKey >(GetArenaForAllocation());
}
return _impl_.key_.reference_gemm_;
}
inline ::xla::AutotuneResult_GemmKey* AutotuneResult_FailureResult::mutable_reference_gemm() {
::xla::AutotuneResult_GemmKey* _msg = _internal_mutable_reference_gemm();
// @@protoc_insertion_point(field_mutable:xla.AutotuneResult.FailureResult.reference_gemm)
return _msg;
}
// .xla.AutotuneResult.CudaConvPlanKey reference_cuda_conv_plan = 14;
inline bool AutotuneResult_FailureResult::_internal_has_reference_cuda_conv_plan() const {
return key_case() == kReferenceCudaConvPlan;
}
inline bool AutotuneResult_FailureResult::has_reference_cuda_conv_plan() const {
return _internal_has_reference_cuda_conv_plan();
}
inline void AutotuneResult_FailureResult::set_has_reference_cuda_conv_plan() {
_impl_._oneof_case_[0] = kReferenceCudaConvPlan;
}
inline void AutotuneResult_FailureResult::clear_reference_cuda_conv_plan() {
if (_internal_has_reference_cuda_conv_plan()) {
if (GetArenaForAllocation() == nullptr) {
delete _impl_.key_.reference_cuda_conv_plan_;
}
clear_has_key();
}
}
inline ::xla::AutotuneResult_CudaConvPlanKey* AutotuneResult_FailureResult::release_reference_cuda_conv_plan() {
// @@protoc_insertion_point(field_release:xla.AutotuneResult.FailureResult.reference_cuda_conv_plan)
if (_internal_has_reference_cuda_conv_plan()) {
clear_has_key();
::xla::AutotuneResult_CudaConvPlanKey* temp = _impl_.key_.reference_cuda_conv_plan_;
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
_impl_.key_.reference_cuda_conv_plan_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline const ::xla::AutotuneResult_CudaConvPlanKey& AutotuneResult_FailureResult::_internal_reference_cuda_conv_plan() const {
return _internal_has_reference_cuda_conv_plan()
? *_impl_.key_.reference_cuda_conv_plan_
: reinterpret_cast< ::xla::AutotuneResult_CudaConvPlanKey&>(::xla::_AutotuneResult_CudaConvPlanKey_default_instance_);
}
inline const ::xla::AutotuneResult_CudaConvPlanKey& AutotuneResult_FailureResult::reference_cuda_conv_plan() const {
// @@protoc_insertion_point(field_get:xla.AutotuneResult.FailureResult.reference_cuda_conv_plan)
return _internal_reference_cuda_conv_plan();
}
inline ::xla::AutotuneResult_CudaConvPlanKey* AutotuneResult_FailureResult::unsafe_arena_release_reference_cuda_conv_plan() {
// @@protoc_insertion_point(field_unsafe_arena_release:xla.AutotuneResult.FailureResult.reference_cuda_conv_plan)
if (_internal_has_reference_cuda_conv_plan()) {
clear_has_key();
::xla::AutotuneResult_CudaConvPlanKey* temp = _impl_.key_.reference_cuda_conv_plan_;
_impl_.key_.reference_cuda_conv_plan_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline void AutotuneResult_FailureResult::unsafe_arena_set_allocated_reference_cuda_conv_plan(::xla::AutotuneResult_CudaConvPlanKey* reference_cuda_conv_plan) {
clear_key();
if (reference_cuda_conv_plan) {
set_has_reference_cuda_conv_plan();
_impl_.key_.reference_cuda_conv_plan_ = reference_cuda_conv_plan;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.AutotuneResult.FailureResult.reference_cuda_conv_plan)
}
inline ::xla::AutotuneResult_CudaConvPlanKey* AutotuneResult_FailureResult::_internal_mutable_reference_cuda_conv_plan() {
if (!_internal_has_reference_cuda_conv_plan()) {
clear_key();
set_has_reference_cuda_conv_plan();
_impl_.key_.reference_cuda_conv_plan_ = CreateMaybeMessage< ::xla::AutotuneResult_CudaConvPlanKey >(GetArenaForAllocation());
}
return _impl_.key_.reference_cuda_conv_plan_;
}
inline ::xla::AutotuneResult_CudaConvPlanKey* AutotuneResult_FailureResult::mutable_reference_cuda_conv_plan() {
::xla::AutotuneResult_CudaConvPlanKey* _msg = _internal_mutable_reference_cuda_conv_plan();
// @@protoc_insertion_point(field_mutable:xla.AutotuneResult.FailureResult.reference_cuda_conv_plan)
return _msg;
}
// .stream_executor.dnn.AlgorithmProto reference_algorithm = 15;
inline bool AutotuneResult_FailureResult::_internal_has_reference_algorithm() const {
return key_case() == kReferenceAlgorithm;
}
inline bool AutotuneResult_FailureResult::has_reference_algorithm() const {
return _internal_has_reference_algorithm();
}
inline void AutotuneResult_FailureResult::set_has_reference_algorithm() {
_impl_._oneof_case_[0] = kReferenceAlgorithm;
}
inline ::stream_executor::dnn::AlgorithmProto* AutotuneResult_FailureResult::release_reference_algorithm() {
// @@protoc_insertion_point(field_release:xla.AutotuneResult.FailureResult.reference_algorithm)
if (_internal_has_reference_algorithm()) {
clear_has_key();
::stream_executor::dnn::AlgorithmProto* temp = _impl_.key_.reference_algorithm_;
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
_impl_.key_.reference_algorithm_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline const ::stream_executor::dnn::AlgorithmProto& AutotuneResult_FailureResult::_internal_reference_algorithm() const {
return _internal_has_reference_algorithm()
? *_impl_.key_.reference_algorithm_
: reinterpret_cast< ::stream_executor::dnn::AlgorithmProto&>(::stream_executor::dnn::_AlgorithmProto_default_instance_);
}
inline const ::stream_executor::dnn::AlgorithmProto& AutotuneResult_FailureResult::reference_algorithm() const {
// @@protoc_insertion_point(field_get:xla.AutotuneResult.FailureResult.reference_algorithm)
return _internal_reference_algorithm();
}
inline ::stream_executor::dnn::AlgorithmProto* AutotuneResult_FailureResult::unsafe_arena_release_reference_algorithm() {
// @@protoc_insertion_point(field_unsafe_arena_release:xla.AutotuneResult.FailureResult.reference_algorithm)
if (_internal_has_reference_algorithm()) {
clear_has_key();
::stream_executor::dnn::AlgorithmProto* temp = _impl_.key_.reference_algorithm_;
_impl_.key_.reference_algorithm_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline void AutotuneResult_FailureResult::unsafe_arena_set_allocated_reference_algorithm(::stream_executor::dnn::AlgorithmProto* reference_algorithm) {
clear_key();
if (reference_algorithm) {
set_has_reference_algorithm();
_impl_.key_.reference_algorithm_ = reference_algorithm;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.AutotuneResult.FailureResult.reference_algorithm)
}
inline ::stream_executor::dnn::AlgorithmProto* AutotuneResult_FailureResult::_internal_mutable_reference_algorithm() {
if (!_internal_has_reference_algorithm()) {
clear_key();
set_has_reference_algorithm();
_impl_.key_.reference_algorithm_ = CreateMaybeMessage< ::stream_executor::dnn::AlgorithmProto >(GetArenaForAllocation());
}
return _impl_.key_.reference_algorithm_;
}
inline ::stream_executor::dnn::AlgorithmProto* AutotuneResult_FailureResult::mutable_reference_algorithm() {
::stream_executor::dnn::AlgorithmProto* _msg = _internal_mutable_reference_algorithm();
// @@protoc_insertion_point(field_mutable:xla.AutotuneResult.FailureResult.reference_algorithm)
return _msg;
}
// int64 buffer_address = 13;
inline void AutotuneResult_FailureResult::clear_buffer_address() {
_impl_.buffer_address_ = int64_t{0};
}
inline int64_t AutotuneResult_FailureResult::_internal_buffer_address() const {
return _impl_.buffer_address_;
}
inline int64_t AutotuneResult_FailureResult::buffer_address() const {
// @@protoc_insertion_point(field_get:xla.AutotuneResult.FailureResult.buffer_address)
return _internal_buffer_address();
}
inline void AutotuneResult_FailureResult::_internal_set_buffer_address(int64_t value) {
_impl_.buffer_address_ = value;
}
inline void AutotuneResult_FailureResult::set_buffer_address(int64_t value) {
_internal_set_buffer_address(value);
// @@protoc_insertion_point(field_set:xla.AutotuneResult.FailureResult.buffer_address)
}
inline bool AutotuneResult_FailureResult::has_key() const {
return key_case() != KEY_NOT_SET;
}
inline void AutotuneResult_FailureResult::clear_has_key() {
_impl_._oneof_case_[0] = KEY_NOT_SET;
}
inline AutotuneResult_FailureResult::KeyCase AutotuneResult_FailureResult::key_case() const {
return AutotuneResult_FailureResult::KeyCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------
// AutotuneResult_ConvKey
// int64 algorithm = 1;
inline void AutotuneResult_ConvKey::clear_algorithm() {
_impl_.algorithm_ = int64_t{0};
}
inline int64_t AutotuneResult_ConvKey::_internal_algorithm() const {
return _impl_.algorithm_;
}
inline int64_t AutotuneResult_ConvKey::algorithm() const {
// @@protoc_insertion_point(field_get:xla.AutotuneResult.ConvKey.algorithm)
return _internal_algorithm();
}
inline void AutotuneResult_ConvKey::_internal_set_algorithm(int64_t value) {
_impl_.algorithm_ = value;
}
inline void AutotuneResult_ConvKey::set_algorithm(int64_t value) {
_internal_set_algorithm(value);
// @@protoc_insertion_point(field_set:xla.AutotuneResult.ConvKey.algorithm)
}
// bool tensor_ops_enabled = 2;
inline void AutotuneResult_ConvKey::clear_tensor_ops_enabled() {
_impl_.tensor_ops_enabled_ = false;
}
inline bool AutotuneResult_ConvKey::_internal_tensor_ops_enabled() const {
return _impl_.tensor_ops_enabled_;
}
inline bool AutotuneResult_ConvKey::tensor_ops_enabled() const {
// @@protoc_insertion_point(field_get:xla.AutotuneResult.ConvKey.tensor_ops_enabled)
return _internal_tensor_ops_enabled();
}
inline void AutotuneResult_ConvKey::_internal_set_tensor_ops_enabled(bool value) {
_impl_.tensor_ops_enabled_ = value;
}
inline void AutotuneResult_ConvKey::set_tensor_ops_enabled(bool value) {
_internal_set_tensor_ops_enabled(value);
// @@protoc_insertion_point(field_set:xla.AutotuneResult.ConvKey.tensor_ops_enabled)
}
// -------------------------------------------------------------------
// AutotuneResult_GemmKey
// int64 algorithm = 1;
inline void AutotuneResult_GemmKey::clear_algorithm() {
_impl_.algorithm_ = int64_t{0};
}
inline int64_t AutotuneResult_GemmKey::_internal_algorithm() const {
return _impl_.algorithm_;
}
inline int64_t AutotuneResult_GemmKey::algorithm() const {
// @@protoc_insertion_point(field_get:xla.AutotuneResult.GemmKey.algorithm)
return _internal_algorithm();
}
inline void AutotuneResult_GemmKey::_internal_set_algorithm(int64_t value) {
_impl_.algorithm_ = value;
}
inline void AutotuneResult_GemmKey::set_algorithm(int64_t value) {
_internal_set_algorithm(value);
// @@protoc_insertion_point(field_set:xla.AutotuneResult.GemmKey.algorithm)
}
// -------------------------------------------------------------------
// AutotuneResult_CudaConvPlanKey
// string exec_plan_id = 1;
inline void AutotuneResult_CudaConvPlanKey::clear_exec_plan_id() {
_impl_.exec_plan_id_.ClearToEmpty();
}
inline const std::string& AutotuneResult_CudaConvPlanKey::exec_plan_id() const {
// @@protoc_insertion_point(field_get:xla.AutotuneResult.CudaConvPlanKey.exec_plan_id)
return _internal_exec_plan_id();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void AutotuneResult_CudaConvPlanKey::set_exec_plan_id(ArgT0&& arg0, ArgT... args) {
_impl_.exec_plan_id_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:xla.AutotuneResult.CudaConvPlanKey.exec_plan_id)
}
inline std::string* AutotuneResult_CudaConvPlanKey::mutable_exec_plan_id() {
std::string* _s = _internal_mutable_exec_plan_id();
// @@protoc_insertion_point(field_mutable:xla.AutotuneResult.CudaConvPlanKey.exec_plan_id)
return _s;
}
inline const std::string& AutotuneResult_CudaConvPlanKey::_internal_exec_plan_id() const {
return _impl_.exec_plan_id_.Get();
}
inline void AutotuneResult_CudaConvPlanKey::_internal_set_exec_plan_id(const std::string& value) {
_impl_.exec_plan_id_.Set(value, GetArenaForAllocation());
}
inline std::string* AutotuneResult_CudaConvPlanKey::_internal_mutable_exec_plan_id() {
return _impl_.exec_plan_id_.Mutable(GetArenaForAllocation());
}
inline std::string* AutotuneResult_CudaConvPlanKey::release_exec_plan_id() {
// @@protoc_insertion_point(field_release:xla.AutotuneResult.CudaConvPlanKey.exec_plan_id)
return _impl_.exec_plan_id_.Release();
}
inline void AutotuneResult_CudaConvPlanKey::set_allocated_exec_plan_id(std::string* exec_plan_id) {
if (exec_plan_id != nullptr) {
} else {
}
_impl_.exec_plan_id_.SetAllocated(exec_plan_id, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (_impl_.exec_plan_id_.IsDefault()) {
_impl_.exec_plan_id_.Set("", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:xla.AutotuneResult.CudaConvPlanKey.exec_plan_id)
}
// -------------------------------------------------------------------
// AutotuneResult_TritonGemmKey
// int64 block_m = 1;
inline void AutotuneResult_TritonGemmKey::clear_block_m() {
_impl_.block_m_ = int64_t{0};
}
inline int64_t AutotuneResult_TritonGemmKey::_internal_block_m() const {
return _impl_.block_m_;
}
inline int64_t AutotuneResult_TritonGemmKey::block_m() const {
// @@protoc_insertion_point(field_get:xla.AutotuneResult.TritonGemmKey.block_m)
return _internal_block_m();
}
inline void AutotuneResult_TritonGemmKey::_internal_set_block_m(int64_t value) {
_impl_.block_m_ = value;
}
inline void AutotuneResult_TritonGemmKey::set_block_m(int64_t value) {
_internal_set_block_m(value);
// @@protoc_insertion_point(field_set:xla.AutotuneResult.TritonGemmKey.block_m)
}
// int64 block_n = 2;
inline void AutotuneResult_TritonGemmKey::clear_block_n() {
_impl_.block_n_ = int64_t{0};
}
inline int64_t AutotuneResult_TritonGemmKey::_internal_block_n() const {
return _impl_.block_n_;
}
inline int64_t AutotuneResult_TritonGemmKey::block_n() const {
// @@protoc_insertion_point(field_get:xla.AutotuneResult.TritonGemmKey.block_n)
return _internal_block_n();
}
inline void AutotuneResult_TritonGemmKey::_internal_set_block_n(int64_t value) {
_impl_.block_n_ = value;
}
inline void AutotuneResult_TritonGemmKey::set_block_n(int64_t value) {
_internal_set_block_n(value);
// @@protoc_insertion_point(field_set:xla.AutotuneResult.TritonGemmKey.block_n)
}
// int64 block_k = 3;
inline void AutotuneResult_TritonGemmKey::clear_block_k() {
_impl_.block_k_ = int64_t{0};
}
inline int64_t AutotuneResult_TritonGemmKey::_internal_block_k() const {
return _impl_.block_k_;
}
inline int64_t AutotuneResult_TritonGemmKey::block_k() const {
// @@protoc_insertion_point(field_get:xla.AutotuneResult.TritonGemmKey.block_k)
return _internal_block_k();
}
inline void AutotuneResult_TritonGemmKey::_internal_set_block_k(int64_t value) {
_impl_.block_k_ = value;
}
inline void AutotuneResult_TritonGemmKey::set_block_k(int64_t value) {
_internal_set_block_k(value);
// @@protoc_insertion_point(field_set:xla.AutotuneResult.TritonGemmKey.block_k)
}
// int64 split_k = 4;
inline void AutotuneResult_TritonGemmKey::clear_split_k() {
_impl_.split_k_ = int64_t{0};
}
inline int64_t AutotuneResult_TritonGemmKey::_internal_split_k() const {
return _impl_.split_k_;
}
inline int64_t AutotuneResult_TritonGemmKey::split_k() const {
// @@protoc_insertion_point(field_get:xla.AutotuneResult.TritonGemmKey.split_k)
return _internal_split_k();
}
inline void AutotuneResult_TritonGemmKey::_internal_set_split_k(int64_t value) {
_impl_.split_k_ = value;
}
inline void AutotuneResult_TritonGemmKey::set_split_k(int64_t value) {
_internal_set_split_k(value);
// @@protoc_insertion_point(field_set:xla.AutotuneResult.TritonGemmKey.split_k)
}
// int64 num_stages = 5;
inline void AutotuneResult_TritonGemmKey::clear_num_stages() {
_impl_.num_stages_ = int64_t{0};
}
inline int64_t AutotuneResult_TritonGemmKey::_internal_num_stages() const {
return _impl_.num_stages_;
}
inline int64_t AutotuneResult_TritonGemmKey::num_stages() const {
// @@protoc_insertion_point(field_get:xla.AutotuneResult.TritonGemmKey.num_stages)
return _internal_num_stages();
}
inline void AutotuneResult_TritonGemmKey::_internal_set_num_stages(int64_t value) {
_impl_.num_stages_ = value;
}
inline void AutotuneResult_TritonGemmKey::set_num_stages(int64_t value) {
_internal_set_num_stages(value);
// @@protoc_insertion_point(field_set:xla.AutotuneResult.TritonGemmKey.num_stages)
}
// int64 num_warps = 6;
inline void AutotuneResult_TritonGemmKey::clear_num_warps() {
_impl_.num_warps_ = int64_t{0};
}
inline int64_t AutotuneResult_TritonGemmKey::_internal_num_warps() const {
return _impl_.num_warps_;
}
inline int64_t AutotuneResult_TritonGemmKey::num_warps() const {
// @@protoc_insertion_point(field_get:xla.AutotuneResult.TritonGemmKey.num_warps)
return _internal_num_warps();
}
inline void AutotuneResult_TritonGemmKey::_internal_set_num_warps(int64_t value) {
_impl_.num_warps_ = value;
}
inline void AutotuneResult_TritonGemmKey::set_num_warps(int64_t value) {
_internal_set_num_warps(value);
// @@protoc_insertion_point(field_set:xla.AutotuneResult.TritonGemmKey.num_warps)
}
// -------------------------------------------------------------------
// AutotuneResult
// int64 scratch_bytes = 8;
inline void AutotuneResult::clear_scratch_bytes() {
_impl_.scratch_bytes_ = int64_t{0};
}
inline int64_t AutotuneResult::_internal_scratch_bytes() const {
return _impl_.scratch_bytes_;
}
inline int64_t AutotuneResult::scratch_bytes() const {
// @@protoc_insertion_point(field_get:xla.AutotuneResult.scratch_bytes)
return _internal_scratch_bytes();
}
inline void AutotuneResult::_internal_set_scratch_bytes(int64_t value) {
_impl_.scratch_bytes_ = value;
}
inline void AutotuneResult::set_scratch_bytes(int64_t value) {
_internal_set_scratch_bytes(value);
// @@protoc_insertion_point(field_set:xla.AutotuneResult.scratch_bytes)
}
// .google.protobuf.Duration run_time = 9;
inline bool AutotuneResult::_internal_has_run_time() const {
return this != internal_default_instance() && _impl_.run_time_ != nullptr;
}
inline bool AutotuneResult::has_run_time() const {
return _internal_has_run_time();
}
inline const ::PROTOBUF_NAMESPACE_ID::Duration& AutotuneResult::_internal_run_time() const {
const ::PROTOBUF_NAMESPACE_ID::Duration* p = _impl_.run_time_;
return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Duration&>(
::PROTOBUF_NAMESPACE_ID::_Duration_default_instance_);
}
inline const ::PROTOBUF_NAMESPACE_ID::Duration& AutotuneResult::run_time() const {
// @@protoc_insertion_point(field_get:xla.AutotuneResult.run_time)
return _internal_run_time();
}
inline void AutotuneResult::unsafe_arena_set_allocated_run_time(
::PROTOBUF_NAMESPACE_ID::Duration* run_time) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.run_time_);
}
_impl_.run_time_ = run_time;
if (run_time) {
} else {
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.AutotuneResult.run_time)
}
inline ::PROTOBUF_NAMESPACE_ID::Duration* AutotuneResult::release_run_time() {
::PROTOBUF_NAMESPACE_ID::Duration* temp = _impl_.run_time_;
_impl_.run_time_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::Duration* AutotuneResult::unsafe_arena_release_run_time() {
// @@protoc_insertion_point(field_release:xla.AutotuneResult.run_time)
::PROTOBUF_NAMESPACE_ID::Duration* temp = _impl_.run_time_;
_impl_.run_time_ = nullptr;
return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::Duration* AutotuneResult::_internal_mutable_run_time() {
if (_impl_.run_time_ == nullptr) {
auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Duration>(GetArenaForAllocation());
_impl_.run_time_ = p;
}
return _impl_.run_time_;
}
inline ::PROTOBUF_NAMESPACE_ID::Duration* AutotuneResult::mutable_run_time() {
::PROTOBUF_NAMESPACE_ID::Duration* _msg = _internal_mutable_run_time();
// @@protoc_insertion_point(field_mutable:xla.AutotuneResult.run_time)
return _msg;
}
inline void AutotuneResult::set_allocated_run_time(::PROTOBUF_NAMESPACE_ID::Duration* run_time) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.run_time_);
}
if (run_time) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(run_time));
if (message_arena != submessage_arena) {
run_time = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, run_time, submessage_arena);
}
} else {
}
_impl_.run_time_ = run_time;
// @@protoc_insertion_point(field_set_allocated:xla.AutotuneResult.run_time)
}
// .xla.AutotuneResult.FailureResult failure = 7;
inline bool AutotuneResult::_internal_has_failure() const {
return this != internal_default_instance() && _impl_.failure_ != nullptr;
}
inline bool AutotuneResult::has_failure() const {
return _internal_has_failure();
}
inline void AutotuneResult::clear_failure() {
if (GetArenaForAllocation() == nullptr && _impl_.failure_ != nullptr) {
delete _impl_.failure_;
}
_impl_.failure_ = nullptr;
}
inline const ::xla::AutotuneResult_FailureResult& AutotuneResult::_internal_failure() const {
const ::xla::AutotuneResult_FailureResult* p = _impl_.failure_;
return p != nullptr ? *p : reinterpret_cast<const ::xla::AutotuneResult_FailureResult&>(
::xla::_AutotuneResult_FailureResult_default_instance_);
}
inline const ::xla::AutotuneResult_FailureResult& AutotuneResult::failure() const {
// @@protoc_insertion_point(field_get:xla.AutotuneResult.failure)
return _internal_failure();
}
inline void AutotuneResult::unsafe_arena_set_allocated_failure(
::xla::AutotuneResult_FailureResult* failure) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.failure_);
}
_impl_.failure_ = failure;
if (failure) {
} else {
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.AutotuneResult.failure)
}
inline ::xla::AutotuneResult_FailureResult* AutotuneResult::release_failure() {
::xla::AutotuneResult_FailureResult* temp = _impl_.failure_;
_impl_.failure_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::xla::AutotuneResult_FailureResult* AutotuneResult::unsafe_arena_release_failure() {
// @@protoc_insertion_point(field_release:xla.AutotuneResult.failure)
::xla::AutotuneResult_FailureResult* temp = _impl_.failure_;
_impl_.failure_ = nullptr;
return temp;
}
inline ::xla::AutotuneResult_FailureResult* AutotuneResult::_internal_mutable_failure() {
if (_impl_.failure_ == nullptr) {
auto* p = CreateMaybeMessage<::xla::AutotuneResult_FailureResult>(GetArenaForAllocation());
_impl_.failure_ = p;
}
return _impl_.failure_;
}
inline ::xla::AutotuneResult_FailureResult* AutotuneResult::mutable_failure() {
::xla::AutotuneResult_FailureResult* _msg = _internal_mutable_failure();
// @@protoc_insertion_point(field_mutable:xla.AutotuneResult.failure)
return _msg;
}
inline void AutotuneResult::set_allocated_failure(::xla::AutotuneResult_FailureResult* failure) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete _impl_.failure_;
}
if (failure) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(failure);
if (message_arena != submessage_arena) {
failure = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, failure, submessage_arena);
}
} else {
}
_impl_.failure_ = failure;
// @@protoc_insertion_point(field_set_allocated:xla.AutotuneResult.failure)
}
// .xla.AutotuneResult.ConvKey conv = 5;
inline bool AutotuneResult::_internal_has_conv() const {
return key_case() == kConv;
}
inline bool AutotuneResult::has_conv() const {
return _internal_has_conv();
}
inline void AutotuneResult::set_has_conv() {
_impl_._oneof_case_[0] = kConv;
}
inline void AutotuneResult::clear_conv() {
if (_internal_has_conv()) {
if (GetArenaForAllocation() == nullptr) {
delete _impl_.key_.conv_;
}
clear_has_key();
}
}
inline ::xla::AutotuneResult_ConvKey* AutotuneResult::release_conv() {
// @@protoc_insertion_point(field_release:xla.AutotuneResult.conv)
if (_internal_has_conv()) {
clear_has_key();
::xla::AutotuneResult_ConvKey* temp = _impl_.key_.conv_;
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
_impl_.key_.conv_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline const ::xla::AutotuneResult_ConvKey& AutotuneResult::_internal_conv() const {
return _internal_has_conv()
? *_impl_.key_.conv_
: reinterpret_cast< ::xla::AutotuneResult_ConvKey&>(::xla::_AutotuneResult_ConvKey_default_instance_);
}
inline const ::xla::AutotuneResult_ConvKey& AutotuneResult::conv() const {
// @@protoc_insertion_point(field_get:xla.AutotuneResult.conv)
return _internal_conv();
}
inline ::xla::AutotuneResult_ConvKey* AutotuneResult::unsafe_arena_release_conv() {
// @@protoc_insertion_point(field_unsafe_arena_release:xla.AutotuneResult.conv)
if (_internal_has_conv()) {
clear_has_key();
::xla::AutotuneResult_ConvKey* temp = _impl_.key_.conv_;
_impl_.key_.conv_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline void AutotuneResult::unsafe_arena_set_allocated_conv(::xla::AutotuneResult_ConvKey* conv) {
clear_key();
if (conv) {
set_has_conv();
_impl_.key_.conv_ = conv;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.AutotuneResult.conv)
}
inline ::xla::AutotuneResult_ConvKey* AutotuneResult::_internal_mutable_conv() {
if (!_internal_has_conv()) {
clear_key();
set_has_conv();
_impl_.key_.conv_ = CreateMaybeMessage< ::xla::AutotuneResult_ConvKey >(GetArenaForAllocation());
}
return _impl_.key_.conv_;
}
inline ::xla::AutotuneResult_ConvKey* AutotuneResult::mutable_conv() {
::xla::AutotuneResult_ConvKey* _msg = _internal_mutable_conv();
// @@protoc_insertion_point(field_mutable:xla.AutotuneResult.conv)
return _msg;
}
// .xla.AutotuneResult.GemmKey gemm = 6;
inline bool AutotuneResult::_internal_has_gemm() const {
return key_case() == kGemm;
}
inline bool AutotuneResult::has_gemm() const {
return _internal_has_gemm();
}
inline void AutotuneResult::set_has_gemm() {
_impl_._oneof_case_[0] = kGemm;
}
inline void AutotuneResult::clear_gemm() {
if (_internal_has_gemm()) {
if (GetArenaForAllocation() == nullptr) {
delete _impl_.key_.gemm_;
}
clear_has_key();
}
}
inline ::xla::AutotuneResult_GemmKey* AutotuneResult::release_gemm() {
// @@protoc_insertion_point(field_release:xla.AutotuneResult.gemm)
if (_internal_has_gemm()) {
clear_has_key();
::xla::AutotuneResult_GemmKey* temp = _impl_.key_.gemm_;
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
_impl_.key_.gemm_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline const ::xla::AutotuneResult_GemmKey& AutotuneResult::_internal_gemm() const {
return _internal_has_gemm()
? *_impl_.key_.gemm_
: reinterpret_cast< ::xla::AutotuneResult_GemmKey&>(::xla::_AutotuneResult_GemmKey_default_instance_);
}
inline const ::xla::AutotuneResult_GemmKey& AutotuneResult::gemm() const {
// @@protoc_insertion_point(field_get:xla.AutotuneResult.gemm)
return _internal_gemm();
}
inline ::xla::AutotuneResult_GemmKey* AutotuneResult::unsafe_arena_release_gemm() {
// @@protoc_insertion_point(field_unsafe_arena_release:xla.AutotuneResult.gemm)
if (_internal_has_gemm()) {
clear_has_key();
::xla::AutotuneResult_GemmKey* temp = _impl_.key_.gemm_;
_impl_.key_.gemm_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline void AutotuneResult::unsafe_arena_set_allocated_gemm(::xla::AutotuneResult_GemmKey* gemm) {
clear_key();
if (gemm) {
set_has_gemm();
_impl_.key_.gemm_ = gemm;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.AutotuneResult.gemm)
}
inline ::xla::AutotuneResult_GemmKey* AutotuneResult::_internal_mutable_gemm() {
if (!_internal_has_gemm()) {
clear_key();
set_has_gemm();
_impl_.key_.gemm_ = CreateMaybeMessage< ::xla::AutotuneResult_GemmKey >(GetArenaForAllocation());
}
return _impl_.key_.gemm_;
}
inline ::xla::AutotuneResult_GemmKey* AutotuneResult::mutable_gemm() {
::xla::AutotuneResult_GemmKey* _msg = _internal_mutable_gemm();
// @@protoc_insertion_point(field_mutable:xla.AutotuneResult.gemm)
return _msg;
}
// .xla.AutotuneResult.TritonGemmKey triton = 17;
inline bool AutotuneResult::_internal_has_triton() const {
return key_case() == kTriton;
}
inline bool AutotuneResult::has_triton() const {
return _internal_has_triton();
}
inline void AutotuneResult::set_has_triton() {
_impl_._oneof_case_[0] = kTriton;
}
inline void AutotuneResult::clear_triton() {
if (_internal_has_triton()) {
if (GetArenaForAllocation() == nullptr) {
delete _impl_.key_.triton_;
}
clear_has_key();
}
}
inline ::xla::AutotuneResult_TritonGemmKey* AutotuneResult::release_triton() {
// @@protoc_insertion_point(field_release:xla.AutotuneResult.triton)
if (_internal_has_triton()) {
clear_has_key();
::xla::AutotuneResult_TritonGemmKey* temp = _impl_.key_.triton_;
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
_impl_.key_.triton_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline const ::xla::AutotuneResult_TritonGemmKey& AutotuneResult::_internal_triton() const {
return _internal_has_triton()
? *_impl_.key_.triton_
: reinterpret_cast< ::xla::AutotuneResult_TritonGemmKey&>(::xla::_AutotuneResult_TritonGemmKey_default_instance_);
}
inline const ::xla::AutotuneResult_TritonGemmKey& AutotuneResult::triton() const {
// @@protoc_insertion_point(field_get:xla.AutotuneResult.triton)
return _internal_triton();
}
inline ::xla::AutotuneResult_TritonGemmKey* AutotuneResult::unsafe_arena_release_triton() {
// @@protoc_insertion_point(field_unsafe_arena_release:xla.AutotuneResult.triton)
if (_internal_has_triton()) {
clear_has_key();
::xla::AutotuneResult_TritonGemmKey* temp = _impl_.key_.triton_;
_impl_.key_.triton_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline void AutotuneResult::unsafe_arena_set_allocated_triton(::xla::AutotuneResult_TritonGemmKey* triton) {
clear_key();
if (triton) {
set_has_triton();
_impl_.key_.triton_ = triton;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.AutotuneResult.triton)
}
inline ::xla::AutotuneResult_TritonGemmKey* AutotuneResult::_internal_mutable_triton() {
if (!_internal_has_triton()) {
clear_key();
set_has_triton();
_impl_.key_.triton_ = CreateMaybeMessage< ::xla::AutotuneResult_TritonGemmKey >(GetArenaForAllocation());
}
return _impl_.key_.triton_;
}
inline ::xla::AutotuneResult_TritonGemmKey* AutotuneResult::mutable_triton() {
::xla::AutotuneResult_TritonGemmKey* _msg = _internal_mutable_triton();
// @@protoc_insertion_point(field_mutable:xla.AutotuneResult.triton)
return _msg;
}
// .xla.AutotuneResult.CudaConvPlanKey cuda_conv_plan = 15;
inline bool AutotuneResult::_internal_has_cuda_conv_plan() const {
return key_case() == kCudaConvPlan;
}
inline bool AutotuneResult::has_cuda_conv_plan() const {
return _internal_has_cuda_conv_plan();
}
inline void AutotuneResult::set_has_cuda_conv_plan() {
_impl_._oneof_case_[0] = kCudaConvPlan;
}
inline void AutotuneResult::clear_cuda_conv_plan() {
if (_internal_has_cuda_conv_plan()) {
if (GetArenaForAllocation() == nullptr) {
delete _impl_.key_.cuda_conv_plan_;
}
clear_has_key();
}
}
inline ::xla::AutotuneResult_CudaConvPlanKey* AutotuneResult::release_cuda_conv_plan() {
// @@protoc_insertion_point(field_release:xla.AutotuneResult.cuda_conv_plan)
if (_internal_has_cuda_conv_plan()) {
clear_has_key();
::xla::AutotuneResult_CudaConvPlanKey* temp = _impl_.key_.cuda_conv_plan_;
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
_impl_.key_.cuda_conv_plan_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline const ::xla::AutotuneResult_CudaConvPlanKey& AutotuneResult::_internal_cuda_conv_plan() const {
return _internal_has_cuda_conv_plan()
? *_impl_.key_.cuda_conv_plan_
: reinterpret_cast< ::xla::AutotuneResult_CudaConvPlanKey&>(::xla::_AutotuneResult_CudaConvPlanKey_default_instance_);
}
inline const ::xla::AutotuneResult_CudaConvPlanKey& AutotuneResult::cuda_conv_plan() const {
// @@protoc_insertion_point(field_get:xla.AutotuneResult.cuda_conv_plan)
return _internal_cuda_conv_plan();
}
inline ::xla::AutotuneResult_CudaConvPlanKey* AutotuneResult::unsafe_arena_release_cuda_conv_plan() {
// @@protoc_insertion_point(field_unsafe_arena_release:xla.AutotuneResult.cuda_conv_plan)
if (_internal_has_cuda_conv_plan()) {
clear_has_key();
::xla::AutotuneResult_CudaConvPlanKey* temp = _impl_.key_.cuda_conv_plan_;
_impl_.key_.cuda_conv_plan_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline void AutotuneResult::unsafe_arena_set_allocated_cuda_conv_plan(::xla::AutotuneResult_CudaConvPlanKey* cuda_conv_plan) {
clear_key();
if (cuda_conv_plan) {
set_has_cuda_conv_plan();
_impl_.key_.cuda_conv_plan_ = cuda_conv_plan;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.AutotuneResult.cuda_conv_plan)
}
inline ::xla::AutotuneResult_CudaConvPlanKey* AutotuneResult::_internal_mutable_cuda_conv_plan() {
if (!_internal_has_cuda_conv_plan()) {
clear_key();
set_has_cuda_conv_plan();
_impl_.key_.cuda_conv_plan_ = CreateMaybeMessage< ::xla::AutotuneResult_CudaConvPlanKey >(GetArenaForAllocation());
}
return _impl_.key_.cuda_conv_plan_;
}
inline ::xla::AutotuneResult_CudaConvPlanKey* AutotuneResult::mutable_cuda_conv_plan() {
::xla::AutotuneResult_CudaConvPlanKey* _msg = _internal_mutable_cuda_conv_plan();
// @@protoc_insertion_point(field_mutable:xla.AutotuneResult.cuda_conv_plan)
return _msg;
}
// .stream_executor.dnn.AlgorithmProto algorithm = 16;
inline bool AutotuneResult::_internal_has_algorithm() const {
return key_case() == kAlgorithm;
}
inline bool AutotuneResult::has_algorithm() const {
return _internal_has_algorithm();
}
inline void AutotuneResult::set_has_algorithm() {
_impl_._oneof_case_[0] = kAlgorithm;
}
inline ::stream_executor::dnn::AlgorithmProto* AutotuneResult::release_algorithm() {
// @@protoc_insertion_point(field_release:xla.AutotuneResult.algorithm)
if (_internal_has_algorithm()) {
clear_has_key();
::stream_executor::dnn::AlgorithmProto* temp = _impl_.key_.algorithm_;
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
_impl_.key_.algorithm_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline const ::stream_executor::dnn::AlgorithmProto& AutotuneResult::_internal_algorithm() const {
return _internal_has_algorithm()
? *_impl_.key_.algorithm_
: reinterpret_cast< ::stream_executor::dnn::AlgorithmProto&>(::stream_executor::dnn::_AlgorithmProto_default_instance_);
}
inline const ::stream_executor::dnn::AlgorithmProto& AutotuneResult::algorithm() const {
// @@protoc_insertion_point(field_get:xla.AutotuneResult.algorithm)
return _internal_algorithm();
}
inline ::stream_executor::dnn::AlgorithmProto* AutotuneResult::unsafe_arena_release_algorithm() {
// @@protoc_insertion_point(field_unsafe_arena_release:xla.AutotuneResult.algorithm)
if (_internal_has_algorithm()) {
clear_has_key();
::stream_executor::dnn::AlgorithmProto* temp = _impl_.key_.algorithm_;
_impl_.key_.algorithm_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline void AutotuneResult::unsafe_arena_set_allocated_algorithm(::stream_executor::dnn::AlgorithmProto* algorithm) {
clear_key();
if (algorithm) {
set_has_algorithm();
_impl_.key_.algorithm_ = algorithm;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.AutotuneResult.algorithm)
}
inline ::stream_executor::dnn::AlgorithmProto* AutotuneResult::_internal_mutable_algorithm() {
if (!_internal_has_algorithm()) {
clear_key();
set_has_algorithm();
_impl_.key_.algorithm_ = CreateMaybeMessage< ::stream_executor::dnn::AlgorithmProto >(GetArenaForAllocation());
}
return _impl_.key_.algorithm_;
}
inline ::stream_executor::dnn::AlgorithmProto* AutotuneResult::mutable_algorithm() {
::stream_executor::dnn::AlgorithmProto* _msg = _internal_mutable_algorithm();
// @@protoc_insertion_point(field_mutable:xla.AutotuneResult.algorithm)
return _msg;
}
inline bool AutotuneResult::has_key() const {
return key_case() != KEY_NOT_SET;
}
inline void AutotuneResult::clear_has_key() {
_impl_._oneof_case_[0] = KEY_NOT_SET;
}
inline AutotuneResult::KeyCase AutotuneResult::key_case() const {
return AutotuneResult::KeyCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------
// AutotuningLog
// .google.protobuf.Any instr = 1;
inline bool AutotuningLog::_internal_has_instr() const {
return this != internal_default_instance() && _impl_.instr_ != nullptr;
}
inline bool AutotuningLog::has_instr() const {
return _internal_has_instr();
}
inline const ::PROTOBUF_NAMESPACE_ID::Any& AutotuningLog::_internal_instr() const {
const ::PROTOBUF_NAMESPACE_ID::Any* p = _impl_.instr_;
return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Any&>(
::PROTOBUF_NAMESPACE_ID::_Any_default_instance_);
}
inline const ::PROTOBUF_NAMESPACE_ID::Any& AutotuningLog::instr() const {
// @@protoc_insertion_point(field_get:xla.AutotuningLog.instr)
return _internal_instr();
}
inline void AutotuningLog::unsafe_arena_set_allocated_instr(
::PROTOBUF_NAMESPACE_ID::Any* instr) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.instr_);
}
_impl_.instr_ = instr;
if (instr) {
} else {
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.AutotuningLog.instr)
}
inline ::PROTOBUF_NAMESPACE_ID::Any* AutotuningLog::release_instr() {
::PROTOBUF_NAMESPACE_ID::Any* temp = _impl_.instr_;
_impl_.instr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::Any* AutotuningLog::unsafe_arena_release_instr() {
// @@protoc_insertion_point(field_release:xla.AutotuningLog.instr)
::PROTOBUF_NAMESPACE_ID::Any* temp = _impl_.instr_;
_impl_.instr_ = nullptr;
return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::Any* AutotuningLog::_internal_mutable_instr() {
if (_impl_.instr_ == nullptr) {
auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Any>(GetArenaForAllocation());
_impl_.instr_ = p;
}
return _impl_.instr_;
}
inline ::PROTOBUF_NAMESPACE_ID::Any* AutotuningLog::mutable_instr() {
::PROTOBUF_NAMESPACE_ID::Any* _msg = _internal_mutable_instr();
// @@protoc_insertion_point(field_mutable:xla.AutotuningLog.instr)
return _msg;
}
inline void AutotuningLog::set_allocated_instr(::PROTOBUF_NAMESPACE_ID::Any* instr) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.instr_);
}
if (instr) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(instr));
if (message_arena != submessage_arena) {
instr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, instr, submessage_arena);
}
} else {
}
_impl_.instr_ = instr;
// @@protoc_insertion_point(field_set_allocated:xla.AutotuningLog.instr)
}
// repeated .xla.AutotuneResult results = 2;
inline int AutotuningLog::_internal_results_size() const {
return _impl_.results_.size();
}
inline int AutotuningLog::results_size() const {
return _internal_results_size();
}
inline void AutotuningLog::clear_results() {
_impl_.results_.Clear();
}
inline ::xla::AutotuneResult* AutotuningLog::mutable_results(int index) {
// @@protoc_insertion_point(field_mutable:xla.AutotuningLog.results)
return _impl_.results_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::AutotuneResult >*
AutotuningLog::mutable_results() {
// @@protoc_insertion_point(field_mutable_list:xla.AutotuningLog.results)
return &_impl_.results_;
}
inline const ::xla::AutotuneResult& AutotuningLog::_internal_results(int index) const {
return _impl_.results_.Get(index);
}
inline const ::xla::AutotuneResult& AutotuningLog::results(int index) const {
// @@protoc_insertion_point(field_get:xla.AutotuningLog.results)
return _internal_results(index);
}
inline ::xla::AutotuneResult* AutotuningLog::_internal_add_results() {
return _impl_.results_.Add();
}
inline ::xla::AutotuneResult* AutotuningLog::add_results() {
::xla::AutotuneResult* _add = _internal_add_results();
// @@protoc_insertion_point(field_add:xla.AutotuningLog.results)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::AutotuneResult >&
AutotuningLog::results() const {
// @@protoc_insertion_point(field_list:xla.AutotuningLog.results)
return _impl_.results_;
}
// .xla.CudnnVersion cudnn_version = 3;
inline bool AutotuningLog::_internal_has_cudnn_version() const {
return this != internal_default_instance() && _impl_.cudnn_version_ != nullptr;
}
inline bool AutotuningLog::has_cudnn_version() const {
return _internal_has_cudnn_version();
}
inline void AutotuningLog::clear_cudnn_version() {
if (GetArenaForAllocation() == nullptr && _impl_.cudnn_version_ != nullptr) {
delete _impl_.cudnn_version_;
}
_impl_.cudnn_version_ = nullptr;
}
inline const ::xla::CudnnVersion& AutotuningLog::_internal_cudnn_version() const {
const ::xla::CudnnVersion* p = _impl_.cudnn_version_;
return p != nullptr ? *p : reinterpret_cast<const ::xla::CudnnVersion&>(
::xla::_CudnnVersion_default_instance_);
}
inline const ::xla::CudnnVersion& AutotuningLog::cudnn_version() const {
// @@protoc_insertion_point(field_get:xla.AutotuningLog.cudnn_version)
return _internal_cudnn_version();
}
inline void AutotuningLog::unsafe_arena_set_allocated_cudnn_version(
::xla::CudnnVersion* cudnn_version) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.cudnn_version_);
}
_impl_.cudnn_version_ = cudnn_version;
if (cudnn_version) {
} else {
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.AutotuningLog.cudnn_version)
}
inline ::xla::CudnnVersion* AutotuningLog::release_cudnn_version() {
::xla::CudnnVersion* temp = _impl_.cudnn_version_;
_impl_.cudnn_version_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::xla::CudnnVersion* AutotuningLog::unsafe_arena_release_cudnn_version() {
// @@protoc_insertion_point(field_release:xla.AutotuningLog.cudnn_version)
::xla::CudnnVersion* temp = _impl_.cudnn_version_;
_impl_.cudnn_version_ = nullptr;
return temp;
}
inline ::xla::CudnnVersion* AutotuningLog::_internal_mutable_cudnn_version() {
if (_impl_.cudnn_version_ == nullptr) {
auto* p = CreateMaybeMessage<::xla::CudnnVersion>(GetArenaForAllocation());
_impl_.cudnn_version_ = p;
}
return _impl_.cudnn_version_;
}
inline ::xla::CudnnVersion* AutotuningLog::mutable_cudnn_version() {
::xla::CudnnVersion* _msg = _internal_mutable_cudnn_version();
// @@protoc_insertion_point(field_mutable:xla.AutotuningLog.cudnn_version)
return _msg;
}
inline void AutotuningLog::set_allocated_cudnn_version(::xla::CudnnVersion* cudnn_version) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete _impl_.cudnn_version_;
}
if (cudnn_version) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(cudnn_version);
if (message_arena != submessage_arena) {
cudnn_version = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, cudnn_version, submessage_arena);
}
} else {
}
_impl_.cudnn_version_ = cudnn_version;
// @@protoc_insertion_point(field_set_allocated:xla.AutotuningLog.cudnn_version)
}
// .xla.ComputeCapability compute_capability = 4;
inline bool AutotuningLog::_internal_has_compute_capability() const {
return this != internal_default_instance() && _impl_.compute_capability_ != nullptr;
}
inline bool AutotuningLog::has_compute_capability() const {
return _internal_has_compute_capability();
}
inline void AutotuningLog::clear_compute_capability() {
if (GetArenaForAllocation() == nullptr && _impl_.compute_capability_ != nullptr) {
delete _impl_.compute_capability_;
}
_impl_.compute_capability_ = nullptr;
}
inline const ::xla::ComputeCapability& AutotuningLog::_internal_compute_capability() const {
const ::xla::ComputeCapability* p = _impl_.compute_capability_;
return p != nullptr ? *p : reinterpret_cast<const ::xla::ComputeCapability&>(
::xla::_ComputeCapability_default_instance_);
}
inline const ::xla::ComputeCapability& AutotuningLog::compute_capability() const {
// @@protoc_insertion_point(field_get:xla.AutotuningLog.compute_capability)
return _internal_compute_capability();
}
inline void AutotuningLog::unsafe_arena_set_allocated_compute_capability(
::xla::ComputeCapability* compute_capability) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.compute_capability_);
}
_impl_.compute_capability_ = compute_capability;
if (compute_capability) {
} else {
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.AutotuningLog.compute_capability)
}
inline ::xla::ComputeCapability* AutotuningLog::release_compute_capability() {
::xla::ComputeCapability* temp = _impl_.compute_capability_;
_impl_.compute_capability_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::xla::ComputeCapability* AutotuningLog::unsafe_arena_release_compute_capability() {
// @@protoc_insertion_point(field_release:xla.AutotuningLog.compute_capability)
::xla::ComputeCapability* temp = _impl_.compute_capability_;
_impl_.compute_capability_ = nullptr;
return temp;
}
inline ::xla::ComputeCapability* AutotuningLog::_internal_mutable_compute_capability() {
if (_impl_.compute_capability_ == nullptr) {
auto* p = CreateMaybeMessage<::xla::ComputeCapability>(GetArenaForAllocation());
_impl_.compute_capability_ = p;
}
return _impl_.compute_capability_;
}
inline ::xla::ComputeCapability* AutotuningLog::mutable_compute_capability() {
::xla::ComputeCapability* _msg = _internal_mutable_compute_capability();
// @@protoc_insertion_point(field_mutable:xla.AutotuningLog.compute_capability)
return _msg;
}
inline void AutotuningLog::set_allocated_compute_capability(::xla::ComputeCapability* compute_capability) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete _impl_.compute_capability_;
}
if (compute_capability) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(compute_capability);
if (message_arena != submessage_arena) {
compute_capability = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, compute_capability, submessage_arena);
}
} else {
}
_impl_.compute_capability_ = compute_capability;
// @@protoc_insertion_point(field_set_allocated:xla.AutotuningLog.compute_capability)
}
// string device_pci_bus_id = 5;
inline void AutotuningLog::clear_device_pci_bus_id() {
_impl_.device_pci_bus_id_.ClearToEmpty();
}
inline const std::string& AutotuningLog::device_pci_bus_id() const {
// @@protoc_insertion_point(field_get:xla.AutotuningLog.device_pci_bus_id)
return _internal_device_pci_bus_id();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void AutotuningLog::set_device_pci_bus_id(ArgT0&& arg0, ArgT... args) {
_impl_.device_pci_bus_id_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:xla.AutotuningLog.device_pci_bus_id)
}
inline std::string* AutotuningLog::mutable_device_pci_bus_id() {
std::string* _s = _internal_mutable_device_pci_bus_id();
// @@protoc_insertion_point(field_mutable:xla.AutotuningLog.device_pci_bus_id)
return _s;
}
inline const std::string& AutotuningLog::_internal_device_pci_bus_id() const {
return _impl_.device_pci_bus_id_.Get();
}
inline void AutotuningLog::_internal_set_device_pci_bus_id(const std::string& value) {
_impl_.device_pci_bus_id_.Set(value, GetArenaForAllocation());
}
inline std::string* AutotuningLog::_internal_mutable_device_pci_bus_id() {
return _impl_.device_pci_bus_id_.Mutable(GetArenaForAllocation());
}
inline std::string* AutotuningLog::release_device_pci_bus_id() {
// @@protoc_insertion_point(field_release:xla.AutotuningLog.device_pci_bus_id)
return _impl_.device_pci_bus_id_.Release();
}
inline void AutotuningLog::set_allocated_device_pci_bus_id(std::string* device_pci_bus_id) {
if (device_pci_bus_id != nullptr) {
} else {
}
_impl_.device_pci_bus_id_.SetAllocated(device_pci_bus_id, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (_impl_.device_pci_bus_id_.IsDefault()) {
_impl_.device_pci_bus_id_.Set("", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:xla.AutotuningLog.device_pci_bus_id)
}
// string blas_version = 6;
inline void AutotuningLog::clear_blas_version() {
_impl_.blas_version_.ClearToEmpty();
}
inline const std::string& AutotuningLog::blas_version() const {
// @@protoc_insertion_point(field_get:xla.AutotuningLog.blas_version)
return _internal_blas_version();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void AutotuningLog::set_blas_version(ArgT0&& arg0, ArgT... args) {
_impl_.blas_version_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:xla.AutotuningLog.blas_version)
}
inline std::string* AutotuningLog::mutable_blas_version() {
std::string* _s = _internal_mutable_blas_version();
// @@protoc_insertion_point(field_mutable:xla.AutotuningLog.blas_version)
return _s;
}
inline const std::string& AutotuningLog::_internal_blas_version() const {
return _impl_.blas_version_.Get();
}
inline void AutotuningLog::_internal_set_blas_version(const std::string& value) {
_impl_.blas_version_.Set(value, GetArenaForAllocation());
}
inline std::string* AutotuningLog::_internal_mutable_blas_version() {
return _impl_.blas_version_.Mutable(GetArenaForAllocation());
}
inline std::string* AutotuningLog::release_blas_version() {
// @@protoc_insertion_point(field_release:xla.AutotuningLog.blas_version)
return _impl_.blas_version_.Release();
}
inline void AutotuningLog::set_allocated_blas_version(std::string* blas_version) {
if (blas_version != nullptr) {
} else {
}
_impl_.blas_version_.SetAllocated(blas_version, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (_impl_.blas_version_.IsDefault()) {
_impl_.blas_version_.Set("", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:xla.AutotuningLog.blas_version)
}
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif // __GNUC__
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// @@protoc_insertion_point(namespace_scope)
} // namespace xla
PROTOBUF_NAMESPACE_OPEN
template <> struct is_proto_enum< ::xla::AutotuneResult_FailureKind> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::xla::AutotuneResult_FailureKind>() {
return ::xla::AutotuneResult_FailureKind_descriptor();
}
PROTOBUF_NAMESPACE_CLOSE
// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>
#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_xla_2fautotuning_2eproto
Reference in New Issue View Git Blame Copy Permalink