wehub-resource-sync
5141 lines
209 KiB
C++
5141 lines
209 KiB
C++
// Generated by the protocol buffer compiler. DO NOT EDIT!
|
|
// source: MNN_compression.proto
|
|
|
|
#ifndef GOOGLE_PROTOBUF_INCLUDED_MNN_5fcompression_2eproto
|
|
#define GOOGLE_PROTOBUF_INCLUDED_MNN_5fcompression_2eproto
|
|
|
|
#include <limits>
|
|
#include <string>
|
|
|
|
#include <google/protobuf/port_def.inc>
|
|
#if PROTOBUF_VERSION < 3019000
|
|
#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 3019000 < 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_table_driven.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>
|
|
// @@protoc_insertion_point(includes)
|
|
#include <google/protobuf/port_def.inc>
|
|
#define PROTOBUF_INTERNAL_EXPORT_MNN_5fcompression_2eproto
|
|
PROTOBUF_NAMESPACE_OPEN
|
|
namespace internal {
|
|
class AnyMetadata;
|
|
} // namespace internal
|
|
PROTOBUF_NAMESPACE_CLOSE
|
|
|
|
// Internal implementation detail -- do not use these members.
|
|
struct TableStruct_MNN_5fcompression_2eproto {
|
|
static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
|
|
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
|
|
static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
|
|
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
|
|
static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[11]
|
|
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
|
|
static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
|
|
static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
|
|
static const uint32_t offsets[];
|
|
};
|
|
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_MNN_5fcompression_2eproto;
|
|
namespace MNN {
|
|
namespace Compression {
|
|
class CompressionAlgo;
|
|
struct CompressionAlgoDefaultTypeInternal;
|
|
extern CompressionAlgoDefaultTypeInternal _CompressionAlgo_default_instance_;
|
|
class LayerQuantizeParams;
|
|
struct LayerQuantizeParamsDefaultTypeInternal;
|
|
extern LayerQuantizeParamsDefaultTypeInternal _LayerQuantizeParams_default_instance_;
|
|
class LayerQuantizeParams_ActivationParams;
|
|
struct LayerQuantizeParams_ActivationParamsDefaultTypeInternal;
|
|
extern LayerQuantizeParams_ActivationParamsDefaultTypeInternal _LayerQuantizeParams_ActivationParams_default_instance_;
|
|
class LayerQuantizeParams_ConvolutionInfo;
|
|
struct LayerQuantizeParams_ConvolutionInfoDefaultTypeInternal;
|
|
extern LayerQuantizeParams_ConvolutionInfoDefaultTypeInternal _LayerQuantizeParams_ConvolutionInfo_default_instance_;
|
|
class LayerQuantizeParams_WeightParams;
|
|
struct LayerQuantizeParams_WeightParamsDefaultTypeInternal;
|
|
extern LayerQuantizeParams_WeightParamsDefaultTypeInternal _LayerQuantizeParams_WeightParams_default_instance_;
|
|
class LayerQuantizeParams_WinogradParams;
|
|
struct LayerQuantizeParams_WinogradParamsDefaultTypeInternal;
|
|
extern LayerQuantizeParams_WinogradParamsDefaultTypeInternal _LayerQuantizeParams_WinogradParams_default_instance_;
|
|
class LevelPrunerParams;
|
|
struct LevelPrunerParamsDefaultTypeInternal;
|
|
extern LevelPrunerParamsDefaultTypeInternal _LevelPrunerParams_default_instance_;
|
|
class Pipeline;
|
|
struct PipelineDefaultTypeInternal;
|
|
extern PipelineDefaultTypeInternal _Pipeline_default_instance_;
|
|
class PruneParams;
|
|
struct PruneParamsDefaultTypeInternal;
|
|
extern PruneParamsDefaultTypeInternal _PruneParams_default_instance_;
|
|
class QuantizeParams;
|
|
struct QuantizeParamsDefaultTypeInternal;
|
|
extern QuantizeParamsDefaultTypeInternal _QuantizeParams_default_instance_;
|
|
class SIMDOCPrunerParams;
|
|
struct SIMDOCPrunerParamsDefaultTypeInternal;
|
|
extern SIMDOCPrunerParamsDefaultTypeInternal _SIMDOCPrunerParams_default_instance_;
|
|
} // namespace Compression
|
|
} // namespace MNN
|
|
PROTOBUF_NAMESPACE_OPEN
|
|
template<> ::MNN::Compression::CompressionAlgo* Arena::CreateMaybeMessage<::MNN::Compression::CompressionAlgo>(Arena*);
|
|
template<> ::MNN::Compression::LayerQuantizeParams* Arena::CreateMaybeMessage<::MNN::Compression::LayerQuantizeParams>(Arena*);
|
|
template<> ::MNN::Compression::LayerQuantizeParams_ActivationParams* Arena::CreateMaybeMessage<::MNN::Compression::LayerQuantizeParams_ActivationParams>(Arena*);
|
|
template<> ::MNN::Compression::LayerQuantizeParams_ConvolutionInfo* Arena::CreateMaybeMessage<::MNN::Compression::LayerQuantizeParams_ConvolutionInfo>(Arena*);
|
|
template<> ::MNN::Compression::LayerQuantizeParams_WeightParams* Arena::CreateMaybeMessage<::MNN::Compression::LayerQuantizeParams_WeightParams>(Arena*);
|
|
template<> ::MNN::Compression::LayerQuantizeParams_WinogradParams* Arena::CreateMaybeMessage<::MNN::Compression::LayerQuantizeParams_WinogradParams>(Arena*);
|
|
template<> ::MNN::Compression::LevelPrunerParams* Arena::CreateMaybeMessage<::MNN::Compression::LevelPrunerParams>(Arena*);
|
|
template<> ::MNN::Compression::Pipeline* Arena::CreateMaybeMessage<::MNN::Compression::Pipeline>(Arena*);
|
|
template<> ::MNN::Compression::PruneParams* Arena::CreateMaybeMessage<::MNN::Compression::PruneParams>(Arena*);
|
|
template<> ::MNN::Compression::QuantizeParams* Arena::CreateMaybeMessage<::MNN::Compression::QuantizeParams>(Arena*);
|
|
template<> ::MNN::Compression::SIMDOCPrunerParams* Arena::CreateMaybeMessage<::MNN::Compression::SIMDOCPrunerParams>(Arena*);
|
|
PROTOBUF_NAMESPACE_CLOSE
|
|
namespace MNN {
|
|
namespace Compression {
|
|
|
|
enum QuantizeParams_RoundMode : int {
|
|
QuantizeParams_RoundMode_ROUND_TOWARDS_ZERO = 0,
|
|
QuantizeParams_RoundMode_ROUND_AWAY_FROM_ZERO = 1,
|
|
QuantizeParams_RoundMode_ROUND_HALF_TO_EVEN = 2
|
|
};
|
|
bool QuantizeParams_RoundMode_IsValid(int value);
|
|
constexpr QuantizeParams_RoundMode QuantizeParams_RoundMode_RoundMode_MIN = QuantizeParams_RoundMode_ROUND_TOWARDS_ZERO;
|
|
constexpr QuantizeParams_RoundMode QuantizeParams_RoundMode_RoundMode_MAX = QuantizeParams_RoundMode_ROUND_HALF_TO_EVEN;
|
|
constexpr int QuantizeParams_RoundMode_RoundMode_ARRAYSIZE = QuantizeParams_RoundMode_RoundMode_MAX + 1;
|
|
|
|
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* QuantizeParams_RoundMode_descriptor();
|
|
template<typename T>
|
|
inline const std::string& QuantizeParams_RoundMode_Name(T enum_t_value) {
|
|
static_assert(::std::is_same<T, QuantizeParams_RoundMode>::value ||
|
|
::std::is_integral<T>::value,
|
|
"Incorrect type passed to function QuantizeParams_RoundMode_Name.");
|
|
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
|
|
QuantizeParams_RoundMode_descriptor(), enum_t_value);
|
|
}
|
|
inline bool QuantizeParams_RoundMode_Parse(
|
|
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, QuantizeParams_RoundMode* value) {
|
|
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<QuantizeParams_RoundMode>(
|
|
QuantizeParams_RoundMode_descriptor(), name, value);
|
|
}
|
|
enum LayerQuantizeParams_QuantMethod : int {
|
|
LayerQuantizeParams_QuantMethod_QAT = 0,
|
|
LayerQuantizeParams_QuantMethod_OverflowAware = 1,
|
|
LayerQuantizeParams_QuantMethod_WinogradAware = 2
|
|
};
|
|
bool LayerQuantizeParams_QuantMethod_IsValid(int value);
|
|
constexpr LayerQuantizeParams_QuantMethod LayerQuantizeParams_QuantMethod_QuantMethod_MIN = LayerQuantizeParams_QuantMethod_QAT;
|
|
constexpr LayerQuantizeParams_QuantMethod LayerQuantizeParams_QuantMethod_QuantMethod_MAX = LayerQuantizeParams_QuantMethod_WinogradAware;
|
|
constexpr int LayerQuantizeParams_QuantMethod_QuantMethod_ARRAYSIZE = LayerQuantizeParams_QuantMethod_QuantMethod_MAX + 1;
|
|
|
|
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* LayerQuantizeParams_QuantMethod_descriptor();
|
|
template<typename T>
|
|
inline const std::string& LayerQuantizeParams_QuantMethod_Name(T enum_t_value) {
|
|
static_assert(::std::is_same<T, LayerQuantizeParams_QuantMethod>::value ||
|
|
::std::is_integral<T>::value,
|
|
"Incorrect type passed to function LayerQuantizeParams_QuantMethod_Name.");
|
|
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
|
|
LayerQuantizeParams_QuantMethod_descriptor(), enum_t_value);
|
|
}
|
|
inline bool LayerQuantizeParams_QuantMethod_Parse(
|
|
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LayerQuantizeParams_QuantMethod* value) {
|
|
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<LayerQuantizeParams_QuantMethod>(
|
|
LayerQuantizeParams_QuantMethod_descriptor(), name, value);
|
|
}
|
|
enum PruneParams_PruneType : int {
|
|
PruneParams_PruneType_RANDOM = 0,
|
|
PruneParams_PruneType_SIMD_OC = 1,
|
|
PruneParams_PruneType_FILTER = 2
|
|
};
|
|
bool PruneParams_PruneType_IsValid(int value);
|
|
constexpr PruneParams_PruneType PruneParams_PruneType_PruneType_MIN = PruneParams_PruneType_RANDOM;
|
|
constexpr PruneParams_PruneType PruneParams_PruneType_PruneType_MAX = PruneParams_PruneType_FILTER;
|
|
constexpr int PruneParams_PruneType_PruneType_ARRAYSIZE = PruneParams_PruneType_PruneType_MAX + 1;
|
|
|
|
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PruneParams_PruneType_descriptor();
|
|
template<typename T>
|
|
inline const std::string& PruneParams_PruneType_Name(T enum_t_value) {
|
|
static_assert(::std::is_same<T, PruneParams_PruneType>::value ||
|
|
::std::is_integral<T>::value,
|
|
"Incorrect type passed to function PruneParams_PruneType_Name.");
|
|
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
|
|
PruneParams_PruneType_descriptor(), enum_t_value);
|
|
}
|
|
inline bool PruneParams_PruneType_Parse(
|
|
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PruneParams_PruneType* value) {
|
|
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<PruneParams_PruneType>(
|
|
PruneParams_PruneType_descriptor(), name, value);
|
|
}
|
|
enum CompressionAlgo_CompressionType : int {
|
|
CompressionAlgo_CompressionType_QUANTIZE = 0,
|
|
CompressionAlgo_CompressionType_PRUNE = 1
|
|
};
|
|
bool CompressionAlgo_CompressionType_IsValid(int value);
|
|
constexpr CompressionAlgo_CompressionType CompressionAlgo_CompressionType_CompressionType_MIN = CompressionAlgo_CompressionType_QUANTIZE;
|
|
constexpr CompressionAlgo_CompressionType CompressionAlgo_CompressionType_CompressionType_MAX = CompressionAlgo_CompressionType_PRUNE;
|
|
constexpr int CompressionAlgo_CompressionType_CompressionType_ARRAYSIZE = CompressionAlgo_CompressionType_CompressionType_MAX + 1;
|
|
|
|
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CompressionAlgo_CompressionType_descriptor();
|
|
template<typename T>
|
|
inline const std::string& CompressionAlgo_CompressionType_Name(T enum_t_value) {
|
|
static_assert(::std::is_same<T, CompressionAlgo_CompressionType>::value ||
|
|
::std::is_integral<T>::value,
|
|
"Incorrect type passed to function CompressionAlgo_CompressionType_Name.");
|
|
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
|
|
CompressionAlgo_CompressionType_descriptor(), enum_t_value);
|
|
}
|
|
inline bool CompressionAlgo_CompressionType_Parse(
|
|
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CompressionAlgo_CompressionType* value) {
|
|
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<CompressionAlgo_CompressionType>(
|
|
CompressionAlgo_CompressionType_descriptor(), name, value);
|
|
}
|
|
// ===================================================================
|
|
|
|
class QuantizeParams final :
|
|
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MNN.Compression.QuantizeParams) */ {
|
|
public:
|
|
inline QuantizeParams() : QuantizeParams(nullptr) {}
|
|
~QuantizeParams() override;
|
|
explicit constexpr QuantizeParams(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
|
|
|
|
QuantizeParams(const QuantizeParams& from);
|
|
QuantizeParams(QuantizeParams&& from) noexcept
|
|
: QuantizeParams() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline QuantizeParams& operator=(const QuantizeParams& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline QuantizeParams& operator=(QuantizeParams&& 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;
|
|
}
|
|
|
|
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
|
|
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
|
|
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
|
|
}
|
|
|
|
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 QuantizeParams& default_instance() {
|
|
return *internal_default_instance();
|
|
}
|
|
static inline const QuantizeParams* internal_default_instance() {
|
|
return reinterpret_cast<const QuantizeParams*>(
|
|
&_QuantizeParams_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
0;
|
|
|
|
friend void swap(QuantizeParams& a, QuantizeParams& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(QuantizeParams* 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(QuantizeParams* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
QuantizeParams* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
|
|
return CreateMaybeMessage<QuantizeParams>(arena);
|
|
}
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
|
|
void CopyFrom(const QuantizeParams& from);
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
|
|
void MergeFrom(const QuantizeParams& from);
|
|
private:
|
|
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
|
|
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 _cached_size_.Get(); }
|
|
|
|
private:
|
|
void SharedCtor();
|
|
void SharedDtor();
|
|
void SetCachedSize(int size) const final;
|
|
void InternalSwap(QuantizeParams* other);
|
|
|
|
private:
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "MNN.Compression.QuantizeParams";
|
|
}
|
|
protected:
|
|
explicit QuantizeParams(::PROTOBUF_NAMESPACE_ID::Arena* arena,
|
|
bool is_message_owned = false);
|
|
private:
|
|
static void ArenaDtor(void* object);
|
|
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
|
|
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 QuantizeParams_RoundMode RoundMode;
|
|
static constexpr RoundMode ROUND_TOWARDS_ZERO =
|
|
QuantizeParams_RoundMode_ROUND_TOWARDS_ZERO;
|
|
static constexpr RoundMode ROUND_AWAY_FROM_ZERO =
|
|
QuantizeParams_RoundMode_ROUND_AWAY_FROM_ZERO;
|
|
static constexpr RoundMode ROUND_HALF_TO_EVEN =
|
|
QuantizeParams_RoundMode_ROUND_HALF_TO_EVEN;
|
|
static inline bool RoundMode_IsValid(int value) {
|
|
return QuantizeParams_RoundMode_IsValid(value);
|
|
}
|
|
static constexpr RoundMode RoundMode_MIN =
|
|
QuantizeParams_RoundMode_RoundMode_MIN;
|
|
static constexpr RoundMode RoundMode_MAX =
|
|
QuantizeParams_RoundMode_RoundMode_MAX;
|
|
static constexpr int RoundMode_ARRAYSIZE =
|
|
QuantizeParams_RoundMode_RoundMode_ARRAYSIZE;
|
|
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
|
|
RoundMode_descriptor() {
|
|
return QuantizeParams_RoundMode_descriptor();
|
|
}
|
|
template<typename T>
|
|
static inline const std::string& RoundMode_Name(T enum_t_value) {
|
|
static_assert(::std::is_same<T, RoundMode>::value ||
|
|
::std::is_integral<T>::value,
|
|
"Incorrect type passed to function RoundMode_Name.");
|
|
return QuantizeParams_RoundMode_Name(enum_t_value);
|
|
}
|
|
static inline bool RoundMode_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
|
|
RoundMode* value) {
|
|
return QuantizeParams_RoundMode_Parse(name, value);
|
|
}
|
|
|
|
// accessors -------------------------------------------------------
|
|
|
|
enum : int {
|
|
kLayerFieldNumber = 4,
|
|
kRoundModeFieldNumber = 1,
|
|
};
|
|
// repeated .MNN.Compression.LayerQuantizeParams layer = 4;
|
|
int layer_size() const;
|
|
private:
|
|
int _internal_layer_size() const;
|
|
public:
|
|
void clear_layer();
|
|
::MNN::Compression::LayerQuantizeParams* mutable_layer(int index);
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MNN::Compression::LayerQuantizeParams >*
|
|
mutable_layer();
|
|
private:
|
|
const ::MNN::Compression::LayerQuantizeParams& _internal_layer(int index) const;
|
|
::MNN::Compression::LayerQuantizeParams* _internal_add_layer();
|
|
public:
|
|
const ::MNN::Compression::LayerQuantizeParams& layer(int index) const;
|
|
::MNN::Compression::LayerQuantizeParams* add_layer();
|
|
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MNN::Compression::LayerQuantizeParams >&
|
|
layer() const;
|
|
|
|
// optional .MNN.Compression.QuantizeParams.RoundMode round_mode = 1 [default = ROUND_AWAY_FROM_ZERO];
|
|
bool has_round_mode() const;
|
|
private:
|
|
bool _internal_has_round_mode() const;
|
|
public:
|
|
void clear_round_mode();
|
|
::MNN::Compression::QuantizeParams_RoundMode round_mode() const;
|
|
void set_round_mode(::MNN::Compression::QuantizeParams_RoundMode value);
|
|
private:
|
|
::MNN::Compression::QuantizeParams_RoundMode _internal_round_mode() const;
|
|
void _internal_set_round_mode(::MNN::Compression::QuantizeParams_RoundMode value);
|
|
public:
|
|
|
|
// @@protoc_insertion_point(class_scope:MNN.Compression.QuantizeParams)
|
|
private:
|
|
class _Internal;
|
|
|
|
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
|
|
typedef void InternalArenaConstructable_;
|
|
typedef void DestructorSkippable_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
|
|
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MNN::Compression::LayerQuantizeParams > layer_;
|
|
int round_mode_;
|
|
friend struct ::TableStruct_MNN_5fcompression_2eproto;
|
|
};
|
|
// -------------------------------------------------------------------
|
|
|
|
class LayerQuantizeParams_ActivationParams final :
|
|
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MNN.Compression.LayerQuantizeParams.ActivationParams) */ {
|
|
public:
|
|
inline LayerQuantizeParams_ActivationParams() : LayerQuantizeParams_ActivationParams(nullptr) {}
|
|
~LayerQuantizeParams_ActivationParams() override;
|
|
explicit constexpr LayerQuantizeParams_ActivationParams(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
|
|
|
|
LayerQuantizeParams_ActivationParams(const LayerQuantizeParams_ActivationParams& from);
|
|
LayerQuantizeParams_ActivationParams(LayerQuantizeParams_ActivationParams&& from) noexcept
|
|
: LayerQuantizeParams_ActivationParams() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline LayerQuantizeParams_ActivationParams& operator=(const LayerQuantizeParams_ActivationParams& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline LayerQuantizeParams_ActivationParams& operator=(LayerQuantizeParams_ActivationParams&& 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;
|
|
}
|
|
|
|
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
|
|
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
|
|
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
|
|
}
|
|
|
|
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 LayerQuantizeParams_ActivationParams& default_instance() {
|
|
return *internal_default_instance();
|
|
}
|
|
static inline const LayerQuantizeParams_ActivationParams* internal_default_instance() {
|
|
return reinterpret_cast<const LayerQuantizeParams_ActivationParams*>(
|
|
&_LayerQuantizeParams_ActivationParams_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
1;
|
|
|
|
friend void swap(LayerQuantizeParams_ActivationParams& a, LayerQuantizeParams_ActivationParams& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(LayerQuantizeParams_ActivationParams* 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(LayerQuantizeParams_ActivationParams* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
LayerQuantizeParams_ActivationParams* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
|
|
return CreateMaybeMessage<LayerQuantizeParams_ActivationParams>(arena);
|
|
}
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
|
|
void CopyFrom(const LayerQuantizeParams_ActivationParams& from);
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
|
|
void MergeFrom(const LayerQuantizeParams_ActivationParams& from);
|
|
private:
|
|
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
|
|
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 _cached_size_.Get(); }
|
|
|
|
private:
|
|
void SharedCtor();
|
|
void SharedDtor();
|
|
void SetCachedSize(int size) const final;
|
|
void InternalSwap(LayerQuantizeParams_ActivationParams* other);
|
|
|
|
private:
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "MNN.Compression.LayerQuantizeParams.ActivationParams";
|
|
}
|
|
protected:
|
|
explicit LayerQuantizeParams_ActivationParams(::PROTOBUF_NAMESPACE_ID::Arena* arena,
|
|
bool is_message_owned = false);
|
|
private:
|
|
static void ArenaDtor(void* object);
|
|
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
|
|
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 {
|
|
kScalesFieldNumber = 3,
|
|
kNameFieldNumber = 1,
|
|
kZeroPointFieldNumber = 4,
|
|
kClampMaxFieldNumber = 6,
|
|
kBitsFieldNumber = 2,
|
|
kClampMinFieldNumber = 5,
|
|
};
|
|
// repeated float scales = 3;
|
|
int scales_size() const;
|
|
private:
|
|
int _internal_scales_size() const;
|
|
public:
|
|
void clear_scales();
|
|
private:
|
|
float _internal_scales(int index) const;
|
|
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
|
|
_internal_scales() const;
|
|
void _internal_add_scales(float value);
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
|
|
_internal_mutable_scales();
|
|
public:
|
|
float scales(int index) const;
|
|
void set_scales(int index, float value);
|
|
void add_scales(float value);
|
|
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
|
|
scales() const;
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
|
|
mutable_scales();
|
|
|
|
// required string name = 1;
|
|
bool has_name() const;
|
|
private:
|
|
bool _internal_has_name() const;
|
|
public:
|
|
void clear_name();
|
|
const std::string& name() const;
|
|
template <typename ArgT0 = const std::string&, typename... ArgT>
|
|
void set_name(ArgT0&& arg0, ArgT... args);
|
|
std::string* mutable_name();
|
|
PROTOBUF_NODISCARD std::string* release_name();
|
|
void set_allocated_name(std::string* name);
|
|
private:
|
|
const std::string& _internal_name() const;
|
|
inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
|
|
std::string* _internal_mutable_name();
|
|
public:
|
|
|
|
// optional int32 zero_point = 4 [default = 0];
|
|
bool has_zero_point() const;
|
|
private:
|
|
bool _internal_has_zero_point() const;
|
|
public:
|
|
void clear_zero_point();
|
|
int32_t zero_point() const;
|
|
void set_zero_point(int32_t value);
|
|
private:
|
|
int32_t _internal_zero_point() const;
|
|
void _internal_set_zero_point(int32_t value);
|
|
public:
|
|
|
|
// optional int32 clamp_max = 6 [default = 127];
|
|
bool has_clamp_max() const;
|
|
private:
|
|
bool _internal_has_clamp_max() const;
|
|
public:
|
|
void clear_clamp_max();
|
|
int32_t clamp_max() const;
|
|
void set_clamp_max(int32_t value);
|
|
private:
|
|
int32_t _internal_clamp_max() const;
|
|
void _internal_set_clamp_max(int32_t value);
|
|
public:
|
|
|
|
// optional int32 bits = 2 [default = 8];
|
|
bool has_bits() const;
|
|
private:
|
|
bool _internal_has_bits() const;
|
|
public:
|
|
void clear_bits();
|
|
int32_t bits() const;
|
|
void set_bits(int32_t value);
|
|
private:
|
|
int32_t _internal_bits() const;
|
|
void _internal_set_bits(int32_t value);
|
|
public:
|
|
|
|
// optional int32 clamp_min = 5 [default = -128];
|
|
bool has_clamp_min() const;
|
|
private:
|
|
bool _internal_has_clamp_min() const;
|
|
public:
|
|
void clear_clamp_min();
|
|
int32_t clamp_min() const;
|
|
void set_clamp_min(int32_t value);
|
|
private:
|
|
int32_t _internal_clamp_min() const;
|
|
void _internal_set_clamp_min(int32_t value);
|
|
public:
|
|
|
|
// @@protoc_insertion_point(class_scope:MNN.Compression.LayerQuantizeParams.ActivationParams)
|
|
private:
|
|
class _Internal;
|
|
|
|
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
|
|
typedef void InternalArenaConstructable_;
|
|
typedef void DestructorSkippable_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
|
|
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedField< float > scales_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
|
|
int32_t zero_point_;
|
|
int32_t clamp_max_;
|
|
int32_t bits_;
|
|
int32_t clamp_min_;
|
|
friend struct ::TableStruct_MNN_5fcompression_2eproto;
|
|
};
|
|
// -------------------------------------------------------------------
|
|
|
|
class LayerQuantizeParams_WeightParams final :
|
|
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MNN.Compression.LayerQuantizeParams.WeightParams) */ {
|
|
public:
|
|
inline LayerQuantizeParams_WeightParams() : LayerQuantizeParams_WeightParams(nullptr) {}
|
|
~LayerQuantizeParams_WeightParams() override;
|
|
explicit constexpr LayerQuantizeParams_WeightParams(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
|
|
|
|
LayerQuantizeParams_WeightParams(const LayerQuantizeParams_WeightParams& from);
|
|
LayerQuantizeParams_WeightParams(LayerQuantizeParams_WeightParams&& from) noexcept
|
|
: LayerQuantizeParams_WeightParams() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline LayerQuantizeParams_WeightParams& operator=(const LayerQuantizeParams_WeightParams& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline LayerQuantizeParams_WeightParams& operator=(LayerQuantizeParams_WeightParams&& 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;
|
|
}
|
|
|
|
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
|
|
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
|
|
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
|
|
}
|
|
|
|
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 LayerQuantizeParams_WeightParams& default_instance() {
|
|
return *internal_default_instance();
|
|
}
|
|
static inline const LayerQuantizeParams_WeightParams* internal_default_instance() {
|
|
return reinterpret_cast<const LayerQuantizeParams_WeightParams*>(
|
|
&_LayerQuantizeParams_WeightParams_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
2;
|
|
|
|
friend void swap(LayerQuantizeParams_WeightParams& a, LayerQuantizeParams_WeightParams& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(LayerQuantizeParams_WeightParams* 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(LayerQuantizeParams_WeightParams* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
LayerQuantizeParams_WeightParams* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
|
|
return CreateMaybeMessage<LayerQuantizeParams_WeightParams>(arena);
|
|
}
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
|
|
void CopyFrom(const LayerQuantizeParams_WeightParams& from);
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
|
|
void MergeFrom(const LayerQuantizeParams_WeightParams& from);
|
|
private:
|
|
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
|
|
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 _cached_size_.Get(); }
|
|
|
|
private:
|
|
void SharedCtor();
|
|
void SharedDtor();
|
|
void SetCachedSize(int size) const final;
|
|
void InternalSwap(LayerQuantizeParams_WeightParams* other);
|
|
|
|
private:
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "MNN.Compression.LayerQuantizeParams.WeightParams";
|
|
}
|
|
protected:
|
|
explicit LayerQuantizeParams_WeightParams(::PROTOBUF_NAMESPACE_ID::Arena* arena,
|
|
bool is_message_owned = false);
|
|
private:
|
|
static void ArenaDtor(void* object);
|
|
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
|
|
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 {
|
|
kScalesFieldNumber = 3,
|
|
kNameFieldNumber = 1,
|
|
kAsymmetricFieldNumber = 6,
|
|
kBlockSizeFieldNumber = 7,
|
|
kClampMaxFieldNumber = 5,
|
|
kBitsFieldNumber = 2,
|
|
kClampMinFieldNumber = 4,
|
|
};
|
|
// repeated float scales = 3;
|
|
int scales_size() const;
|
|
private:
|
|
int _internal_scales_size() const;
|
|
public:
|
|
void clear_scales();
|
|
private:
|
|
float _internal_scales(int index) const;
|
|
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
|
|
_internal_scales() const;
|
|
void _internal_add_scales(float value);
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
|
|
_internal_mutable_scales();
|
|
public:
|
|
float scales(int index) const;
|
|
void set_scales(int index, float value);
|
|
void add_scales(float value);
|
|
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
|
|
scales() const;
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
|
|
mutable_scales();
|
|
|
|
// required string name = 1;
|
|
bool has_name() const;
|
|
private:
|
|
bool _internal_has_name() const;
|
|
public:
|
|
void clear_name();
|
|
const std::string& name() const;
|
|
template <typename ArgT0 = const std::string&, typename... ArgT>
|
|
void set_name(ArgT0&& arg0, ArgT... args);
|
|
std::string* mutable_name();
|
|
PROTOBUF_NODISCARD std::string* release_name();
|
|
void set_allocated_name(std::string* name);
|
|
private:
|
|
const std::string& _internal_name() const;
|
|
inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
|
|
std::string* _internal_mutable_name();
|
|
public:
|
|
|
|
// optional bool asymmetric = 6 [default = false];
|
|
bool has_asymmetric() const;
|
|
private:
|
|
bool _internal_has_asymmetric() const;
|
|
public:
|
|
void clear_asymmetric();
|
|
bool asymmetric() const;
|
|
void set_asymmetric(bool value);
|
|
private:
|
|
bool _internal_asymmetric() const;
|
|
void _internal_set_asymmetric(bool value);
|
|
public:
|
|
|
|
// optional int32 block_size = 7 [default = 0];
|
|
bool has_block_size() const;
|
|
private:
|
|
bool _internal_has_block_size() const;
|
|
public:
|
|
void clear_block_size();
|
|
int32_t block_size() const;
|
|
void set_block_size(int32_t value);
|
|
private:
|
|
int32_t _internal_block_size() const;
|
|
void _internal_set_block_size(int32_t value);
|
|
public:
|
|
|
|
// optional int32 clamp_max = 5 [default = 127];
|
|
bool has_clamp_max() const;
|
|
private:
|
|
bool _internal_has_clamp_max() const;
|
|
public:
|
|
void clear_clamp_max();
|
|
int32_t clamp_max() const;
|
|
void set_clamp_max(int32_t value);
|
|
private:
|
|
int32_t _internal_clamp_max() const;
|
|
void _internal_set_clamp_max(int32_t value);
|
|
public:
|
|
|
|
// optional int32 bits = 2 [default = 8];
|
|
bool has_bits() const;
|
|
private:
|
|
bool _internal_has_bits() const;
|
|
public:
|
|
void clear_bits();
|
|
int32_t bits() const;
|
|
void set_bits(int32_t value);
|
|
private:
|
|
int32_t _internal_bits() const;
|
|
void _internal_set_bits(int32_t value);
|
|
public:
|
|
|
|
// optional int32 clamp_min = 4 [default = -128];
|
|
bool has_clamp_min() const;
|
|
private:
|
|
bool _internal_has_clamp_min() const;
|
|
public:
|
|
void clear_clamp_min();
|
|
int32_t clamp_min() const;
|
|
void set_clamp_min(int32_t value);
|
|
private:
|
|
int32_t _internal_clamp_min() const;
|
|
void _internal_set_clamp_min(int32_t value);
|
|
public:
|
|
|
|
// @@protoc_insertion_point(class_scope:MNN.Compression.LayerQuantizeParams.WeightParams)
|
|
private:
|
|
class _Internal;
|
|
|
|
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
|
|
typedef void InternalArenaConstructable_;
|
|
typedef void DestructorSkippable_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
|
|
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedField< float > scales_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
|
|
bool asymmetric_;
|
|
int32_t block_size_;
|
|
int32_t clamp_max_;
|
|
int32_t bits_;
|
|
int32_t clamp_min_;
|
|
friend struct ::TableStruct_MNN_5fcompression_2eproto;
|
|
};
|
|
// -------------------------------------------------------------------
|
|
|
|
class LayerQuantizeParams_WinogradParams final :
|
|
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MNN.Compression.LayerQuantizeParams.WinogradParams) */ {
|
|
public:
|
|
inline LayerQuantizeParams_WinogradParams() : LayerQuantizeParams_WinogradParams(nullptr) {}
|
|
~LayerQuantizeParams_WinogradParams() override;
|
|
explicit constexpr LayerQuantizeParams_WinogradParams(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
|
|
|
|
LayerQuantizeParams_WinogradParams(const LayerQuantizeParams_WinogradParams& from);
|
|
LayerQuantizeParams_WinogradParams(LayerQuantizeParams_WinogradParams&& from) noexcept
|
|
: LayerQuantizeParams_WinogradParams() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline LayerQuantizeParams_WinogradParams& operator=(const LayerQuantizeParams_WinogradParams& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline LayerQuantizeParams_WinogradParams& operator=(LayerQuantizeParams_WinogradParams&& 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;
|
|
}
|
|
|
|
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
|
|
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
|
|
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
|
|
}
|
|
|
|
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 LayerQuantizeParams_WinogradParams& default_instance() {
|
|
return *internal_default_instance();
|
|
}
|
|
static inline const LayerQuantizeParams_WinogradParams* internal_default_instance() {
|
|
return reinterpret_cast<const LayerQuantizeParams_WinogradParams*>(
|
|
&_LayerQuantizeParams_WinogradParams_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
3;
|
|
|
|
friend void swap(LayerQuantizeParams_WinogradParams& a, LayerQuantizeParams_WinogradParams& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(LayerQuantizeParams_WinogradParams* 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(LayerQuantizeParams_WinogradParams* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
LayerQuantizeParams_WinogradParams* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
|
|
return CreateMaybeMessage<LayerQuantizeParams_WinogradParams>(arena);
|
|
}
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
|
|
void CopyFrom(const LayerQuantizeParams_WinogradParams& from);
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
|
|
void MergeFrom(const LayerQuantizeParams_WinogradParams& from);
|
|
private:
|
|
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
|
|
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 _cached_size_.Get(); }
|
|
|
|
private:
|
|
void SharedCtor();
|
|
void SharedDtor();
|
|
void SetCachedSize(int size) const final;
|
|
void InternalSwap(LayerQuantizeParams_WinogradParams* other);
|
|
|
|
private:
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "MNN.Compression.LayerQuantizeParams.WinogradParams";
|
|
}
|
|
protected:
|
|
explicit LayerQuantizeParams_WinogradParams(::PROTOBUF_NAMESPACE_ID::Arena* arena,
|
|
bool is_message_owned = false);
|
|
private:
|
|
static void ArenaDtor(void* object);
|
|
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
|
|
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 {
|
|
kUnitsAttrFieldNumber = 4,
|
|
kVersionFieldNumber = 1,
|
|
};
|
|
// repeated int32 units_attr = 4;
|
|
int units_attr_size() const;
|
|
private:
|
|
int _internal_units_attr_size() const;
|
|
public:
|
|
void clear_units_attr();
|
|
private:
|
|
int32_t _internal_units_attr(int index) const;
|
|
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
|
|
_internal_units_attr() const;
|
|
void _internal_add_units_attr(int32_t value);
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
|
|
_internal_mutable_units_attr();
|
|
public:
|
|
int32_t units_attr(int index) const;
|
|
void set_units_attr(int index, int32_t value);
|
|
void add_units_attr(int32_t value);
|
|
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
|
|
units_attr() const;
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
|
|
mutable_units_attr();
|
|
|
|
// required int32 version = 1 [default = 0];
|
|
bool has_version() const;
|
|
private:
|
|
bool _internal_has_version() const;
|
|
public:
|
|
void clear_version();
|
|
int32_t version() const;
|
|
void set_version(int32_t value);
|
|
private:
|
|
int32_t _internal_version() const;
|
|
void _internal_set_version(int32_t value);
|
|
public:
|
|
|
|
// @@protoc_insertion_point(class_scope:MNN.Compression.LayerQuantizeParams.WinogradParams)
|
|
private:
|
|
class _Internal;
|
|
|
|
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
|
|
typedef void InternalArenaConstructable_;
|
|
typedef void DestructorSkippable_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
|
|
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > units_attr_;
|
|
int32_t version_;
|
|
friend struct ::TableStruct_MNN_5fcompression_2eproto;
|
|
};
|
|
// -------------------------------------------------------------------
|
|
|
|
class LayerQuantizeParams_ConvolutionInfo final :
|
|
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MNN.Compression.LayerQuantizeParams.ConvolutionInfo) */ {
|
|
public:
|
|
inline LayerQuantizeParams_ConvolutionInfo() : LayerQuantizeParams_ConvolutionInfo(nullptr) {}
|
|
~LayerQuantizeParams_ConvolutionInfo() override;
|
|
explicit constexpr LayerQuantizeParams_ConvolutionInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
|
|
|
|
LayerQuantizeParams_ConvolutionInfo(const LayerQuantizeParams_ConvolutionInfo& from);
|
|
LayerQuantizeParams_ConvolutionInfo(LayerQuantizeParams_ConvolutionInfo&& from) noexcept
|
|
: LayerQuantizeParams_ConvolutionInfo() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline LayerQuantizeParams_ConvolutionInfo& operator=(const LayerQuantizeParams_ConvolutionInfo& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline LayerQuantizeParams_ConvolutionInfo& operator=(LayerQuantizeParams_ConvolutionInfo&& 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;
|
|
}
|
|
|
|
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
|
|
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
|
|
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
|
|
}
|
|
|
|
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 LayerQuantizeParams_ConvolutionInfo& default_instance() {
|
|
return *internal_default_instance();
|
|
}
|
|
static inline const LayerQuantizeParams_ConvolutionInfo* internal_default_instance() {
|
|
return reinterpret_cast<const LayerQuantizeParams_ConvolutionInfo*>(
|
|
&_LayerQuantizeParams_ConvolutionInfo_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
4;
|
|
|
|
friend void swap(LayerQuantizeParams_ConvolutionInfo& a, LayerQuantizeParams_ConvolutionInfo& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(LayerQuantizeParams_ConvolutionInfo* 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(LayerQuantizeParams_ConvolutionInfo* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
LayerQuantizeParams_ConvolutionInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
|
|
return CreateMaybeMessage<LayerQuantizeParams_ConvolutionInfo>(arena);
|
|
}
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
|
|
void CopyFrom(const LayerQuantizeParams_ConvolutionInfo& from);
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
|
|
void MergeFrom(const LayerQuantizeParams_ConvolutionInfo& from);
|
|
private:
|
|
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
|
|
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 _cached_size_.Get(); }
|
|
|
|
private:
|
|
void SharedCtor();
|
|
void SharedDtor();
|
|
void SetCachedSize(int size) const final;
|
|
void InternalSwap(LayerQuantizeParams_ConvolutionInfo* other);
|
|
|
|
private:
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "MNN.Compression.LayerQuantizeParams.ConvolutionInfo";
|
|
}
|
|
protected:
|
|
explicit LayerQuantizeParams_ConvolutionInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
|
|
bool is_message_owned = false);
|
|
private:
|
|
static void ArenaDtor(void* object);
|
|
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
|
|
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 {
|
|
kKernelSizeFieldNumber = 3,
|
|
kInputChannelFieldNumber = 1,
|
|
kOutputChannelFieldNumber = 2,
|
|
};
|
|
// repeated int32 kernel_size = 3;
|
|
int kernel_size_size() const;
|
|
private:
|
|
int _internal_kernel_size_size() const;
|
|
public:
|
|
void clear_kernel_size();
|
|
private:
|
|
int32_t _internal_kernel_size(int index) const;
|
|
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
|
|
_internal_kernel_size() const;
|
|
void _internal_add_kernel_size(int32_t value);
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
|
|
_internal_mutable_kernel_size();
|
|
public:
|
|
int32_t kernel_size(int index) const;
|
|
void set_kernel_size(int index, int32_t value);
|
|
void add_kernel_size(int32_t value);
|
|
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
|
|
kernel_size() const;
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
|
|
mutable_kernel_size();
|
|
|
|
// required int32 input_channel = 1;
|
|
bool has_input_channel() const;
|
|
private:
|
|
bool _internal_has_input_channel() const;
|
|
public:
|
|
void clear_input_channel();
|
|
int32_t input_channel() const;
|
|
void set_input_channel(int32_t value);
|
|
private:
|
|
int32_t _internal_input_channel() const;
|
|
void _internal_set_input_channel(int32_t value);
|
|
public:
|
|
|
|
// required int32 output_channel = 2;
|
|
bool has_output_channel() const;
|
|
private:
|
|
bool _internal_has_output_channel() const;
|
|
public:
|
|
void clear_output_channel();
|
|
int32_t output_channel() const;
|
|
void set_output_channel(int32_t value);
|
|
private:
|
|
int32_t _internal_output_channel() const;
|
|
void _internal_set_output_channel(int32_t value);
|
|
public:
|
|
|
|
// @@protoc_insertion_point(class_scope:MNN.Compression.LayerQuantizeParams.ConvolutionInfo)
|
|
private:
|
|
class _Internal;
|
|
|
|
// helper for ByteSizeLong()
|
|
size_t RequiredFieldsByteSizeFallback() const;
|
|
|
|
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
|
|
typedef void InternalArenaConstructable_;
|
|
typedef void DestructorSkippable_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
|
|
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > kernel_size_;
|
|
int32_t input_channel_;
|
|
int32_t output_channel_;
|
|
friend struct ::TableStruct_MNN_5fcompression_2eproto;
|
|
};
|
|
// -------------------------------------------------------------------
|
|
|
|
class LayerQuantizeParams final :
|
|
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MNN.Compression.LayerQuantizeParams) */ {
|
|
public:
|
|
inline LayerQuantizeParams() : LayerQuantizeParams(nullptr) {}
|
|
~LayerQuantizeParams() override;
|
|
explicit constexpr LayerQuantizeParams(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
|
|
|
|
LayerQuantizeParams(const LayerQuantizeParams& from);
|
|
LayerQuantizeParams(LayerQuantizeParams&& from) noexcept
|
|
: LayerQuantizeParams() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline LayerQuantizeParams& operator=(const LayerQuantizeParams& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline LayerQuantizeParams& operator=(LayerQuantizeParams&& 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;
|
|
}
|
|
|
|
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
|
|
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
|
|
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
|
|
}
|
|
|
|
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 LayerQuantizeParams& default_instance() {
|
|
return *internal_default_instance();
|
|
}
|
|
static inline const LayerQuantizeParams* internal_default_instance() {
|
|
return reinterpret_cast<const LayerQuantizeParams*>(
|
|
&_LayerQuantizeParams_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
5;
|
|
|
|
friend void swap(LayerQuantizeParams& a, LayerQuantizeParams& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(LayerQuantizeParams* 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(LayerQuantizeParams* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
LayerQuantizeParams* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
|
|
return CreateMaybeMessage<LayerQuantizeParams>(arena);
|
|
}
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
|
|
void CopyFrom(const LayerQuantizeParams& from);
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
|
|
void MergeFrom(const LayerQuantizeParams& from);
|
|
private:
|
|
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
|
|
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 _cached_size_.Get(); }
|
|
|
|
private:
|
|
void SharedCtor();
|
|
void SharedDtor();
|
|
void SetCachedSize(int size) const final;
|
|
void InternalSwap(LayerQuantizeParams* other);
|
|
|
|
private:
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "MNN.Compression.LayerQuantizeParams";
|
|
}
|
|
protected:
|
|
explicit LayerQuantizeParams(::PROTOBUF_NAMESPACE_ID::Arena* arena,
|
|
bool is_message_owned = false);
|
|
private:
|
|
static void ArenaDtor(void* object);
|
|
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
|
|
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 LayerQuantizeParams_ActivationParams ActivationParams;
|
|
typedef LayerQuantizeParams_WeightParams WeightParams;
|
|
typedef LayerQuantizeParams_WinogradParams WinogradParams;
|
|
typedef LayerQuantizeParams_ConvolutionInfo ConvolutionInfo;
|
|
|
|
typedef LayerQuantizeParams_QuantMethod QuantMethod;
|
|
static constexpr QuantMethod QAT =
|
|
LayerQuantizeParams_QuantMethod_QAT;
|
|
static constexpr QuantMethod OverflowAware =
|
|
LayerQuantizeParams_QuantMethod_OverflowAware;
|
|
static constexpr QuantMethod WinogradAware =
|
|
LayerQuantizeParams_QuantMethod_WinogradAware;
|
|
static inline bool QuantMethod_IsValid(int value) {
|
|
return LayerQuantizeParams_QuantMethod_IsValid(value);
|
|
}
|
|
static constexpr QuantMethod QuantMethod_MIN =
|
|
LayerQuantizeParams_QuantMethod_QuantMethod_MIN;
|
|
static constexpr QuantMethod QuantMethod_MAX =
|
|
LayerQuantizeParams_QuantMethod_QuantMethod_MAX;
|
|
static constexpr int QuantMethod_ARRAYSIZE =
|
|
LayerQuantizeParams_QuantMethod_QuantMethod_ARRAYSIZE;
|
|
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
|
|
QuantMethod_descriptor() {
|
|
return LayerQuantizeParams_QuantMethod_descriptor();
|
|
}
|
|
template<typename T>
|
|
static inline const std::string& QuantMethod_Name(T enum_t_value) {
|
|
static_assert(::std::is_same<T, QuantMethod>::value ||
|
|
::std::is_integral<T>::value,
|
|
"Incorrect type passed to function QuantMethod_Name.");
|
|
return LayerQuantizeParams_QuantMethod_Name(enum_t_value);
|
|
}
|
|
static inline bool QuantMethod_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
|
|
QuantMethod* value) {
|
|
return LayerQuantizeParams_QuantMethod_Parse(name, value);
|
|
}
|
|
|
|
// accessors -------------------------------------------------------
|
|
|
|
enum : int {
|
|
kInputFieldNumber = 1,
|
|
kWeightFieldNumber = 2,
|
|
kOutputFieldNumber = 3,
|
|
kOpNameFieldNumber = 6,
|
|
kSubgraphNameFieldNumber = 7,
|
|
kWinoParamsFieldNumber = 5,
|
|
kConvFieldNumber = 8,
|
|
kMethodFieldNumber = 4,
|
|
};
|
|
// repeated .MNN.Compression.LayerQuantizeParams.ActivationParams input = 1;
|
|
int input_size() const;
|
|
private:
|
|
int _internal_input_size() const;
|
|
public:
|
|
void clear_input();
|
|
::MNN::Compression::LayerQuantizeParams_ActivationParams* mutable_input(int index);
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MNN::Compression::LayerQuantizeParams_ActivationParams >*
|
|
mutable_input();
|
|
private:
|
|
const ::MNN::Compression::LayerQuantizeParams_ActivationParams& _internal_input(int index) const;
|
|
::MNN::Compression::LayerQuantizeParams_ActivationParams* _internal_add_input();
|
|
public:
|
|
const ::MNN::Compression::LayerQuantizeParams_ActivationParams& input(int index) const;
|
|
::MNN::Compression::LayerQuantizeParams_ActivationParams* add_input();
|
|
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MNN::Compression::LayerQuantizeParams_ActivationParams >&
|
|
input() const;
|
|
|
|
// repeated .MNN.Compression.LayerQuantizeParams.WeightParams weight = 2;
|
|
int weight_size() const;
|
|
private:
|
|
int _internal_weight_size() const;
|
|
public:
|
|
void clear_weight();
|
|
::MNN::Compression::LayerQuantizeParams_WeightParams* mutable_weight(int index);
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MNN::Compression::LayerQuantizeParams_WeightParams >*
|
|
mutable_weight();
|
|
private:
|
|
const ::MNN::Compression::LayerQuantizeParams_WeightParams& _internal_weight(int index) const;
|
|
::MNN::Compression::LayerQuantizeParams_WeightParams* _internal_add_weight();
|
|
public:
|
|
const ::MNN::Compression::LayerQuantizeParams_WeightParams& weight(int index) const;
|
|
::MNN::Compression::LayerQuantizeParams_WeightParams* add_weight();
|
|
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MNN::Compression::LayerQuantizeParams_WeightParams >&
|
|
weight() const;
|
|
|
|
// repeated .MNN.Compression.LayerQuantizeParams.ActivationParams output = 3;
|
|
int output_size() const;
|
|
private:
|
|
int _internal_output_size() const;
|
|
public:
|
|
void clear_output();
|
|
::MNN::Compression::LayerQuantizeParams_ActivationParams* mutable_output(int index);
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MNN::Compression::LayerQuantizeParams_ActivationParams >*
|
|
mutable_output();
|
|
private:
|
|
const ::MNN::Compression::LayerQuantizeParams_ActivationParams& _internal_output(int index) const;
|
|
::MNN::Compression::LayerQuantizeParams_ActivationParams* _internal_add_output();
|
|
public:
|
|
const ::MNN::Compression::LayerQuantizeParams_ActivationParams& output(int index) const;
|
|
::MNN::Compression::LayerQuantizeParams_ActivationParams* add_output();
|
|
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MNN::Compression::LayerQuantizeParams_ActivationParams >&
|
|
output() const;
|
|
|
|
// optional string op_name = 6;
|
|
bool has_op_name() const;
|
|
private:
|
|
bool _internal_has_op_name() const;
|
|
public:
|
|
void clear_op_name();
|
|
const std::string& op_name() const;
|
|
template <typename ArgT0 = const std::string&, typename... ArgT>
|
|
void set_op_name(ArgT0&& arg0, ArgT... args);
|
|
std::string* mutable_op_name();
|
|
PROTOBUF_NODISCARD std::string* release_op_name();
|
|
void set_allocated_op_name(std::string* op_name);
|
|
private:
|
|
const std::string& _internal_op_name() const;
|
|
inline PROTOBUF_ALWAYS_INLINE void _internal_set_op_name(const std::string& value);
|
|
std::string* _internal_mutable_op_name();
|
|
public:
|
|
|
|
// optional string subgraph_name = 7;
|
|
bool has_subgraph_name() const;
|
|
private:
|
|
bool _internal_has_subgraph_name() const;
|
|
public:
|
|
void clear_subgraph_name();
|
|
const std::string& subgraph_name() const;
|
|
template <typename ArgT0 = const std::string&, typename... ArgT>
|
|
void set_subgraph_name(ArgT0&& arg0, ArgT... args);
|
|
std::string* mutable_subgraph_name();
|
|
PROTOBUF_NODISCARD std::string* release_subgraph_name();
|
|
void set_allocated_subgraph_name(std::string* subgraph_name);
|
|
private:
|
|
const std::string& _internal_subgraph_name() const;
|
|
inline PROTOBUF_ALWAYS_INLINE void _internal_set_subgraph_name(const std::string& value);
|
|
std::string* _internal_mutable_subgraph_name();
|
|
public:
|
|
|
|
// optional .MNN.Compression.LayerQuantizeParams.WinogradParams wino_params = 5;
|
|
bool has_wino_params() const;
|
|
private:
|
|
bool _internal_has_wino_params() const;
|
|
public:
|
|
void clear_wino_params();
|
|
const ::MNN::Compression::LayerQuantizeParams_WinogradParams& wino_params() const;
|
|
PROTOBUF_NODISCARD ::MNN::Compression::LayerQuantizeParams_WinogradParams* release_wino_params();
|
|
::MNN::Compression::LayerQuantizeParams_WinogradParams* mutable_wino_params();
|
|
void set_allocated_wino_params(::MNN::Compression::LayerQuantizeParams_WinogradParams* wino_params);
|
|
private:
|
|
const ::MNN::Compression::LayerQuantizeParams_WinogradParams& _internal_wino_params() const;
|
|
::MNN::Compression::LayerQuantizeParams_WinogradParams* _internal_mutable_wino_params();
|
|
public:
|
|
void unsafe_arena_set_allocated_wino_params(
|
|
::MNN::Compression::LayerQuantizeParams_WinogradParams* wino_params);
|
|
::MNN::Compression::LayerQuantizeParams_WinogradParams* unsafe_arena_release_wino_params();
|
|
|
|
// optional .MNN.Compression.LayerQuantizeParams.ConvolutionInfo conv = 8;
|
|
bool has_conv() const;
|
|
private:
|
|
bool _internal_has_conv() const;
|
|
public:
|
|
void clear_conv();
|
|
const ::MNN::Compression::LayerQuantizeParams_ConvolutionInfo& conv() const;
|
|
PROTOBUF_NODISCARD ::MNN::Compression::LayerQuantizeParams_ConvolutionInfo* release_conv();
|
|
::MNN::Compression::LayerQuantizeParams_ConvolutionInfo* mutable_conv();
|
|
void set_allocated_conv(::MNN::Compression::LayerQuantizeParams_ConvolutionInfo* conv);
|
|
private:
|
|
const ::MNN::Compression::LayerQuantizeParams_ConvolutionInfo& _internal_conv() const;
|
|
::MNN::Compression::LayerQuantizeParams_ConvolutionInfo* _internal_mutable_conv();
|
|
public:
|
|
void unsafe_arena_set_allocated_conv(
|
|
::MNN::Compression::LayerQuantizeParams_ConvolutionInfo* conv);
|
|
::MNN::Compression::LayerQuantizeParams_ConvolutionInfo* unsafe_arena_release_conv();
|
|
|
|
// optional .MNN.Compression.LayerQuantizeParams.QuantMethod method = 4 [default = QAT];
|
|
bool has_method() const;
|
|
private:
|
|
bool _internal_has_method() const;
|
|
public:
|
|
void clear_method();
|
|
::MNN::Compression::LayerQuantizeParams_QuantMethod method() const;
|
|
void set_method(::MNN::Compression::LayerQuantizeParams_QuantMethod value);
|
|
private:
|
|
::MNN::Compression::LayerQuantizeParams_QuantMethod _internal_method() const;
|
|
void _internal_set_method(::MNN::Compression::LayerQuantizeParams_QuantMethod value);
|
|
public:
|
|
|
|
// @@protoc_insertion_point(class_scope:MNN.Compression.LayerQuantizeParams)
|
|
private:
|
|
class _Internal;
|
|
|
|
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
|
|
typedef void InternalArenaConstructable_;
|
|
typedef void DestructorSkippable_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
|
|
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MNN::Compression::LayerQuantizeParams_ActivationParams > input_;
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MNN::Compression::LayerQuantizeParams_WeightParams > weight_;
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MNN::Compression::LayerQuantizeParams_ActivationParams > output_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr op_name_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr subgraph_name_;
|
|
::MNN::Compression::LayerQuantizeParams_WinogradParams* wino_params_;
|
|
::MNN::Compression::LayerQuantizeParams_ConvolutionInfo* conv_;
|
|
int method_;
|
|
friend struct ::TableStruct_MNN_5fcompression_2eproto;
|
|
};
|
|
// -------------------------------------------------------------------
|
|
|
|
class LevelPrunerParams final :
|
|
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MNN.Compression.LevelPrunerParams) */ {
|
|
public:
|
|
inline LevelPrunerParams() : LevelPrunerParams(nullptr) {}
|
|
~LevelPrunerParams() override;
|
|
explicit constexpr LevelPrunerParams(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
|
|
|
|
LevelPrunerParams(const LevelPrunerParams& from);
|
|
LevelPrunerParams(LevelPrunerParams&& from) noexcept
|
|
: LevelPrunerParams() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline LevelPrunerParams& operator=(const LevelPrunerParams& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline LevelPrunerParams& operator=(LevelPrunerParams&& 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;
|
|
}
|
|
|
|
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
|
|
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
|
|
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
|
|
}
|
|
|
|
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 LevelPrunerParams& default_instance() {
|
|
return *internal_default_instance();
|
|
}
|
|
static inline const LevelPrunerParams* internal_default_instance() {
|
|
return reinterpret_cast<const LevelPrunerParams*>(
|
|
&_LevelPrunerParams_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
6;
|
|
|
|
friend void swap(LevelPrunerParams& a, LevelPrunerParams& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(LevelPrunerParams* 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(LevelPrunerParams* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
LevelPrunerParams* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
|
|
return CreateMaybeMessage<LevelPrunerParams>(arena);
|
|
}
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
|
|
void CopyFrom(const LevelPrunerParams& from);
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
|
|
void MergeFrom(const LevelPrunerParams& from);
|
|
private:
|
|
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
|
|
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 _cached_size_.Get(); }
|
|
|
|
private:
|
|
void SharedCtor();
|
|
void SharedDtor();
|
|
void SetCachedSize(int size) const final;
|
|
void InternalSwap(LevelPrunerParams* other);
|
|
|
|
private:
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "MNN.Compression.LevelPrunerParams";
|
|
}
|
|
protected:
|
|
explicit LevelPrunerParams(::PROTOBUF_NAMESPACE_ID::Arena* arena,
|
|
bool is_message_owned = false);
|
|
private:
|
|
static void ArenaDtor(void* object);
|
|
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
|
|
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 {
|
|
kWeightTensorNamesFieldNumber = 1,
|
|
kPruneRatiosFieldNumber = 2,
|
|
kLayerNamesFieldNumber = 3,
|
|
};
|
|
// repeated string weight_tensor_names = 1;
|
|
int weight_tensor_names_size() const;
|
|
private:
|
|
int _internal_weight_tensor_names_size() const;
|
|
public:
|
|
void clear_weight_tensor_names();
|
|
const std::string& weight_tensor_names(int index) const;
|
|
std::string* mutable_weight_tensor_names(int index);
|
|
void set_weight_tensor_names(int index, const std::string& value);
|
|
void set_weight_tensor_names(int index, std::string&& value);
|
|
void set_weight_tensor_names(int index, const char* value);
|
|
void set_weight_tensor_names(int index, const char* value, size_t size);
|
|
std::string* add_weight_tensor_names();
|
|
void add_weight_tensor_names(const std::string& value);
|
|
void add_weight_tensor_names(std::string&& value);
|
|
void add_weight_tensor_names(const char* value);
|
|
void add_weight_tensor_names(const char* value, size_t size);
|
|
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& weight_tensor_names() const;
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_weight_tensor_names();
|
|
private:
|
|
const std::string& _internal_weight_tensor_names(int index) const;
|
|
std::string* _internal_add_weight_tensor_names();
|
|
public:
|
|
|
|
// repeated float prune_ratios = 2;
|
|
int prune_ratios_size() const;
|
|
private:
|
|
int _internal_prune_ratios_size() const;
|
|
public:
|
|
void clear_prune_ratios();
|
|
private:
|
|
float _internal_prune_ratios(int index) const;
|
|
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
|
|
_internal_prune_ratios() const;
|
|
void _internal_add_prune_ratios(float value);
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
|
|
_internal_mutable_prune_ratios();
|
|
public:
|
|
float prune_ratios(int index) const;
|
|
void set_prune_ratios(int index, float value);
|
|
void add_prune_ratios(float value);
|
|
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
|
|
prune_ratios() const;
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
|
|
mutable_prune_ratios();
|
|
|
|
// repeated string layer_names = 3;
|
|
int layer_names_size() const;
|
|
private:
|
|
int _internal_layer_names_size() const;
|
|
public:
|
|
void clear_layer_names();
|
|
const std::string& layer_names(int index) const;
|
|
std::string* mutable_layer_names(int index);
|
|
void set_layer_names(int index, const std::string& value);
|
|
void set_layer_names(int index, std::string&& value);
|
|
void set_layer_names(int index, const char* value);
|
|
void set_layer_names(int index, const char* value, size_t size);
|
|
std::string* add_layer_names();
|
|
void add_layer_names(const std::string& value);
|
|
void add_layer_names(std::string&& value);
|
|
void add_layer_names(const char* value);
|
|
void add_layer_names(const char* value, size_t size);
|
|
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& layer_names() const;
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_layer_names();
|
|
private:
|
|
const std::string& _internal_layer_names(int index) const;
|
|
std::string* _internal_add_layer_names();
|
|
public:
|
|
|
|
// @@protoc_insertion_point(class_scope:MNN.Compression.LevelPrunerParams)
|
|
private:
|
|
class _Internal;
|
|
|
|
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
|
|
typedef void InternalArenaConstructable_;
|
|
typedef void DestructorSkippable_;
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> weight_tensor_names_;
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedField< float > prune_ratios_;
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> layer_names_;
|
|
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
|
|
friend struct ::TableStruct_MNN_5fcompression_2eproto;
|
|
};
|
|
// -------------------------------------------------------------------
|
|
|
|
class SIMDOCPrunerParams final :
|
|
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MNN.Compression.SIMDOCPrunerParams) */ {
|
|
public:
|
|
inline SIMDOCPrunerParams() : SIMDOCPrunerParams(nullptr) {}
|
|
~SIMDOCPrunerParams() override;
|
|
explicit constexpr SIMDOCPrunerParams(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
|
|
|
|
SIMDOCPrunerParams(const SIMDOCPrunerParams& from);
|
|
SIMDOCPrunerParams(SIMDOCPrunerParams&& from) noexcept
|
|
: SIMDOCPrunerParams() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline SIMDOCPrunerParams& operator=(const SIMDOCPrunerParams& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline SIMDOCPrunerParams& operator=(SIMDOCPrunerParams&& 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;
|
|
}
|
|
|
|
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
|
|
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
|
|
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
|
|
}
|
|
|
|
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 SIMDOCPrunerParams& default_instance() {
|
|
return *internal_default_instance();
|
|
}
|
|
static inline const SIMDOCPrunerParams* internal_default_instance() {
|
|
return reinterpret_cast<const SIMDOCPrunerParams*>(
|
|
&_SIMDOCPrunerParams_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
7;
|
|
|
|
friend void swap(SIMDOCPrunerParams& a, SIMDOCPrunerParams& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(SIMDOCPrunerParams* 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(SIMDOCPrunerParams* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
SIMDOCPrunerParams* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
|
|
return CreateMaybeMessage<SIMDOCPrunerParams>(arena);
|
|
}
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
|
|
void CopyFrom(const SIMDOCPrunerParams& from);
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
|
|
void MergeFrom(const SIMDOCPrunerParams& from);
|
|
private:
|
|
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
|
|
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 _cached_size_.Get(); }
|
|
|
|
private:
|
|
void SharedCtor();
|
|
void SharedDtor();
|
|
void SetCachedSize(int size) const final;
|
|
void InternalSwap(SIMDOCPrunerParams* other);
|
|
|
|
private:
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "MNN.Compression.SIMDOCPrunerParams";
|
|
}
|
|
protected:
|
|
explicit SIMDOCPrunerParams(::PROTOBUF_NAMESPACE_ID::Arena* arena,
|
|
bool is_message_owned = false);
|
|
private:
|
|
static void ArenaDtor(void* object);
|
|
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
|
|
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 {
|
|
kWeightTensorNamesFieldNumber = 1,
|
|
kPruneRatiosFieldNumber = 2,
|
|
kLayerNamesFieldNumber = 3,
|
|
kOcBlocksFieldNumber = 4,
|
|
};
|
|
// repeated string weight_tensor_names = 1;
|
|
int weight_tensor_names_size() const;
|
|
private:
|
|
int _internal_weight_tensor_names_size() const;
|
|
public:
|
|
void clear_weight_tensor_names();
|
|
const std::string& weight_tensor_names(int index) const;
|
|
std::string* mutable_weight_tensor_names(int index);
|
|
void set_weight_tensor_names(int index, const std::string& value);
|
|
void set_weight_tensor_names(int index, std::string&& value);
|
|
void set_weight_tensor_names(int index, const char* value);
|
|
void set_weight_tensor_names(int index, const char* value, size_t size);
|
|
std::string* add_weight_tensor_names();
|
|
void add_weight_tensor_names(const std::string& value);
|
|
void add_weight_tensor_names(std::string&& value);
|
|
void add_weight_tensor_names(const char* value);
|
|
void add_weight_tensor_names(const char* value, size_t size);
|
|
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& weight_tensor_names() const;
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_weight_tensor_names();
|
|
private:
|
|
const std::string& _internal_weight_tensor_names(int index) const;
|
|
std::string* _internal_add_weight_tensor_names();
|
|
public:
|
|
|
|
// repeated float prune_ratios = 2;
|
|
int prune_ratios_size() const;
|
|
private:
|
|
int _internal_prune_ratios_size() const;
|
|
public:
|
|
void clear_prune_ratios();
|
|
private:
|
|
float _internal_prune_ratios(int index) const;
|
|
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
|
|
_internal_prune_ratios() const;
|
|
void _internal_add_prune_ratios(float value);
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
|
|
_internal_mutable_prune_ratios();
|
|
public:
|
|
float prune_ratios(int index) const;
|
|
void set_prune_ratios(int index, float value);
|
|
void add_prune_ratios(float value);
|
|
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
|
|
prune_ratios() const;
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
|
|
mutable_prune_ratios();
|
|
|
|
// repeated string layer_names = 3;
|
|
int layer_names_size() const;
|
|
private:
|
|
int _internal_layer_names_size() const;
|
|
public:
|
|
void clear_layer_names();
|
|
const std::string& layer_names(int index) const;
|
|
std::string* mutable_layer_names(int index);
|
|
void set_layer_names(int index, const std::string& value);
|
|
void set_layer_names(int index, std::string&& value);
|
|
void set_layer_names(int index, const char* value);
|
|
void set_layer_names(int index, const char* value, size_t size);
|
|
std::string* add_layer_names();
|
|
void add_layer_names(const std::string& value);
|
|
void add_layer_names(std::string&& value);
|
|
void add_layer_names(const char* value);
|
|
void add_layer_names(const char* value, size_t size);
|
|
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& layer_names() const;
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_layer_names();
|
|
private:
|
|
const std::string& _internal_layer_names(int index) const;
|
|
std::string* _internal_add_layer_names();
|
|
public:
|
|
|
|
// repeated int32 oc_blocks = 4;
|
|
int oc_blocks_size() const;
|
|
private:
|
|
int _internal_oc_blocks_size() const;
|
|
public:
|
|
void clear_oc_blocks();
|
|
private:
|
|
int32_t _internal_oc_blocks(int index) const;
|
|
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
|
|
_internal_oc_blocks() const;
|
|
void _internal_add_oc_blocks(int32_t value);
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
|
|
_internal_mutable_oc_blocks();
|
|
public:
|
|
int32_t oc_blocks(int index) const;
|
|
void set_oc_blocks(int index, int32_t value);
|
|
void add_oc_blocks(int32_t value);
|
|
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
|
|
oc_blocks() const;
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
|
|
mutable_oc_blocks();
|
|
|
|
// @@protoc_insertion_point(class_scope:MNN.Compression.SIMDOCPrunerParams)
|
|
private:
|
|
class _Internal;
|
|
|
|
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
|
|
typedef void InternalArenaConstructable_;
|
|
typedef void DestructorSkippable_;
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> weight_tensor_names_;
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedField< float > prune_ratios_;
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> layer_names_;
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > oc_blocks_;
|
|
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
|
|
friend struct ::TableStruct_MNN_5fcompression_2eproto;
|
|
};
|
|
// -------------------------------------------------------------------
|
|
|
|
class PruneParams final :
|
|
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MNN.Compression.PruneParams) */ {
|
|
public:
|
|
inline PruneParams() : PruneParams(nullptr) {}
|
|
~PruneParams() override;
|
|
explicit constexpr PruneParams(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
|
|
|
|
PruneParams(const PruneParams& from);
|
|
PruneParams(PruneParams&& from) noexcept
|
|
: PruneParams() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline PruneParams& operator=(const PruneParams& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline PruneParams& operator=(PruneParams&& 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;
|
|
}
|
|
|
|
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
|
|
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
|
|
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
|
|
}
|
|
|
|
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 PruneParams& default_instance() {
|
|
return *internal_default_instance();
|
|
}
|
|
static inline const PruneParams* internal_default_instance() {
|
|
return reinterpret_cast<const PruneParams*>(
|
|
&_PruneParams_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
8;
|
|
|
|
friend void swap(PruneParams& a, PruneParams& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(PruneParams* 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(PruneParams* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
PruneParams* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
|
|
return CreateMaybeMessage<PruneParams>(arena);
|
|
}
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
|
|
void CopyFrom(const PruneParams& from);
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
|
|
void MergeFrom(const PruneParams& from);
|
|
private:
|
|
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
|
|
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 _cached_size_.Get(); }
|
|
|
|
private:
|
|
void SharedCtor();
|
|
void SharedDtor();
|
|
void SetCachedSize(int size) const final;
|
|
void InternalSwap(PruneParams* other);
|
|
|
|
private:
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "MNN.Compression.PruneParams";
|
|
}
|
|
protected:
|
|
explicit PruneParams(::PROTOBUF_NAMESPACE_ID::Arena* arena,
|
|
bool is_message_owned = false);
|
|
private:
|
|
static void ArenaDtor(void* object);
|
|
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
|
|
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 PruneParams_PruneType PruneType;
|
|
static constexpr PruneType RANDOM =
|
|
PruneParams_PruneType_RANDOM;
|
|
static constexpr PruneType SIMD_OC =
|
|
PruneParams_PruneType_SIMD_OC;
|
|
static constexpr PruneType FILTER =
|
|
PruneParams_PruneType_FILTER;
|
|
static inline bool PruneType_IsValid(int value) {
|
|
return PruneParams_PruneType_IsValid(value);
|
|
}
|
|
static constexpr PruneType PruneType_MIN =
|
|
PruneParams_PruneType_PruneType_MIN;
|
|
static constexpr PruneType PruneType_MAX =
|
|
PruneParams_PruneType_PruneType_MAX;
|
|
static constexpr int PruneType_ARRAYSIZE =
|
|
PruneParams_PruneType_PruneType_ARRAYSIZE;
|
|
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
|
|
PruneType_descriptor() {
|
|
return PruneParams_PruneType_descriptor();
|
|
}
|
|
template<typename T>
|
|
static inline const std::string& PruneType_Name(T enum_t_value) {
|
|
static_assert(::std::is_same<T, PruneType>::value ||
|
|
::std::is_integral<T>::value,
|
|
"Incorrect type passed to function PruneType_Name.");
|
|
return PruneParams_PruneType_Name(enum_t_value);
|
|
}
|
|
static inline bool PruneType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
|
|
PruneType* value) {
|
|
return PruneParams_PruneType_Parse(name, value);
|
|
}
|
|
|
|
// accessors -------------------------------------------------------
|
|
|
|
enum : int {
|
|
kLevelPrunerParamsFieldNumber = 2,
|
|
kSimdOcPrunerParamsFieldNumber = 3,
|
|
kTypeFieldNumber = 1,
|
|
};
|
|
// optional .MNN.Compression.LevelPrunerParams level_pruner_params = 2;
|
|
bool has_level_pruner_params() const;
|
|
private:
|
|
bool _internal_has_level_pruner_params() const;
|
|
public:
|
|
void clear_level_pruner_params();
|
|
const ::MNN::Compression::LevelPrunerParams& level_pruner_params() const;
|
|
PROTOBUF_NODISCARD ::MNN::Compression::LevelPrunerParams* release_level_pruner_params();
|
|
::MNN::Compression::LevelPrunerParams* mutable_level_pruner_params();
|
|
void set_allocated_level_pruner_params(::MNN::Compression::LevelPrunerParams* level_pruner_params);
|
|
private:
|
|
const ::MNN::Compression::LevelPrunerParams& _internal_level_pruner_params() const;
|
|
::MNN::Compression::LevelPrunerParams* _internal_mutable_level_pruner_params();
|
|
public:
|
|
void unsafe_arena_set_allocated_level_pruner_params(
|
|
::MNN::Compression::LevelPrunerParams* level_pruner_params);
|
|
::MNN::Compression::LevelPrunerParams* unsafe_arena_release_level_pruner_params();
|
|
|
|
// optional .MNN.Compression.SIMDOCPrunerParams simd_oc_pruner_params = 3;
|
|
bool has_simd_oc_pruner_params() const;
|
|
private:
|
|
bool _internal_has_simd_oc_pruner_params() const;
|
|
public:
|
|
void clear_simd_oc_pruner_params();
|
|
const ::MNN::Compression::SIMDOCPrunerParams& simd_oc_pruner_params() const;
|
|
PROTOBUF_NODISCARD ::MNN::Compression::SIMDOCPrunerParams* release_simd_oc_pruner_params();
|
|
::MNN::Compression::SIMDOCPrunerParams* mutable_simd_oc_pruner_params();
|
|
void set_allocated_simd_oc_pruner_params(::MNN::Compression::SIMDOCPrunerParams* simd_oc_pruner_params);
|
|
private:
|
|
const ::MNN::Compression::SIMDOCPrunerParams& _internal_simd_oc_pruner_params() const;
|
|
::MNN::Compression::SIMDOCPrunerParams* _internal_mutable_simd_oc_pruner_params();
|
|
public:
|
|
void unsafe_arena_set_allocated_simd_oc_pruner_params(
|
|
::MNN::Compression::SIMDOCPrunerParams* simd_oc_pruner_params);
|
|
::MNN::Compression::SIMDOCPrunerParams* unsafe_arena_release_simd_oc_pruner_params();
|
|
|
|
// optional .MNN.Compression.PruneParams.PruneType type = 1 [default = RANDOM];
|
|
bool has_type() const;
|
|
private:
|
|
bool _internal_has_type() const;
|
|
public:
|
|
void clear_type();
|
|
::MNN::Compression::PruneParams_PruneType type() const;
|
|
void set_type(::MNN::Compression::PruneParams_PruneType value);
|
|
private:
|
|
::MNN::Compression::PruneParams_PruneType _internal_type() const;
|
|
void _internal_set_type(::MNN::Compression::PruneParams_PruneType value);
|
|
public:
|
|
|
|
// @@protoc_insertion_point(class_scope:MNN.Compression.PruneParams)
|
|
private:
|
|
class _Internal;
|
|
|
|
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
|
|
typedef void InternalArenaConstructable_;
|
|
typedef void DestructorSkippable_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
|
|
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
|
|
::MNN::Compression::LevelPrunerParams* level_pruner_params_;
|
|
::MNN::Compression::SIMDOCPrunerParams* simd_oc_pruner_params_;
|
|
int type_;
|
|
friend struct ::TableStruct_MNN_5fcompression_2eproto;
|
|
};
|
|
// -------------------------------------------------------------------
|
|
|
|
class CompressionAlgo final :
|
|
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MNN.Compression.CompressionAlgo) */ {
|
|
public:
|
|
inline CompressionAlgo() : CompressionAlgo(nullptr) {}
|
|
~CompressionAlgo() override;
|
|
explicit constexpr CompressionAlgo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
|
|
|
|
CompressionAlgo(const CompressionAlgo& from);
|
|
CompressionAlgo(CompressionAlgo&& from) noexcept
|
|
: CompressionAlgo() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline CompressionAlgo& operator=(const CompressionAlgo& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline CompressionAlgo& operator=(CompressionAlgo&& 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;
|
|
}
|
|
|
|
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
|
|
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
|
|
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
|
|
}
|
|
|
|
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 CompressionAlgo& default_instance() {
|
|
return *internal_default_instance();
|
|
}
|
|
static inline const CompressionAlgo* internal_default_instance() {
|
|
return reinterpret_cast<const CompressionAlgo*>(
|
|
&_CompressionAlgo_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
9;
|
|
|
|
friend void swap(CompressionAlgo& a, CompressionAlgo& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(CompressionAlgo* 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(CompressionAlgo* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
CompressionAlgo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
|
|
return CreateMaybeMessage<CompressionAlgo>(arena);
|
|
}
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
|
|
void CopyFrom(const CompressionAlgo& from);
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
|
|
void MergeFrom(const CompressionAlgo& from);
|
|
private:
|
|
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
|
|
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 _cached_size_.Get(); }
|
|
|
|
private:
|
|
void SharedCtor();
|
|
void SharedDtor();
|
|
void SetCachedSize(int size) const final;
|
|
void InternalSwap(CompressionAlgo* other);
|
|
|
|
private:
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "MNN.Compression.CompressionAlgo";
|
|
}
|
|
protected:
|
|
explicit CompressionAlgo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
|
|
bool is_message_owned = false);
|
|
private:
|
|
static void ArenaDtor(void* object);
|
|
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
|
|
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 CompressionAlgo_CompressionType CompressionType;
|
|
static constexpr CompressionType QUANTIZE =
|
|
CompressionAlgo_CompressionType_QUANTIZE;
|
|
static constexpr CompressionType PRUNE =
|
|
CompressionAlgo_CompressionType_PRUNE;
|
|
static inline bool CompressionType_IsValid(int value) {
|
|
return CompressionAlgo_CompressionType_IsValid(value);
|
|
}
|
|
static constexpr CompressionType CompressionType_MIN =
|
|
CompressionAlgo_CompressionType_CompressionType_MIN;
|
|
static constexpr CompressionType CompressionType_MAX =
|
|
CompressionAlgo_CompressionType_CompressionType_MAX;
|
|
static constexpr int CompressionType_ARRAYSIZE =
|
|
CompressionAlgo_CompressionType_CompressionType_ARRAYSIZE;
|
|
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
|
|
CompressionType_descriptor() {
|
|
return CompressionAlgo_CompressionType_descriptor();
|
|
}
|
|
template<typename T>
|
|
static inline const std::string& CompressionType_Name(T enum_t_value) {
|
|
static_assert(::std::is_same<T, CompressionType>::value ||
|
|
::std::is_integral<T>::value,
|
|
"Incorrect type passed to function CompressionType_Name.");
|
|
return CompressionAlgo_CompressionType_Name(enum_t_value);
|
|
}
|
|
static inline bool CompressionType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
|
|
CompressionType* value) {
|
|
return CompressionAlgo_CompressionType_Parse(name, value);
|
|
}
|
|
|
|
// accessors -------------------------------------------------------
|
|
|
|
enum : int {
|
|
kQuantParamsFieldNumber = 2,
|
|
kPruneParamsFieldNumber = 3,
|
|
kTypeFieldNumber = 1,
|
|
};
|
|
// optional .MNN.Compression.QuantizeParams quant_params = 2;
|
|
bool has_quant_params() const;
|
|
private:
|
|
bool _internal_has_quant_params() const;
|
|
public:
|
|
void clear_quant_params();
|
|
const ::MNN::Compression::QuantizeParams& quant_params() const;
|
|
PROTOBUF_NODISCARD ::MNN::Compression::QuantizeParams* release_quant_params();
|
|
::MNN::Compression::QuantizeParams* mutable_quant_params();
|
|
void set_allocated_quant_params(::MNN::Compression::QuantizeParams* quant_params);
|
|
private:
|
|
const ::MNN::Compression::QuantizeParams& _internal_quant_params() const;
|
|
::MNN::Compression::QuantizeParams* _internal_mutable_quant_params();
|
|
public:
|
|
void unsafe_arena_set_allocated_quant_params(
|
|
::MNN::Compression::QuantizeParams* quant_params);
|
|
::MNN::Compression::QuantizeParams* unsafe_arena_release_quant_params();
|
|
|
|
// optional .MNN.Compression.PruneParams prune_params = 3;
|
|
bool has_prune_params() const;
|
|
private:
|
|
bool _internal_has_prune_params() const;
|
|
public:
|
|
void clear_prune_params();
|
|
const ::MNN::Compression::PruneParams& prune_params() const;
|
|
PROTOBUF_NODISCARD ::MNN::Compression::PruneParams* release_prune_params();
|
|
::MNN::Compression::PruneParams* mutable_prune_params();
|
|
void set_allocated_prune_params(::MNN::Compression::PruneParams* prune_params);
|
|
private:
|
|
const ::MNN::Compression::PruneParams& _internal_prune_params() const;
|
|
::MNN::Compression::PruneParams* _internal_mutable_prune_params();
|
|
public:
|
|
void unsafe_arena_set_allocated_prune_params(
|
|
::MNN::Compression::PruneParams* prune_params);
|
|
::MNN::Compression::PruneParams* unsafe_arena_release_prune_params();
|
|
|
|
// optional .MNN.Compression.CompressionAlgo.CompressionType type = 1 [default = QUANTIZE];
|
|
bool has_type() const;
|
|
private:
|
|
bool _internal_has_type() const;
|
|
public:
|
|
void clear_type();
|
|
::MNN::Compression::CompressionAlgo_CompressionType type() const;
|
|
void set_type(::MNN::Compression::CompressionAlgo_CompressionType value);
|
|
private:
|
|
::MNN::Compression::CompressionAlgo_CompressionType _internal_type() const;
|
|
void _internal_set_type(::MNN::Compression::CompressionAlgo_CompressionType value);
|
|
public:
|
|
|
|
// @@protoc_insertion_point(class_scope:MNN.Compression.CompressionAlgo)
|
|
private:
|
|
class _Internal;
|
|
|
|
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
|
|
typedef void InternalArenaConstructable_;
|
|
typedef void DestructorSkippable_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
|
|
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
|
|
::MNN::Compression::QuantizeParams* quant_params_;
|
|
::MNN::Compression::PruneParams* prune_params_;
|
|
int type_;
|
|
friend struct ::TableStruct_MNN_5fcompression_2eproto;
|
|
};
|
|
// -------------------------------------------------------------------
|
|
|
|
class Pipeline final :
|
|
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MNN.Compression.Pipeline) */ {
|
|
public:
|
|
inline Pipeline() : Pipeline(nullptr) {}
|
|
~Pipeline() override;
|
|
explicit constexpr Pipeline(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
|
|
|
|
Pipeline(const Pipeline& from);
|
|
Pipeline(Pipeline&& from) noexcept
|
|
: Pipeline() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline Pipeline& operator=(const Pipeline& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline Pipeline& operator=(Pipeline&& 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;
|
|
}
|
|
|
|
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
|
|
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
|
|
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
|
|
}
|
|
|
|
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 Pipeline& default_instance() {
|
|
return *internal_default_instance();
|
|
}
|
|
static inline const Pipeline* internal_default_instance() {
|
|
return reinterpret_cast<const Pipeline*>(
|
|
&_Pipeline_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
10;
|
|
|
|
friend void swap(Pipeline& a, Pipeline& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(Pipeline* 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(Pipeline* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
Pipeline* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
|
|
return CreateMaybeMessage<Pipeline>(arena);
|
|
}
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
|
|
void CopyFrom(const Pipeline& from);
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
|
|
void MergeFrom(const Pipeline& from);
|
|
private:
|
|
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
|
|
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 _cached_size_.Get(); }
|
|
|
|
private:
|
|
void SharedCtor();
|
|
void SharedDtor();
|
|
void SetCachedSize(int size) const final;
|
|
void InternalSwap(Pipeline* other);
|
|
|
|
private:
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "MNN.Compression.Pipeline";
|
|
}
|
|
protected:
|
|
explicit Pipeline(::PROTOBUF_NAMESPACE_ID::Arena* arena,
|
|
bool is_message_owned = false);
|
|
private:
|
|
static void ArenaDtor(void* object);
|
|
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
|
|
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 {
|
|
kAlgoFieldNumber = 2,
|
|
kVersionFieldNumber = 1,
|
|
kMnnUuidFieldNumber = 3,
|
|
kForGuideFieldNumber = 4,
|
|
};
|
|
// repeated .MNN.Compression.CompressionAlgo algo = 2;
|
|
int algo_size() const;
|
|
private:
|
|
int _internal_algo_size() const;
|
|
public:
|
|
void clear_algo();
|
|
::MNN::Compression::CompressionAlgo* mutable_algo(int index);
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MNN::Compression::CompressionAlgo >*
|
|
mutable_algo();
|
|
private:
|
|
const ::MNN::Compression::CompressionAlgo& _internal_algo(int index) const;
|
|
::MNN::Compression::CompressionAlgo* _internal_add_algo();
|
|
public:
|
|
const ::MNN::Compression::CompressionAlgo& algo(int index) const;
|
|
::MNN::Compression::CompressionAlgo* add_algo();
|
|
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MNN::Compression::CompressionAlgo >&
|
|
algo() const;
|
|
|
|
// required string version = 1 [default = "0.0.0"];
|
|
bool has_version() const;
|
|
private:
|
|
bool _internal_has_version() const;
|
|
public:
|
|
void clear_version();
|
|
const std::string& version() const;
|
|
template <typename ArgT0 = const std::string&, typename... ArgT>
|
|
void set_version(ArgT0&& arg0, ArgT... args);
|
|
std::string* mutable_version();
|
|
PROTOBUF_NODISCARD std::string* release_version();
|
|
void set_allocated_version(std::string* version);
|
|
private:
|
|
const std::string& _internal_version() const;
|
|
inline PROTOBUF_ALWAYS_INLINE void _internal_set_version(const std::string& value);
|
|
std::string* _internal_mutable_version();
|
|
public:
|
|
|
|
// optional string mnn_uuid = 3;
|
|
bool has_mnn_uuid() const;
|
|
private:
|
|
bool _internal_has_mnn_uuid() const;
|
|
public:
|
|
void clear_mnn_uuid();
|
|
const std::string& mnn_uuid() const;
|
|
template <typename ArgT0 = const std::string&, typename... ArgT>
|
|
void set_mnn_uuid(ArgT0&& arg0, ArgT... args);
|
|
std::string* mutable_mnn_uuid();
|
|
PROTOBUF_NODISCARD std::string* release_mnn_uuid();
|
|
void set_allocated_mnn_uuid(std::string* mnn_uuid);
|
|
private:
|
|
const std::string& _internal_mnn_uuid() const;
|
|
inline PROTOBUF_ALWAYS_INLINE void _internal_set_mnn_uuid(const std::string& value);
|
|
std::string* _internal_mutable_mnn_uuid();
|
|
public:
|
|
|
|
// optional bool for_guide = 4 [default = false];
|
|
bool has_for_guide() const;
|
|
private:
|
|
bool _internal_has_for_guide() const;
|
|
public:
|
|
void clear_for_guide();
|
|
bool for_guide() const;
|
|
void set_for_guide(bool value);
|
|
private:
|
|
bool _internal_for_guide() const;
|
|
void _internal_set_for_guide(bool value);
|
|
public:
|
|
|
|
// @@protoc_insertion_point(class_scope:MNN.Compression.Pipeline)
|
|
private:
|
|
class _Internal;
|
|
|
|
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
|
|
typedef void InternalArenaConstructable_;
|
|
typedef void DestructorSkippable_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
|
|
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MNN::Compression::CompressionAlgo > algo_;
|
|
static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_version_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr version_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mnn_uuid_;
|
|
bool for_guide_;
|
|
friend struct ::TableStruct_MNN_5fcompression_2eproto;
|
|
};
|
|
// ===================================================================
|
|
|
|
|
|
// ===================================================================
|
|
|
|
#ifdef __GNUC__
|
|
#pragma GCC diagnostic push
|
|
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
|
|
#endif // __GNUC__
|
|
// QuantizeParams
|
|
|
|
// optional .MNN.Compression.QuantizeParams.RoundMode round_mode = 1 [default = ROUND_AWAY_FROM_ZERO];
|
|
inline bool QuantizeParams::_internal_has_round_mode() const {
|
|
bool value = (_has_bits_[0] & 0x00000001u) != 0;
|
|
return value;
|
|
}
|
|
inline bool QuantizeParams::has_round_mode() const {
|
|
return _internal_has_round_mode();
|
|
}
|
|
inline void QuantizeParams::clear_round_mode() {
|
|
round_mode_ = 1;
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
inline ::MNN::Compression::QuantizeParams_RoundMode QuantizeParams::_internal_round_mode() const {
|
|
return static_cast< ::MNN::Compression::QuantizeParams_RoundMode >(round_mode_);
|
|
}
|
|
inline ::MNN::Compression::QuantizeParams_RoundMode QuantizeParams::round_mode() const {
|
|
// @@protoc_insertion_point(field_get:MNN.Compression.QuantizeParams.round_mode)
|
|
return _internal_round_mode();
|
|
}
|
|
inline void QuantizeParams::_internal_set_round_mode(::MNN::Compression::QuantizeParams_RoundMode value) {
|
|
assert(::MNN::Compression::QuantizeParams_RoundMode_IsValid(value));
|
|
_has_bits_[0] |= 0x00000001u;
|
|
round_mode_ = value;
|
|
}
|
|
inline void QuantizeParams::set_round_mode(::MNN::Compression::QuantizeParams_RoundMode value) {
|
|
_internal_set_round_mode(value);
|
|
// @@protoc_insertion_point(field_set:MNN.Compression.QuantizeParams.round_mode)
|
|
}
|
|
|
|
// repeated .MNN.Compression.LayerQuantizeParams layer = 4;
|
|
inline int QuantizeParams::_internal_layer_size() const {
|
|
return layer_.size();
|
|
}
|
|
inline int QuantizeParams::layer_size() const {
|
|
return _internal_layer_size();
|
|
}
|
|
inline void QuantizeParams::clear_layer() {
|
|
layer_.Clear();
|
|
}
|
|
inline ::MNN::Compression::LayerQuantizeParams* QuantizeParams::mutable_layer(int index) {
|
|
// @@protoc_insertion_point(field_mutable:MNN.Compression.QuantizeParams.layer)
|
|
return layer_.Mutable(index);
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MNN::Compression::LayerQuantizeParams >*
|
|
QuantizeParams::mutable_layer() {
|
|
// @@protoc_insertion_point(field_mutable_list:MNN.Compression.QuantizeParams.layer)
|
|
return &layer_;
|
|
}
|
|
inline const ::MNN::Compression::LayerQuantizeParams& QuantizeParams::_internal_layer(int index) const {
|
|
return layer_.Get(index);
|
|
}
|
|
inline const ::MNN::Compression::LayerQuantizeParams& QuantizeParams::layer(int index) const {
|
|
// @@protoc_insertion_point(field_get:MNN.Compression.QuantizeParams.layer)
|
|
return _internal_layer(index);
|
|
}
|
|
inline ::MNN::Compression::LayerQuantizeParams* QuantizeParams::_internal_add_layer() {
|
|
return layer_.Add();
|
|
}
|
|
inline ::MNN::Compression::LayerQuantizeParams* QuantizeParams::add_layer() {
|
|
::MNN::Compression::LayerQuantizeParams* _add = _internal_add_layer();
|
|
// @@protoc_insertion_point(field_add:MNN.Compression.QuantizeParams.layer)
|
|
return _add;
|
|
}
|
|
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MNN::Compression::LayerQuantizeParams >&
|
|
QuantizeParams::layer() const {
|
|
// @@protoc_insertion_point(field_list:MNN.Compression.QuantizeParams.layer)
|
|
return layer_;
|
|
}
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// LayerQuantizeParams_ActivationParams
|
|
|
|
// required string name = 1;
|
|
inline bool LayerQuantizeParams_ActivationParams::_internal_has_name() const {
|
|
bool value = (_has_bits_[0] & 0x00000001u) != 0;
|
|
return value;
|
|
}
|
|
inline bool LayerQuantizeParams_ActivationParams::has_name() const {
|
|
return _internal_has_name();
|
|
}
|
|
inline void LayerQuantizeParams_ActivationParams::clear_name() {
|
|
name_.ClearToEmpty();
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
inline const std::string& LayerQuantizeParams_ActivationParams::name() const {
|
|
// @@protoc_insertion_point(field_get:MNN.Compression.LayerQuantizeParams.ActivationParams.name)
|
|
return _internal_name();
|
|
}
|
|
template <typename ArgT0, typename... ArgT>
|
|
inline PROTOBUF_ALWAYS_INLINE
|
|
void LayerQuantizeParams_ActivationParams::set_name(ArgT0&& arg0, ArgT... args) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set:MNN.Compression.LayerQuantizeParams.ActivationParams.name)
|
|
}
|
|
inline std::string* LayerQuantizeParams_ActivationParams::mutable_name() {
|
|
std::string* _s = _internal_mutable_name();
|
|
// @@protoc_insertion_point(field_mutable:MNN.Compression.LayerQuantizeParams.ActivationParams.name)
|
|
return _s;
|
|
}
|
|
inline const std::string& LayerQuantizeParams_ActivationParams::_internal_name() const {
|
|
return name_.Get();
|
|
}
|
|
inline void LayerQuantizeParams_ActivationParams::_internal_set_name(const std::string& value) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
|
|
}
|
|
inline std::string* LayerQuantizeParams_ActivationParams::_internal_mutable_name() {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
|
|
}
|
|
inline std::string* LayerQuantizeParams_ActivationParams::release_name() {
|
|
// @@protoc_insertion_point(field_release:MNN.Compression.LayerQuantizeParams.ActivationParams.name)
|
|
if (!_internal_has_name()) {
|
|
return nullptr;
|
|
}
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
auto* p = name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
|
|
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
|
|
name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
|
|
}
|
|
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
return p;
|
|
}
|
|
inline void LayerQuantizeParams_ActivationParams::set_allocated_name(std::string* name) {
|
|
if (name != nullptr) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
} else {
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
|
|
GetArenaForAllocation());
|
|
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
|
|
name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
|
|
}
|
|
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
// @@protoc_insertion_point(field_set_allocated:MNN.Compression.LayerQuantizeParams.ActivationParams.name)
|
|
}
|
|
|
|
// optional int32 bits = 2 [default = 8];
|
|
inline bool LayerQuantizeParams_ActivationParams::_internal_has_bits() const {
|
|
bool value = (_has_bits_[0] & 0x00000008u) != 0;
|
|
return value;
|
|
}
|
|
inline bool LayerQuantizeParams_ActivationParams::has_bits() const {
|
|
return _internal_has_bits();
|
|
}
|
|
inline void LayerQuantizeParams_ActivationParams::clear_bits() {
|
|
bits_ = 8;
|
|
_has_bits_[0] &= ~0x00000008u;
|
|
}
|
|
inline int32_t LayerQuantizeParams_ActivationParams::_internal_bits() const {
|
|
return bits_;
|
|
}
|
|
inline int32_t LayerQuantizeParams_ActivationParams::bits() const {
|
|
// @@protoc_insertion_point(field_get:MNN.Compression.LayerQuantizeParams.ActivationParams.bits)
|
|
return _internal_bits();
|
|
}
|
|
inline void LayerQuantizeParams_ActivationParams::_internal_set_bits(int32_t value) {
|
|
_has_bits_[0] |= 0x00000008u;
|
|
bits_ = value;
|
|
}
|
|
inline void LayerQuantizeParams_ActivationParams::set_bits(int32_t value) {
|
|
_internal_set_bits(value);
|
|
// @@protoc_insertion_point(field_set:MNN.Compression.LayerQuantizeParams.ActivationParams.bits)
|
|
}
|
|
|
|
// repeated float scales = 3;
|
|
inline int LayerQuantizeParams_ActivationParams::_internal_scales_size() const {
|
|
return scales_.size();
|
|
}
|
|
inline int LayerQuantizeParams_ActivationParams::scales_size() const {
|
|
return _internal_scales_size();
|
|
}
|
|
inline void LayerQuantizeParams_ActivationParams::clear_scales() {
|
|
scales_.Clear();
|
|
}
|
|
inline float LayerQuantizeParams_ActivationParams::_internal_scales(int index) const {
|
|
return scales_.Get(index);
|
|
}
|
|
inline float LayerQuantizeParams_ActivationParams::scales(int index) const {
|
|
// @@protoc_insertion_point(field_get:MNN.Compression.LayerQuantizeParams.ActivationParams.scales)
|
|
return _internal_scales(index);
|
|
}
|
|
inline void LayerQuantizeParams_ActivationParams::set_scales(int index, float value) {
|
|
scales_.Set(index, value);
|
|
// @@protoc_insertion_point(field_set:MNN.Compression.LayerQuantizeParams.ActivationParams.scales)
|
|
}
|
|
inline void LayerQuantizeParams_ActivationParams::_internal_add_scales(float value) {
|
|
scales_.Add(value);
|
|
}
|
|
inline void LayerQuantizeParams_ActivationParams::add_scales(float value) {
|
|
_internal_add_scales(value);
|
|
// @@protoc_insertion_point(field_add:MNN.Compression.LayerQuantizeParams.ActivationParams.scales)
|
|
}
|
|
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
|
|
LayerQuantizeParams_ActivationParams::_internal_scales() const {
|
|
return scales_;
|
|
}
|
|
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
|
|
LayerQuantizeParams_ActivationParams::scales() const {
|
|
// @@protoc_insertion_point(field_list:MNN.Compression.LayerQuantizeParams.ActivationParams.scales)
|
|
return _internal_scales();
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
|
|
LayerQuantizeParams_ActivationParams::_internal_mutable_scales() {
|
|
return &scales_;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
|
|
LayerQuantizeParams_ActivationParams::mutable_scales() {
|
|
// @@protoc_insertion_point(field_mutable_list:MNN.Compression.LayerQuantizeParams.ActivationParams.scales)
|
|
return _internal_mutable_scales();
|
|
}
|
|
|
|
// optional int32 zero_point = 4 [default = 0];
|
|
inline bool LayerQuantizeParams_ActivationParams::_internal_has_zero_point() const {
|
|
bool value = (_has_bits_[0] & 0x00000002u) != 0;
|
|
return value;
|
|
}
|
|
inline bool LayerQuantizeParams_ActivationParams::has_zero_point() const {
|
|
return _internal_has_zero_point();
|
|
}
|
|
inline void LayerQuantizeParams_ActivationParams::clear_zero_point() {
|
|
zero_point_ = 0;
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
}
|
|
inline int32_t LayerQuantizeParams_ActivationParams::_internal_zero_point() const {
|
|
return zero_point_;
|
|
}
|
|
inline int32_t LayerQuantizeParams_ActivationParams::zero_point() const {
|
|
// @@protoc_insertion_point(field_get:MNN.Compression.LayerQuantizeParams.ActivationParams.zero_point)
|
|
return _internal_zero_point();
|
|
}
|
|
inline void LayerQuantizeParams_ActivationParams::_internal_set_zero_point(int32_t value) {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
zero_point_ = value;
|
|
}
|
|
inline void LayerQuantizeParams_ActivationParams::set_zero_point(int32_t value) {
|
|
_internal_set_zero_point(value);
|
|
// @@protoc_insertion_point(field_set:MNN.Compression.LayerQuantizeParams.ActivationParams.zero_point)
|
|
}
|
|
|
|
// optional int32 clamp_min = 5 [default = -128];
|
|
inline bool LayerQuantizeParams_ActivationParams::_internal_has_clamp_min() const {
|
|
bool value = (_has_bits_[0] & 0x00000010u) != 0;
|
|
return value;
|
|
}
|
|
inline bool LayerQuantizeParams_ActivationParams::has_clamp_min() const {
|
|
return _internal_has_clamp_min();
|
|
}
|
|
inline void LayerQuantizeParams_ActivationParams::clear_clamp_min() {
|
|
clamp_min_ = -128;
|
|
_has_bits_[0] &= ~0x00000010u;
|
|
}
|
|
inline int32_t LayerQuantizeParams_ActivationParams::_internal_clamp_min() const {
|
|
return clamp_min_;
|
|
}
|
|
inline int32_t LayerQuantizeParams_ActivationParams::clamp_min() const {
|
|
// @@protoc_insertion_point(field_get:MNN.Compression.LayerQuantizeParams.ActivationParams.clamp_min)
|
|
return _internal_clamp_min();
|
|
}
|
|
inline void LayerQuantizeParams_ActivationParams::_internal_set_clamp_min(int32_t value) {
|
|
_has_bits_[0] |= 0x00000010u;
|
|
clamp_min_ = value;
|
|
}
|
|
inline void LayerQuantizeParams_ActivationParams::set_clamp_min(int32_t value) {
|
|
_internal_set_clamp_min(value);
|
|
// @@protoc_insertion_point(field_set:MNN.Compression.LayerQuantizeParams.ActivationParams.clamp_min)
|
|
}
|
|
|
|
// optional int32 clamp_max = 6 [default = 127];
|
|
inline bool LayerQuantizeParams_ActivationParams::_internal_has_clamp_max() const {
|
|
bool value = (_has_bits_[0] & 0x00000004u) != 0;
|
|
return value;
|
|
}
|
|
inline bool LayerQuantizeParams_ActivationParams::has_clamp_max() const {
|
|
return _internal_has_clamp_max();
|
|
}
|
|
inline void LayerQuantizeParams_ActivationParams::clear_clamp_max() {
|
|
clamp_max_ = 127;
|
|
_has_bits_[0] &= ~0x00000004u;
|
|
}
|
|
inline int32_t LayerQuantizeParams_ActivationParams::_internal_clamp_max() const {
|
|
return clamp_max_;
|
|
}
|
|
inline int32_t LayerQuantizeParams_ActivationParams::clamp_max() const {
|
|
// @@protoc_insertion_point(field_get:MNN.Compression.LayerQuantizeParams.ActivationParams.clamp_max)
|
|
return _internal_clamp_max();
|
|
}
|
|
inline void LayerQuantizeParams_ActivationParams::_internal_set_clamp_max(int32_t value) {
|
|
_has_bits_[0] |= 0x00000004u;
|
|
clamp_max_ = value;
|
|
}
|
|
inline void LayerQuantizeParams_ActivationParams::set_clamp_max(int32_t value) {
|
|
_internal_set_clamp_max(value);
|
|
// @@protoc_insertion_point(field_set:MNN.Compression.LayerQuantizeParams.ActivationParams.clamp_max)
|
|
}
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// LayerQuantizeParams_WeightParams
|
|
|
|
// required string name = 1;
|
|
inline bool LayerQuantizeParams_WeightParams::_internal_has_name() const {
|
|
bool value = (_has_bits_[0] & 0x00000001u) != 0;
|
|
return value;
|
|
}
|
|
inline bool LayerQuantizeParams_WeightParams::has_name() const {
|
|
return _internal_has_name();
|
|
}
|
|
inline void LayerQuantizeParams_WeightParams::clear_name() {
|
|
name_.ClearToEmpty();
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
inline const std::string& LayerQuantizeParams_WeightParams::name() const {
|
|
// @@protoc_insertion_point(field_get:MNN.Compression.LayerQuantizeParams.WeightParams.name)
|
|
return _internal_name();
|
|
}
|
|
template <typename ArgT0, typename... ArgT>
|
|
inline PROTOBUF_ALWAYS_INLINE
|
|
void LayerQuantizeParams_WeightParams::set_name(ArgT0&& arg0, ArgT... args) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set:MNN.Compression.LayerQuantizeParams.WeightParams.name)
|
|
}
|
|
inline std::string* LayerQuantizeParams_WeightParams::mutable_name() {
|
|
std::string* _s = _internal_mutable_name();
|
|
// @@protoc_insertion_point(field_mutable:MNN.Compression.LayerQuantizeParams.WeightParams.name)
|
|
return _s;
|
|
}
|
|
inline const std::string& LayerQuantizeParams_WeightParams::_internal_name() const {
|
|
return name_.Get();
|
|
}
|
|
inline void LayerQuantizeParams_WeightParams::_internal_set_name(const std::string& value) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
|
|
}
|
|
inline std::string* LayerQuantizeParams_WeightParams::_internal_mutable_name() {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
|
|
}
|
|
inline std::string* LayerQuantizeParams_WeightParams::release_name() {
|
|
// @@protoc_insertion_point(field_release:MNN.Compression.LayerQuantizeParams.WeightParams.name)
|
|
if (!_internal_has_name()) {
|
|
return nullptr;
|
|
}
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
auto* p = name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
|
|
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
|
|
name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
|
|
}
|
|
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
return p;
|
|
}
|
|
inline void LayerQuantizeParams_WeightParams::set_allocated_name(std::string* name) {
|
|
if (name != nullptr) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
} else {
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
|
|
GetArenaForAllocation());
|
|
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
|
|
name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
|
|
}
|
|
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
// @@protoc_insertion_point(field_set_allocated:MNN.Compression.LayerQuantizeParams.WeightParams.name)
|
|
}
|
|
|
|
// optional int32 bits = 2 [default = 8];
|
|
inline bool LayerQuantizeParams_WeightParams::_internal_has_bits() const {
|
|
bool value = (_has_bits_[0] & 0x00000010u) != 0;
|
|
return value;
|
|
}
|
|
inline bool LayerQuantizeParams_WeightParams::has_bits() const {
|
|
return _internal_has_bits();
|
|
}
|
|
inline void LayerQuantizeParams_WeightParams::clear_bits() {
|
|
bits_ = 8;
|
|
_has_bits_[0] &= ~0x00000010u;
|
|
}
|
|
inline int32_t LayerQuantizeParams_WeightParams::_internal_bits() const {
|
|
return bits_;
|
|
}
|
|
inline int32_t LayerQuantizeParams_WeightParams::bits() const {
|
|
// @@protoc_insertion_point(field_get:MNN.Compression.LayerQuantizeParams.WeightParams.bits)
|
|
return _internal_bits();
|
|
}
|
|
inline void LayerQuantizeParams_WeightParams::_internal_set_bits(int32_t value) {
|
|
_has_bits_[0] |= 0x00000010u;
|
|
bits_ = value;
|
|
}
|
|
inline void LayerQuantizeParams_WeightParams::set_bits(int32_t value) {
|
|
_internal_set_bits(value);
|
|
// @@protoc_insertion_point(field_set:MNN.Compression.LayerQuantizeParams.WeightParams.bits)
|
|
}
|
|
|
|
// repeated float scales = 3;
|
|
inline int LayerQuantizeParams_WeightParams::_internal_scales_size() const {
|
|
return scales_.size();
|
|
}
|
|
inline int LayerQuantizeParams_WeightParams::scales_size() const {
|
|
return _internal_scales_size();
|
|
}
|
|
inline void LayerQuantizeParams_WeightParams::clear_scales() {
|
|
scales_.Clear();
|
|
}
|
|
inline float LayerQuantizeParams_WeightParams::_internal_scales(int index) const {
|
|
return scales_.Get(index);
|
|
}
|
|
inline float LayerQuantizeParams_WeightParams::scales(int index) const {
|
|
// @@protoc_insertion_point(field_get:MNN.Compression.LayerQuantizeParams.WeightParams.scales)
|
|
return _internal_scales(index);
|
|
}
|
|
inline void LayerQuantizeParams_WeightParams::set_scales(int index, float value) {
|
|
scales_.Set(index, value);
|
|
// @@protoc_insertion_point(field_set:MNN.Compression.LayerQuantizeParams.WeightParams.scales)
|
|
}
|
|
inline void LayerQuantizeParams_WeightParams::_internal_add_scales(float value) {
|
|
scales_.Add(value);
|
|
}
|
|
inline void LayerQuantizeParams_WeightParams::add_scales(float value) {
|
|
_internal_add_scales(value);
|
|
// @@protoc_insertion_point(field_add:MNN.Compression.LayerQuantizeParams.WeightParams.scales)
|
|
}
|
|
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
|
|
LayerQuantizeParams_WeightParams::_internal_scales() const {
|
|
return scales_;
|
|
}
|
|
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
|
|
LayerQuantizeParams_WeightParams::scales() const {
|
|
// @@protoc_insertion_point(field_list:MNN.Compression.LayerQuantizeParams.WeightParams.scales)
|
|
return _internal_scales();
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
|
|
LayerQuantizeParams_WeightParams::_internal_mutable_scales() {
|
|
return &scales_;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
|
|
LayerQuantizeParams_WeightParams::mutable_scales() {
|
|
// @@protoc_insertion_point(field_mutable_list:MNN.Compression.LayerQuantizeParams.WeightParams.scales)
|
|
return _internal_mutable_scales();
|
|
}
|
|
|
|
// optional int32 clamp_min = 4 [default = -128];
|
|
inline bool LayerQuantizeParams_WeightParams::_internal_has_clamp_min() const {
|
|
bool value = (_has_bits_[0] & 0x00000020u) != 0;
|
|
return value;
|
|
}
|
|
inline bool LayerQuantizeParams_WeightParams::has_clamp_min() const {
|
|
return _internal_has_clamp_min();
|
|
}
|
|
inline void LayerQuantizeParams_WeightParams::clear_clamp_min() {
|
|
clamp_min_ = -128;
|
|
_has_bits_[0] &= ~0x00000020u;
|
|
}
|
|
inline int32_t LayerQuantizeParams_WeightParams::_internal_clamp_min() const {
|
|
return clamp_min_;
|
|
}
|
|
inline int32_t LayerQuantizeParams_WeightParams::clamp_min() const {
|
|
// @@protoc_insertion_point(field_get:MNN.Compression.LayerQuantizeParams.WeightParams.clamp_min)
|
|
return _internal_clamp_min();
|
|
}
|
|
inline void LayerQuantizeParams_WeightParams::_internal_set_clamp_min(int32_t value) {
|
|
_has_bits_[0] |= 0x00000020u;
|
|
clamp_min_ = value;
|
|
}
|
|
inline void LayerQuantizeParams_WeightParams::set_clamp_min(int32_t value) {
|
|
_internal_set_clamp_min(value);
|
|
// @@protoc_insertion_point(field_set:MNN.Compression.LayerQuantizeParams.WeightParams.clamp_min)
|
|
}
|
|
|
|
// optional int32 clamp_max = 5 [default = 127];
|
|
inline bool LayerQuantizeParams_WeightParams::_internal_has_clamp_max() const {
|
|
bool value = (_has_bits_[0] & 0x00000008u) != 0;
|
|
return value;
|
|
}
|
|
inline bool LayerQuantizeParams_WeightParams::has_clamp_max() const {
|
|
return _internal_has_clamp_max();
|
|
}
|
|
inline void LayerQuantizeParams_WeightParams::clear_clamp_max() {
|
|
clamp_max_ = 127;
|
|
_has_bits_[0] &= ~0x00000008u;
|
|
}
|
|
inline int32_t LayerQuantizeParams_WeightParams::_internal_clamp_max() const {
|
|
return clamp_max_;
|
|
}
|
|
inline int32_t LayerQuantizeParams_WeightParams::clamp_max() const {
|
|
// @@protoc_insertion_point(field_get:MNN.Compression.LayerQuantizeParams.WeightParams.clamp_max)
|
|
return _internal_clamp_max();
|
|
}
|
|
inline void LayerQuantizeParams_WeightParams::_internal_set_clamp_max(int32_t value) {
|
|
_has_bits_[0] |= 0x00000008u;
|
|
clamp_max_ = value;
|
|
}
|
|
inline void LayerQuantizeParams_WeightParams::set_clamp_max(int32_t value) {
|
|
_internal_set_clamp_max(value);
|
|
// @@protoc_insertion_point(field_set:MNN.Compression.LayerQuantizeParams.WeightParams.clamp_max)
|
|
}
|
|
|
|
// optional bool asymmetric = 6 [default = false];
|
|
inline bool LayerQuantizeParams_WeightParams::_internal_has_asymmetric() const {
|
|
bool value = (_has_bits_[0] & 0x00000002u) != 0;
|
|
return value;
|
|
}
|
|
inline bool LayerQuantizeParams_WeightParams::has_asymmetric() const {
|
|
return _internal_has_asymmetric();
|
|
}
|
|
inline void LayerQuantizeParams_WeightParams::clear_asymmetric() {
|
|
asymmetric_ = false;
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
}
|
|
inline bool LayerQuantizeParams_WeightParams::_internal_asymmetric() const {
|
|
return asymmetric_;
|
|
}
|
|
inline bool LayerQuantizeParams_WeightParams::asymmetric() const {
|
|
// @@protoc_insertion_point(field_get:MNN.Compression.LayerQuantizeParams.WeightParams.asymmetric)
|
|
return _internal_asymmetric();
|
|
}
|
|
inline void LayerQuantizeParams_WeightParams::_internal_set_asymmetric(bool value) {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
asymmetric_ = value;
|
|
}
|
|
inline void LayerQuantizeParams_WeightParams::set_asymmetric(bool value) {
|
|
_internal_set_asymmetric(value);
|
|
// @@protoc_insertion_point(field_set:MNN.Compression.LayerQuantizeParams.WeightParams.asymmetric)
|
|
}
|
|
|
|
// optional int32 block_size = 7 [default = 0];
|
|
inline bool LayerQuantizeParams_WeightParams::_internal_has_block_size() const {
|
|
bool value = (_has_bits_[0] & 0x00000004u) != 0;
|
|
return value;
|
|
}
|
|
inline bool LayerQuantizeParams_WeightParams::has_block_size() const {
|
|
return _internal_has_block_size();
|
|
}
|
|
inline void LayerQuantizeParams_WeightParams::clear_block_size() {
|
|
block_size_ = 0;
|
|
_has_bits_[0] &= ~0x00000004u;
|
|
}
|
|
inline int32_t LayerQuantizeParams_WeightParams::_internal_block_size() const {
|
|
return block_size_;
|
|
}
|
|
inline int32_t LayerQuantizeParams_WeightParams::block_size() const {
|
|
// @@protoc_insertion_point(field_get:MNN.Compression.LayerQuantizeParams.WeightParams.block_size)
|
|
return _internal_block_size();
|
|
}
|
|
inline void LayerQuantizeParams_WeightParams::_internal_set_block_size(int32_t value) {
|
|
_has_bits_[0] |= 0x00000004u;
|
|
block_size_ = value;
|
|
}
|
|
inline void LayerQuantizeParams_WeightParams::set_block_size(int32_t value) {
|
|
_internal_set_block_size(value);
|
|
// @@protoc_insertion_point(field_set:MNN.Compression.LayerQuantizeParams.WeightParams.block_size)
|
|
}
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// LayerQuantizeParams_WinogradParams
|
|
|
|
// required int32 version = 1 [default = 0];
|
|
inline bool LayerQuantizeParams_WinogradParams::_internal_has_version() const {
|
|
bool value = (_has_bits_[0] & 0x00000001u) != 0;
|
|
return value;
|
|
}
|
|
inline bool LayerQuantizeParams_WinogradParams::has_version() const {
|
|
return _internal_has_version();
|
|
}
|
|
inline void LayerQuantizeParams_WinogradParams::clear_version() {
|
|
version_ = 0;
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
inline int32_t LayerQuantizeParams_WinogradParams::_internal_version() const {
|
|
return version_;
|
|
}
|
|
inline int32_t LayerQuantizeParams_WinogradParams::version() const {
|
|
// @@protoc_insertion_point(field_get:MNN.Compression.LayerQuantizeParams.WinogradParams.version)
|
|
return _internal_version();
|
|
}
|
|
inline void LayerQuantizeParams_WinogradParams::_internal_set_version(int32_t value) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
version_ = value;
|
|
}
|
|
inline void LayerQuantizeParams_WinogradParams::set_version(int32_t value) {
|
|
_internal_set_version(value);
|
|
// @@protoc_insertion_point(field_set:MNN.Compression.LayerQuantizeParams.WinogradParams.version)
|
|
}
|
|
|
|
// repeated int32 units_attr = 4;
|
|
inline int LayerQuantizeParams_WinogradParams::_internal_units_attr_size() const {
|
|
return units_attr_.size();
|
|
}
|
|
inline int LayerQuantizeParams_WinogradParams::units_attr_size() const {
|
|
return _internal_units_attr_size();
|
|
}
|
|
inline void LayerQuantizeParams_WinogradParams::clear_units_attr() {
|
|
units_attr_.Clear();
|
|
}
|
|
inline int32_t LayerQuantizeParams_WinogradParams::_internal_units_attr(int index) const {
|
|
return units_attr_.Get(index);
|
|
}
|
|
inline int32_t LayerQuantizeParams_WinogradParams::units_attr(int index) const {
|
|
// @@protoc_insertion_point(field_get:MNN.Compression.LayerQuantizeParams.WinogradParams.units_attr)
|
|
return _internal_units_attr(index);
|
|
}
|
|
inline void LayerQuantizeParams_WinogradParams::set_units_attr(int index, int32_t value) {
|
|
units_attr_.Set(index, value);
|
|
// @@protoc_insertion_point(field_set:MNN.Compression.LayerQuantizeParams.WinogradParams.units_attr)
|
|
}
|
|
inline void LayerQuantizeParams_WinogradParams::_internal_add_units_attr(int32_t value) {
|
|
units_attr_.Add(value);
|
|
}
|
|
inline void LayerQuantizeParams_WinogradParams::add_units_attr(int32_t value) {
|
|
_internal_add_units_attr(value);
|
|
// @@protoc_insertion_point(field_add:MNN.Compression.LayerQuantizeParams.WinogradParams.units_attr)
|
|
}
|
|
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
|
|
LayerQuantizeParams_WinogradParams::_internal_units_attr() const {
|
|
return units_attr_;
|
|
}
|
|
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
|
|
LayerQuantizeParams_WinogradParams::units_attr() const {
|
|
// @@protoc_insertion_point(field_list:MNN.Compression.LayerQuantizeParams.WinogradParams.units_attr)
|
|
return _internal_units_attr();
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
|
|
LayerQuantizeParams_WinogradParams::_internal_mutable_units_attr() {
|
|
return &units_attr_;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
|
|
LayerQuantizeParams_WinogradParams::mutable_units_attr() {
|
|
// @@protoc_insertion_point(field_mutable_list:MNN.Compression.LayerQuantizeParams.WinogradParams.units_attr)
|
|
return _internal_mutable_units_attr();
|
|
}
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// LayerQuantizeParams_ConvolutionInfo
|
|
|
|
// required int32 input_channel = 1;
|
|
inline bool LayerQuantizeParams_ConvolutionInfo::_internal_has_input_channel() const {
|
|
bool value = (_has_bits_[0] & 0x00000001u) != 0;
|
|
return value;
|
|
}
|
|
inline bool LayerQuantizeParams_ConvolutionInfo::has_input_channel() const {
|
|
return _internal_has_input_channel();
|
|
}
|
|
inline void LayerQuantizeParams_ConvolutionInfo::clear_input_channel() {
|
|
input_channel_ = 0;
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
inline int32_t LayerQuantizeParams_ConvolutionInfo::_internal_input_channel() const {
|
|
return input_channel_;
|
|
}
|
|
inline int32_t LayerQuantizeParams_ConvolutionInfo::input_channel() const {
|
|
// @@protoc_insertion_point(field_get:MNN.Compression.LayerQuantizeParams.ConvolutionInfo.input_channel)
|
|
return _internal_input_channel();
|
|
}
|
|
inline void LayerQuantizeParams_ConvolutionInfo::_internal_set_input_channel(int32_t value) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
input_channel_ = value;
|
|
}
|
|
inline void LayerQuantizeParams_ConvolutionInfo::set_input_channel(int32_t value) {
|
|
_internal_set_input_channel(value);
|
|
// @@protoc_insertion_point(field_set:MNN.Compression.LayerQuantizeParams.ConvolutionInfo.input_channel)
|
|
}
|
|
|
|
// required int32 output_channel = 2;
|
|
inline bool LayerQuantizeParams_ConvolutionInfo::_internal_has_output_channel() const {
|
|
bool value = (_has_bits_[0] & 0x00000002u) != 0;
|
|
return value;
|
|
}
|
|
inline bool LayerQuantizeParams_ConvolutionInfo::has_output_channel() const {
|
|
return _internal_has_output_channel();
|
|
}
|
|
inline void LayerQuantizeParams_ConvolutionInfo::clear_output_channel() {
|
|
output_channel_ = 0;
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
}
|
|
inline int32_t LayerQuantizeParams_ConvolutionInfo::_internal_output_channel() const {
|
|
return output_channel_;
|
|
}
|
|
inline int32_t LayerQuantizeParams_ConvolutionInfo::output_channel() const {
|
|
// @@protoc_insertion_point(field_get:MNN.Compression.LayerQuantizeParams.ConvolutionInfo.output_channel)
|
|
return _internal_output_channel();
|
|
}
|
|
inline void LayerQuantizeParams_ConvolutionInfo::_internal_set_output_channel(int32_t value) {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
output_channel_ = value;
|
|
}
|
|
inline void LayerQuantizeParams_ConvolutionInfo::set_output_channel(int32_t value) {
|
|
_internal_set_output_channel(value);
|
|
// @@protoc_insertion_point(field_set:MNN.Compression.LayerQuantizeParams.ConvolutionInfo.output_channel)
|
|
}
|
|
|
|
// repeated int32 kernel_size = 3;
|
|
inline int LayerQuantizeParams_ConvolutionInfo::_internal_kernel_size_size() const {
|
|
return kernel_size_.size();
|
|
}
|
|
inline int LayerQuantizeParams_ConvolutionInfo::kernel_size_size() const {
|
|
return _internal_kernel_size_size();
|
|
}
|
|
inline void LayerQuantizeParams_ConvolutionInfo::clear_kernel_size() {
|
|
kernel_size_.Clear();
|
|
}
|
|
inline int32_t LayerQuantizeParams_ConvolutionInfo::_internal_kernel_size(int index) const {
|
|
return kernel_size_.Get(index);
|
|
}
|
|
inline int32_t LayerQuantizeParams_ConvolutionInfo::kernel_size(int index) const {
|
|
// @@protoc_insertion_point(field_get:MNN.Compression.LayerQuantizeParams.ConvolutionInfo.kernel_size)
|
|
return _internal_kernel_size(index);
|
|
}
|
|
inline void LayerQuantizeParams_ConvolutionInfo::set_kernel_size(int index, int32_t value) {
|
|
kernel_size_.Set(index, value);
|
|
// @@protoc_insertion_point(field_set:MNN.Compression.LayerQuantizeParams.ConvolutionInfo.kernel_size)
|
|
}
|
|
inline void LayerQuantizeParams_ConvolutionInfo::_internal_add_kernel_size(int32_t value) {
|
|
kernel_size_.Add(value);
|
|
}
|
|
inline void LayerQuantizeParams_ConvolutionInfo::add_kernel_size(int32_t value) {
|
|
_internal_add_kernel_size(value);
|
|
// @@protoc_insertion_point(field_add:MNN.Compression.LayerQuantizeParams.ConvolutionInfo.kernel_size)
|
|
}
|
|
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
|
|
LayerQuantizeParams_ConvolutionInfo::_internal_kernel_size() const {
|
|
return kernel_size_;
|
|
}
|
|
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
|
|
LayerQuantizeParams_ConvolutionInfo::kernel_size() const {
|
|
// @@protoc_insertion_point(field_list:MNN.Compression.LayerQuantizeParams.ConvolutionInfo.kernel_size)
|
|
return _internal_kernel_size();
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
|
|
LayerQuantizeParams_ConvolutionInfo::_internal_mutable_kernel_size() {
|
|
return &kernel_size_;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
|
|
LayerQuantizeParams_ConvolutionInfo::mutable_kernel_size() {
|
|
// @@protoc_insertion_point(field_mutable_list:MNN.Compression.LayerQuantizeParams.ConvolutionInfo.kernel_size)
|
|
return _internal_mutable_kernel_size();
|
|
}
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// LayerQuantizeParams
|
|
|
|
// repeated .MNN.Compression.LayerQuantizeParams.ActivationParams input = 1;
|
|
inline int LayerQuantizeParams::_internal_input_size() const {
|
|
return input_.size();
|
|
}
|
|
inline int LayerQuantizeParams::input_size() const {
|
|
return _internal_input_size();
|
|
}
|
|
inline void LayerQuantizeParams::clear_input() {
|
|
input_.Clear();
|
|
}
|
|
inline ::MNN::Compression::LayerQuantizeParams_ActivationParams* LayerQuantizeParams::mutable_input(int index) {
|
|
// @@protoc_insertion_point(field_mutable:MNN.Compression.LayerQuantizeParams.input)
|
|
return input_.Mutable(index);
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MNN::Compression::LayerQuantizeParams_ActivationParams >*
|
|
LayerQuantizeParams::mutable_input() {
|
|
// @@protoc_insertion_point(field_mutable_list:MNN.Compression.LayerQuantizeParams.input)
|
|
return &input_;
|
|
}
|
|
inline const ::MNN::Compression::LayerQuantizeParams_ActivationParams& LayerQuantizeParams::_internal_input(int index) const {
|
|
return input_.Get(index);
|
|
}
|
|
inline const ::MNN::Compression::LayerQuantizeParams_ActivationParams& LayerQuantizeParams::input(int index) const {
|
|
// @@protoc_insertion_point(field_get:MNN.Compression.LayerQuantizeParams.input)
|
|
return _internal_input(index);
|
|
}
|
|
inline ::MNN::Compression::LayerQuantizeParams_ActivationParams* LayerQuantizeParams::_internal_add_input() {
|
|
return input_.Add();
|
|
}
|
|
inline ::MNN::Compression::LayerQuantizeParams_ActivationParams* LayerQuantizeParams::add_input() {
|
|
::MNN::Compression::LayerQuantizeParams_ActivationParams* _add = _internal_add_input();
|
|
// @@protoc_insertion_point(field_add:MNN.Compression.LayerQuantizeParams.input)
|
|
return _add;
|
|
}
|
|
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MNN::Compression::LayerQuantizeParams_ActivationParams >&
|
|
LayerQuantizeParams::input() const {
|
|
// @@protoc_insertion_point(field_list:MNN.Compression.LayerQuantizeParams.input)
|
|
return input_;
|
|
}
|
|
|
|
// repeated .MNN.Compression.LayerQuantizeParams.WeightParams weight = 2;
|
|
inline int LayerQuantizeParams::_internal_weight_size() const {
|
|
return weight_.size();
|
|
}
|
|
inline int LayerQuantizeParams::weight_size() const {
|
|
return _internal_weight_size();
|
|
}
|
|
inline void LayerQuantizeParams::clear_weight() {
|
|
weight_.Clear();
|
|
}
|
|
inline ::MNN::Compression::LayerQuantizeParams_WeightParams* LayerQuantizeParams::mutable_weight(int index) {
|
|
// @@protoc_insertion_point(field_mutable:MNN.Compression.LayerQuantizeParams.weight)
|
|
return weight_.Mutable(index);
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MNN::Compression::LayerQuantizeParams_WeightParams >*
|
|
LayerQuantizeParams::mutable_weight() {
|
|
// @@protoc_insertion_point(field_mutable_list:MNN.Compression.LayerQuantizeParams.weight)
|
|
return &weight_;
|
|
}
|
|
inline const ::MNN::Compression::LayerQuantizeParams_WeightParams& LayerQuantizeParams::_internal_weight(int index) const {
|
|
return weight_.Get(index);
|
|
}
|
|
inline const ::MNN::Compression::LayerQuantizeParams_WeightParams& LayerQuantizeParams::weight(int index) const {
|
|
// @@protoc_insertion_point(field_get:MNN.Compression.LayerQuantizeParams.weight)
|
|
return _internal_weight(index);
|
|
}
|
|
inline ::MNN::Compression::LayerQuantizeParams_WeightParams* LayerQuantizeParams::_internal_add_weight() {
|
|
return weight_.Add();
|
|
}
|
|
inline ::MNN::Compression::LayerQuantizeParams_WeightParams* LayerQuantizeParams::add_weight() {
|
|
::MNN::Compression::LayerQuantizeParams_WeightParams* _add = _internal_add_weight();
|
|
// @@protoc_insertion_point(field_add:MNN.Compression.LayerQuantizeParams.weight)
|
|
return _add;
|
|
}
|
|
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MNN::Compression::LayerQuantizeParams_WeightParams >&
|
|
LayerQuantizeParams::weight() const {
|
|
// @@protoc_insertion_point(field_list:MNN.Compression.LayerQuantizeParams.weight)
|
|
return weight_;
|
|
}
|
|
|
|
// repeated .MNN.Compression.LayerQuantizeParams.ActivationParams output = 3;
|
|
inline int LayerQuantizeParams::_internal_output_size() const {
|
|
return output_.size();
|
|
}
|
|
inline int LayerQuantizeParams::output_size() const {
|
|
return _internal_output_size();
|
|
}
|
|
inline void LayerQuantizeParams::clear_output() {
|
|
output_.Clear();
|
|
}
|
|
inline ::MNN::Compression::LayerQuantizeParams_ActivationParams* LayerQuantizeParams::mutable_output(int index) {
|
|
// @@protoc_insertion_point(field_mutable:MNN.Compression.LayerQuantizeParams.output)
|
|
return output_.Mutable(index);
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MNN::Compression::LayerQuantizeParams_ActivationParams >*
|
|
LayerQuantizeParams::mutable_output() {
|
|
// @@protoc_insertion_point(field_mutable_list:MNN.Compression.LayerQuantizeParams.output)
|
|
return &output_;
|
|
}
|
|
inline const ::MNN::Compression::LayerQuantizeParams_ActivationParams& LayerQuantizeParams::_internal_output(int index) const {
|
|
return output_.Get(index);
|
|
}
|
|
inline const ::MNN::Compression::LayerQuantizeParams_ActivationParams& LayerQuantizeParams::output(int index) const {
|
|
// @@protoc_insertion_point(field_get:MNN.Compression.LayerQuantizeParams.output)
|
|
return _internal_output(index);
|
|
}
|
|
inline ::MNN::Compression::LayerQuantizeParams_ActivationParams* LayerQuantizeParams::_internal_add_output() {
|
|
return output_.Add();
|
|
}
|
|
inline ::MNN::Compression::LayerQuantizeParams_ActivationParams* LayerQuantizeParams::add_output() {
|
|
::MNN::Compression::LayerQuantizeParams_ActivationParams* _add = _internal_add_output();
|
|
// @@protoc_insertion_point(field_add:MNN.Compression.LayerQuantizeParams.output)
|
|
return _add;
|
|
}
|
|
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MNN::Compression::LayerQuantizeParams_ActivationParams >&
|
|
LayerQuantizeParams::output() const {
|
|
// @@protoc_insertion_point(field_list:MNN.Compression.LayerQuantizeParams.output)
|
|
return output_;
|
|
}
|
|
|
|
// optional .MNN.Compression.LayerQuantizeParams.QuantMethod method = 4 [default = QAT];
|
|
inline bool LayerQuantizeParams::_internal_has_method() const {
|
|
bool value = (_has_bits_[0] & 0x00000010u) != 0;
|
|
return value;
|
|
}
|
|
inline bool LayerQuantizeParams::has_method() const {
|
|
return _internal_has_method();
|
|
}
|
|
inline void LayerQuantizeParams::clear_method() {
|
|
method_ = 0;
|
|
_has_bits_[0] &= ~0x00000010u;
|
|
}
|
|
inline ::MNN::Compression::LayerQuantizeParams_QuantMethod LayerQuantizeParams::_internal_method() const {
|
|
return static_cast< ::MNN::Compression::LayerQuantizeParams_QuantMethod >(method_);
|
|
}
|
|
inline ::MNN::Compression::LayerQuantizeParams_QuantMethod LayerQuantizeParams::method() const {
|
|
// @@protoc_insertion_point(field_get:MNN.Compression.LayerQuantizeParams.method)
|
|
return _internal_method();
|
|
}
|
|
inline void LayerQuantizeParams::_internal_set_method(::MNN::Compression::LayerQuantizeParams_QuantMethod value) {
|
|
assert(::MNN::Compression::LayerQuantizeParams_QuantMethod_IsValid(value));
|
|
_has_bits_[0] |= 0x00000010u;
|
|
method_ = value;
|
|
}
|
|
inline void LayerQuantizeParams::set_method(::MNN::Compression::LayerQuantizeParams_QuantMethod value) {
|
|
_internal_set_method(value);
|
|
// @@protoc_insertion_point(field_set:MNN.Compression.LayerQuantizeParams.method)
|
|
}
|
|
|
|
// optional .MNN.Compression.LayerQuantizeParams.WinogradParams wino_params = 5;
|
|
inline bool LayerQuantizeParams::_internal_has_wino_params() const {
|
|
bool value = (_has_bits_[0] & 0x00000004u) != 0;
|
|
PROTOBUF_ASSUME(!value || wino_params_ != nullptr);
|
|
return value;
|
|
}
|
|
inline bool LayerQuantizeParams::has_wino_params() const {
|
|
return _internal_has_wino_params();
|
|
}
|
|
inline void LayerQuantizeParams::clear_wino_params() {
|
|
if (wino_params_ != nullptr) wino_params_->Clear();
|
|
_has_bits_[0] &= ~0x00000004u;
|
|
}
|
|
inline const ::MNN::Compression::LayerQuantizeParams_WinogradParams& LayerQuantizeParams::_internal_wino_params() const {
|
|
const ::MNN::Compression::LayerQuantizeParams_WinogradParams* p = wino_params_;
|
|
return p != nullptr ? *p : reinterpret_cast<const ::MNN::Compression::LayerQuantizeParams_WinogradParams&>(
|
|
::MNN::Compression::_LayerQuantizeParams_WinogradParams_default_instance_);
|
|
}
|
|
inline const ::MNN::Compression::LayerQuantizeParams_WinogradParams& LayerQuantizeParams::wino_params() const {
|
|
// @@protoc_insertion_point(field_get:MNN.Compression.LayerQuantizeParams.wino_params)
|
|
return _internal_wino_params();
|
|
}
|
|
inline void LayerQuantizeParams::unsafe_arena_set_allocated_wino_params(
|
|
::MNN::Compression::LayerQuantizeParams_WinogradParams* wino_params) {
|
|
if (GetArenaForAllocation() == nullptr) {
|
|
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(wino_params_);
|
|
}
|
|
wino_params_ = wino_params;
|
|
if (wino_params) {
|
|
_has_bits_[0] |= 0x00000004u;
|
|
} else {
|
|
_has_bits_[0] &= ~0x00000004u;
|
|
}
|
|
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:MNN.Compression.LayerQuantizeParams.wino_params)
|
|
}
|
|
inline ::MNN::Compression::LayerQuantizeParams_WinogradParams* LayerQuantizeParams::release_wino_params() {
|
|
_has_bits_[0] &= ~0x00000004u;
|
|
::MNN::Compression::LayerQuantizeParams_WinogradParams* temp = wino_params_;
|
|
wino_params_ = 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 ::MNN::Compression::LayerQuantizeParams_WinogradParams* LayerQuantizeParams::unsafe_arena_release_wino_params() {
|
|
// @@protoc_insertion_point(field_release:MNN.Compression.LayerQuantizeParams.wino_params)
|
|
_has_bits_[0] &= ~0x00000004u;
|
|
::MNN::Compression::LayerQuantizeParams_WinogradParams* temp = wino_params_;
|
|
wino_params_ = nullptr;
|
|
return temp;
|
|
}
|
|
inline ::MNN::Compression::LayerQuantizeParams_WinogradParams* LayerQuantizeParams::_internal_mutable_wino_params() {
|
|
_has_bits_[0] |= 0x00000004u;
|
|
if (wino_params_ == nullptr) {
|
|
auto* p = CreateMaybeMessage<::MNN::Compression::LayerQuantizeParams_WinogradParams>(GetArenaForAllocation());
|
|
wino_params_ = p;
|
|
}
|
|
return wino_params_;
|
|
}
|
|
inline ::MNN::Compression::LayerQuantizeParams_WinogradParams* LayerQuantizeParams::mutable_wino_params() {
|
|
::MNN::Compression::LayerQuantizeParams_WinogradParams* _msg = _internal_mutable_wino_params();
|
|
// @@protoc_insertion_point(field_mutable:MNN.Compression.LayerQuantizeParams.wino_params)
|
|
return _msg;
|
|
}
|
|
inline void LayerQuantizeParams::set_allocated_wino_params(::MNN::Compression::LayerQuantizeParams_WinogradParams* wino_params) {
|
|
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
|
|
if (message_arena == nullptr) {
|
|
delete wino_params_;
|
|
}
|
|
if (wino_params) {
|
|
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
|
|
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::MNN::Compression::LayerQuantizeParams_WinogradParams>::GetOwningArena(wino_params);
|
|
if (message_arena != submessage_arena) {
|
|
wino_params = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
|
|
message_arena, wino_params, submessage_arena);
|
|
}
|
|
_has_bits_[0] |= 0x00000004u;
|
|
} else {
|
|
_has_bits_[0] &= ~0x00000004u;
|
|
}
|
|
wino_params_ = wino_params;
|
|
// @@protoc_insertion_point(field_set_allocated:MNN.Compression.LayerQuantizeParams.wino_params)
|
|
}
|
|
|
|
// optional string op_name = 6;
|
|
inline bool LayerQuantizeParams::_internal_has_op_name() const {
|
|
bool value = (_has_bits_[0] & 0x00000001u) != 0;
|
|
return value;
|
|
}
|
|
inline bool LayerQuantizeParams::has_op_name() const {
|
|
return _internal_has_op_name();
|
|
}
|
|
inline void LayerQuantizeParams::clear_op_name() {
|
|
op_name_.ClearToEmpty();
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
inline const std::string& LayerQuantizeParams::op_name() const {
|
|
// @@protoc_insertion_point(field_get:MNN.Compression.LayerQuantizeParams.op_name)
|
|
return _internal_op_name();
|
|
}
|
|
template <typename ArgT0, typename... ArgT>
|
|
inline PROTOBUF_ALWAYS_INLINE
|
|
void LayerQuantizeParams::set_op_name(ArgT0&& arg0, ArgT... args) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
op_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set:MNN.Compression.LayerQuantizeParams.op_name)
|
|
}
|
|
inline std::string* LayerQuantizeParams::mutable_op_name() {
|
|
std::string* _s = _internal_mutable_op_name();
|
|
// @@protoc_insertion_point(field_mutable:MNN.Compression.LayerQuantizeParams.op_name)
|
|
return _s;
|
|
}
|
|
inline const std::string& LayerQuantizeParams::_internal_op_name() const {
|
|
return op_name_.Get();
|
|
}
|
|
inline void LayerQuantizeParams::_internal_set_op_name(const std::string& value) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
op_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
|
|
}
|
|
inline std::string* LayerQuantizeParams::_internal_mutable_op_name() {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
return op_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
|
|
}
|
|
inline std::string* LayerQuantizeParams::release_op_name() {
|
|
// @@protoc_insertion_point(field_release:MNN.Compression.LayerQuantizeParams.op_name)
|
|
if (!_internal_has_op_name()) {
|
|
return nullptr;
|
|
}
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
auto* p = op_name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
|
|
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
if (op_name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
|
|
op_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
|
|
}
|
|
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
return p;
|
|
}
|
|
inline void LayerQuantizeParams::set_allocated_op_name(std::string* op_name) {
|
|
if (op_name != nullptr) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
} else {
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
op_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), op_name,
|
|
GetArenaForAllocation());
|
|
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
if (op_name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
|
|
op_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
|
|
}
|
|
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
// @@protoc_insertion_point(field_set_allocated:MNN.Compression.LayerQuantizeParams.op_name)
|
|
}
|
|
|
|
// optional string subgraph_name = 7;
|
|
inline bool LayerQuantizeParams::_internal_has_subgraph_name() const {
|
|
bool value = (_has_bits_[0] & 0x00000002u) != 0;
|
|
return value;
|
|
}
|
|
inline bool LayerQuantizeParams::has_subgraph_name() const {
|
|
return _internal_has_subgraph_name();
|
|
}
|
|
inline void LayerQuantizeParams::clear_subgraph_name() {
|
|
subgraph_name_.ClearToEmpty();
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
}
|
|
inline const std::string& LayerQuantizeParams::subgraph_name() const {
|
|
// @@protoc_insertion_point(field_get:MNN.Compression.LayerQuantizeParams.subgraph_name)
|
|
return _internal_subgraph_name();
|
|
}
|
|
template <typename ArgT0, typename... ArgT>
|
|
inline PROTOBUF_ALWAYS_INLINE
|
|
void LayerQuantizeParams::set_subgraph_name(ArgT0&& arg0, ArgT... args) {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
subgraph_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set:MNN.Compression.LayerQuantizeParams.subgraph_name)
|
|
}
|
|
inline std::string* LayerQuantizeParams::mutable_subgraph_name() {
|
|
std::string* _s = _internal_mutable_subgraph_name();
|
|
// @@protoc_insertion_point(field_mutable:MNN.Compression.LayerQuantizeParams.subgraph_name)
|
|
return _s;
|
|
}
|
|
inline const std::string& LayerQuantizeParams::_internal_subgraph_name() const {
|
|
return subgraph_name_.Get();
|
|
}
|
|
inline void LayerQuantizeParams::_internal_set_subgraph_name(const std::string& value) {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
subgraph_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
|
|
}
|
|
inline std::string* LayerQuantizeParams::_internal_mutable_subgraph_name() {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
return subgraph_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
|
|
}
|
|
inline std::string* LayerQuantizeParams::release_subgraph_name() {
|
|
// @@protoc_insertion_point(field_release:MNN.Compression.LayerQuantizeParams.subgraph_name)
|
|
if (!_internal_has_subgraph_name()) {
|
|
return nullptr;
|
|
}
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
auto* p = subgraph_name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
|
|
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
if (subgraph_name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
|
|
subgraph_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
|
|
}
|
|
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
return p;
|
|
}
|
|
inline void LayerQuantizeParams::set_allocated_subgraph_name(std::string* subgraph_name) {
|
|
if (subgraph_name != nullptr) {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
} else {
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
}
|
|
subgraph_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), subgraph_name,
|
|
GetArenaForAllocation());
|
|
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
if (subgraph_name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
|
|
subgraph_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
|
|
}
|
|
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
// @@protoc_insertion_point(field_set_allocated:MNN.Compression.LayerQuantizeParams.subgraph_name)
|
|
}
|
|
|
|
// optional .MNN.Compression.LayerQuantizeParams.ConvolutionInfo conv = 8;
|
|
inline bool LayerQuantizeParams::_internal_has_conv() const {
|
|
bool value = (_has_bits_[0] & 0x00000008u) != 0;
|
|
PROTOBUF_ASSUME(!value || conv_ != nullptr);
|
|
return value;
|
|
}
|
|
inline bool LayerQuantizeParams::has_conv() const {
|
|
return _internal_has_conv();
|
|
}
|
|
inline void LayerQuantizeParams::clear_conv() {
|
|
if (conv_ != nullptr) conv_->Clear();
|
|
_has_bits_[0] &= ~0x00000008u;
|
|
}
|
|
inline const ::MNN::Compression::LayerQuantizeParams_ConvolutionInfo& LayerQuantizeParams::_internal_conv() const {
|
|
const ::MNN::Compression::LayerQuantizeParams_ConvolutionInfo* p = conv_;
|
|
return p != nullptr ? *p : reinterpret_cast<const ::MNN::Compression::LayerQuantizeParams_ConvolutionInfo&>(
|
|
::MNN::Compression::_LayerQuantizeParams_ConvolutionInfo_default_instance_);
|
|
}
|
|
inline const ::MNN::Compression::LayerQuantizeParams_ConvolutionInfo& LayerQuantizeParams::conv() const {
|
|
// @@protoc_insertion_point(field_get:MNN.Compression.LayerQuantizeParams.conv)
|
|
return _internal_conv();
|
|
}
|
|
inline void LayerQuantizeParams::unsafe_arena_set_allocated_conv(
|
|
::MNN::Compression::LayerQuantizeParams_ConvolutionInfo* conv) {
|
|
if (GetArenaForAllocation() == nullptr) {
|
|
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(conv_);
|
|
}
|
|
conv_ = conv;
|
|
if (conv) {
|
|
_has_bits_[0] |= 0x00000008u;
|
|
} else {
|
|
_has_bits_[0] &= ~0x00000008u;
|
|
}
|
|
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:MNN.Compression.LayerQuantizeParams.conv)
|
|
}
|
|
inline ::MNN::Compression::LayerQuantizeParams_ConvolutionInfo* LayerQuantizeParams::release_conv() {
|
|
_has_bits_[0] &= ~0x00000008u;
|
|
::MNN::Compression::LayerQuantizeParams_ConvolutionInfo* temp = conv_;
|
|
conv_ = 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 ::MNN::Compression::LayerQuantizeParams_ConvolutionInfo* LayerQuantizeParams::unsafe_arena_release_conv() {
|
|
// @@protoc_insertion_point(field_release:MNN.Compression.LayerQuantizeParams.conv)
|
|
_has_bits_[0] &= ~0x00000008u;
|
|
::MNN::Compression::LayerQuantizeParams_ConvolutionInfo* temp = conv_;
|
|
conv_ = nullptr;
|
|
return temp;
|
|
}
|
|
inline ::MNN::Compression::LayerQuantizeParams_ConvolutionInfo* LayerQuantizeParams::_internal_mutable_conv() {
|
|
_has_bits_[0] |= 0x00000008u;
|
|
if (conv_ == nullptr) {
|
|
auto* p = CreateMaybeMessage<::MNN::Compression::LayerQuantizeParams_ConvolutionInfo>(GetArenaForAllocation());
|
|
conv_ = p;
|
|
}
|
|
return conv_;
|
|
}
|
|
inline ::MNN::Compression::LayerQuantizeParams_ConvolutionInfo* LayerQuantizeParams::mutable_conv() {
|
|
::MNN::Compression::LayerQuantizeParams_ConvolutionInfo* _msg = _internal_mutable_conv();
|
|
// @@protoc_insertion_point(field_mutable:MNN.Compression.LayerQuantizeParams.conv)
|
|
return _msg;
|
|
}
|
|
inline void LayerQuantizeParams::set_allocated_conv(::MNN::Compression::LayerQuantizeParams_ConvolutionInfo* conv) {
|
|
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
|
|
if (message_arena == nullptr) {
|
|
delete conv_;
|
|
}
|
|
if (conv) {
|
|
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
|
|
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::MNN::Compression::LayerQuantizeParams_ConvolutionInfo>::GetOwningArena(conv);
|
|
if (message_arena != submessage_arena) {
|
|
conv = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
|
|
message_arena, conv, submessage_arena);
|
|
}
|
|
_has_bits_[0] |= 0x00000008u;
|
|
} else {
|
|
_has_bits_[0] &= ~0x00000008u;
|
|
}
|
|
conv_ = conv;
|
|
// @@protoc_insertion_point(field_set_allocated:MNN.Compression.LayerQuantizeParams.conv)
|
|
}
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// LevelPrunerParams
|
|
|
|
// repeated string weight_tensor_names = 1;
|
|
inline int LevelPrunerParams::_internal_weight_tensor_names_size() const {
|
|
return weight_tensor_names_.size();
|
|
}
|
|
inline int LevelPrunerParams::weight_tensor_names_size() const {
|
|
return _internal_weight_tensor_names_size();
|
|
}
|
|
inline void LevelPrunerParams::clear_weight_tensor_names() {
|
|
weight_tensor_names_.Clear();
|
|
}
|
|
inline std::string* LevelPrunerParams::add_weight_tensor_names() {
|
|
std::string* _s = _internal_add_weight_tensor_names();
|
|
// @@protoc_insertion_point(field_add_mutable:MNN.Compression.LevelPrunerParams.weight_tensor_names)
|
|
return _s;
|
|
}
|
|
inline const std::string& LevelPrunerParams::_internal_weight_tensor_names(int index) const {
|
|
return weight_tensor_names_.Get(index);
|
|
}
|
|
inline const std::string& LevelPrunerParams::weight_tensor_names(int index) const {
|
|
// @@protoc_insertion_point(field_get:MNN.Compression.LevelPrunerParams.weight_tensor_names)
|
|
return _internal_weight_tensor_names(index);
|
|
}
|
|
inline std::string* LevelPrunerParams::mutable_weight_tensor_names(int index) {
|
|
// @@protoc_insertion_point(field_mutable:MNN.Compression.LevelPrunerParams.weight_tensor_names)
|
|
return weight_tensor_names_.Mutable(index);
|
|
}
|
|
inline void LevelPrunerParams::set_weight_tensor_names(int index, const std::string& value) {
|
|
weight_tensor_names_.Mutable(index)->assign(value);
|
|
// @@protoc_insertion_point(field_set:MNN.Compression.LevelPrunerParams.weight_tensor_names)
|
|
}
|
|
inline void LevelPrunerParams::set_weight_tensor_names(int index, std::string&& value) {
|
|
weight_tensor_names_.Mutable(index)->assign(std::move(value));
|
|
// @@protoc_insertion_point(field_set:MNN.Compression.LevelPrunerParams.weight_tensor_names)
|
|
}
|
|
inline void LevelPrunerParams::set_weight_tensor_names(int index, const char* value) {
|
|
GOOGLE_DCHECK(value != nullptr);
|
|
weight_tensor_names_.Mutable(index)->assign(value);
|
|
// @@protoc_insertion_point(field_set_char:MNN.Compression.LevelPrunerParams.weight_tensor_names)
|
|
}
|
|
inline void LevelPrunerParams::set_weight_tensor_names(int index, const char* value, size_t size) {
|
|
weight_tensor_names_.Mutable(index)->assign(
|
|
reinterpret_cast<const char*>(value), size);
|
|
// @@protoc_insertion_point(field_set_pointer:MNN.Compression.LevelPrunerParams.weight_tensor_names)
|
|
}
|
|
inline std::string* LevelPrunerParams::_internal_add_weight_tensor_names() {
|
|
return weight_tensor_names_.Add();
|
|
}
|
|
inline void LevelPrunerParams::add_weight_tensor_names(const std::string& value) {
|
|
weight_tensor_names_.Add()->assign(value);
|
|
// @@protoc_insertion_point(field_add:MNN.Compression.LevelPrunerParams.weight_tensor_names)
|
|
}
|
|
inline void LevelPrunerParams::add_weight_tensor_names(std::string&& value) {
|
|
weight_tensor_names_.Add(std::move(value));
|
|
// @@protoc_insertion_point(field_add:MNN.Compression.LevelPrunerParams.weight_tensor_names)
|
|
}
|
|
inline void LevelPrunerParams::add_weight_tensor_names(const char* value) {
|
|
GOOGLE_DCHECK(value != nullptr);
|
|
weight_tensor_names_.Add()->assign(value);
|
|
// @@protoc_insertion_point(field_add_char:MNN.Compression.LevelPrunerParams.weight_tensor_names)
|
|
}
|
|
inline void LevelPrunerParams::add_weight_tensor_names(const char* value, size_t size) {
|
|
weight_tensor_names_.Add()->assign(reinterpret_cast<const char*>(value), size);
|
|
// @@protoc_insertion_point(field_add_pointer:MNN.Compression.LevelPrunerParams.weight_tensor_names)
|
|
}
|
|
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
|
|
LevelPrunerParams::weight_tensor_names() const {
|
|
// @@protoc_insertion_point(field_list:MNN.Compression.LevelPrunerParams.weight_tensor_names)
|
|
return weight_tensor_names_;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
|
|
LevelPrunerParams::mutable_weight_tensor_names() {
|
|
// @@protoc_insertion_point(field_mutable_list:MNN.Compression.LevelPrunerParams.weight_tensor_names)
|
|
return &weight_tensor_names_;
|
|
}
|
|
|
|
// repeated float prune_ratios = 2;
|
|
inline int LevelPrunerParams::_internal_prune_ratios_size() const {
|
|
return prune_ratios_.size();
|
|
}
|
|
inline int LevelPrunerParams::prune_ratios_size() const {
|
|
return _internal_prune_ratios_size();
|
|
}
|
|
inline void LevelPrunerParams::clear_prune_ratios() {
|
|
prune_ratios_.Clear();
|
|
}
|
|
inline float LevelPrunerParams::_internal_prune_ratios(int index) const {
|
|
return prune_ratios_.Get(index);
|
|
}
|
|
inline float LevelPrunerParams::prune_ratios(int index) const {
|
|
// @@protoc_insertion_point(field_get:MNN.Compression.LevelPrunerParams.prune_ratios)
|
|
return _internal_prune_ratios(index);
|
|
}
|
|
inline void LevelPrunerParams::set_prune_ratios(int index, float value) {
|
|
prune_ratios_.Set(index, value);
|
|
// @@protoc_insertion_point(field_set:MNN.Compression.LevelPrunerParams.prune_ratios)
|
|
}
|
|
inline void LevelPrunerParams::_internal_add_prune_ratios(float value) {
|
|
prune_ratios_.Add(value);
|
|
}
|
|
inline void LevelPrunerParams::add_prune_ratios(float value) {
|
|
_internal_add_prune_ratios(value);
|
|
// @@protoc_insertion_point(field_add:MNN.Compression.LevelPrunerParams.prune_ratios)
|
|
}
|
|
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
|
|
LevelPrunerParams::_internal_prune_ratios() const {
|
|
return prune_ratios_;
|
|
}
|
|
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
|
|
LevelPrunerParams::prune_ratios() const {
|
|
// @@protoc_insertion_point(field_list:MNN.Compression.LevelPrunerParams.prune_ratios)
|
|
return _internal_prune_ratios();
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
|
|
LevelPrunerParams::_internal_mutable_prune_ratios() {
|
|
return &prune_ratios_;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
|
|
LevelPrunerParams::mutable_prune_ratios() {
|
|
// @@protoc_insertion_point(field_mutable_list:MNN.Compression.LevelPrunerParams.prune_ratios)
|
|
return _internal_mutable_prune_ratios();
|
|
}
|
|
|
|
// repeated string layer_names = 3;
|
|
inline int LevelPrunerParams::_internal_layer_names_size() const {
|
|
return layer_names_.size();
|
|
}
|
|
inline int LevelPrunerParams::layer_names_size() const {
|
|
return _internal_layer_names_size();
|
|
}
|
|
inline void LevelPrunerParams::clear_layer_names() {
|
|
layer_names_.Clear();
|
|
}
|
|
inline std::string* LevelPrunerParams::add_layer_names() {
|
|
std::string* _s = _internal_add_layer_names();
|
|
// @@protoc_insertion_point(field_add_mutable:MNN.Compression.LevelPrunerParams.layer_names)
|
|
return _s;
|
|
}
|
|
inline const std::string& LevelPrunerParams::_internal_layer_names(int index) const {
|
|
return layer_names_.Get(index);
|
|
}
|
|
inline const std::string& LevelPrunerParams::layer_names(int index) const {
|
|
// @@protoc_insertion_point(field_get:MNN.Compression.LevelPrunerParams.layer_names)
|
|
return _internal_layer_names(index);
|
|
}
|
|
inline std::string* LevelPrunerParams::mutable_layer_names(int index) {
|
|
// @@protoc_insertion_point(field_mutable:MNN.Compression.LevelPrunerParams.layer_names)
|
|
return layer_names_.Mutable(index);
|
|
}
|
|
inline void LevelPrunerParams::set_layer_names(int index, const std::string& value) {
|
|
layer_names_.Mutable(index)->assign(value);
|
|
// @@protoc_insertion_point(field_set:MNN.Compression.LevelPrunerParams.layer_names)
|
|
}
|
|
inline void LevelPrunerParams::set_layer_names(int index, std::string&& value) {
|
|
layer_names_.Mutable(index)->assign(std::move(value));
|
|
// @@protoc_insertion_point(field_set:MNN.Compression.LevelPrunerParams.layer_names)
|
|
}
|
|
inline void LevelPrunerParams::set_layer_names(int index, const char* value) {
|
|
GOOGLE_DCHECK(value != nullptr);
|
|
layer_names_.Mutable(index)->assign(value);
|
|
// @@protoc_insertion_point(field_set_char:MNN.Compression.LevelPrunerParams.layer_names)
|
|
}
|
|
inline void LevelPrunerParams::set_layer_names(int index, const char* value, size_t size) {
|
|
layer_names_.Mutable(index)->assign(
|
|
reinterpret_cast<const char*>(value), size);
|
|
// @@protoc_insertion_point(field_set_pointer:MNN.Compression.LevelPrunerParams.layer_names)
|
|
}
|
|
inline std::string* LevelPrunerParams::_internal_add_layer_names() {
|
|
return layer_names_.Add();
|
|
}
|
|
inline void LevelPrunerParams::add_layer_names(const std::string& value) {
|
|
layer_names_.Add()->assign(value);
|
|
// @@protoc_insertion_point(field_add:MNN.Compression.LevelPrunerParams.layer_names)
|
|
}
|
|
inline void LevelPrunerParams::add_layer_names(std::string&& value) {
|
|
layer_names_.Add(std::move(value));
|
|
// @@protoc_insertion_point(field_add:MNN.Compression.LevelPrunerParams.layer_names)
|
|
}
|
|
inline void LevelPrunerParams::add_layer_names(const char* value) {
|
|
GOOGLE_DCHECK(value != nullptr);
|
|
layer_names_.Add()->assign(value);
|
|
// @@protoc_insertion_point(field_add_char:MNN.Compression.LevelPrunerParams.layer_names)
|
|
}
|
|
inline void LevelPrunerParams::add_layer_names(const char* value, size_t size) {
|
|
layer_names_.Add()->assign(reinterpret_cast<const char*>(value), size);
|
|
// @@protoc_insertion_point(field_add_pointer:MNN.Compression.LevelPrunerParams.layer_names)
|
|
}
|
|
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
|
|
LevelPrunerParams::layer_names() const {
|
|
// @@protoc_insertion_point(field_list:MNN.Compression.LevelPrunerParams.layer_names)
|
|
return layer_names_;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
|
|
LevelPrunerParams::mutable_layer_names() {
|
|
// @@protoc_insertion_point(field_mutable_list:MNN.Compression.LevelPrunerParams.layer_names)
|
|
return &layer_names_;
|
|
}
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// SIMDOCPrunerParams
|
|
|
|
// repeated string weight_tensor_names = 1;
|
|
inline int SIMDOCPrunerParams::_internal_weight_tensor_names_size() const {
|
|
return weight_tensor_names_.size();
|
|
}
|
|
inline int SIMDOCPrunerParams::weight_tensor_names_size() const {
|
|
return _internal_weight_tensor_names_size();
|
|
}
|
|
inline void SIMDOCPrunerParams::clear_weight_tensor_names() {
|
|
weight_tensor_names_.Clear();
|
|
}
|
|
inline std::string* SIMDOCPrunerParams::add_weight_tensor_names() {
|
|
std::string* _s = _internal_add_weight_tensor_names();
|
|
// @@protoc_insertion_point(field_add_mutable:MNN.Compression.SIMDOCPrunerParams.weight_tensor_names)
|
|
return _s;
|
|
}
|
|
inline const std::string& SIMDOCPrunerParams::_internal_weight_tensor_names(int index) const {
|
|
return weight_tensor_names_.Get(index);
|
|
}
|
|
inline const std::string& SIMDOCPrunerParams::weight_tensor_names(int index) const {
|
|
// @@protoc_insertion_point(field_get:MNN.Compression.SIMDOCPrunerParams.weight_tensor_names)
|
|
return _internal_weight_tensor_names(index);
|
|
}
|
|
inline std::string* SIMDOCPrunerParams::mutable_weight_tensor_names(int index) {
|
|
// @@protoc_insertion_point(field_mutable:MNN.Compression.SIMDOCPrunerParams.weight_tensor_names)
|
|
return weight_tensor_names_.Mutable(index);
|
|
}
|
|
inline void SIMDOCPrunerParams::set_weight_tensor_names(int index, const std::string& value) {
|
|
weight_tensor_names_.Mutable(index)->assign(value);
|
|
// @@protoc_insertion_point(field_set:MNN.Compression.SIMDOCPrunerParams.weight_tensor_names)
|
|
}
|
|
inline void SIMDOCPrunerParams::set_weight_tensor_names(int index, std::string&& value) {
|
|
weight_tensor_names_.Mutable(index)->assign(std::move(value));
|
|
// @@protoc_insertion_point(field_set:MNN.Compression.SIMDOCPrunerParams.weight_tensor_names)
|
|
}
|
|
inline void SIMDOCPrunerParams::set_weight_tensor_names(int index, const char* value) {
|
|
GOOGLE_DCHECK(value != nullptr);
|
|
weight_tensor_names_.Mutable(index)->assign(value);
|
|
// @@protoc_insertion_point(field_set_char:MNN.Compression.SIMDOCPrunerParams.weight_tensor_names)
|
|
}
|
|
inline void SIMDOCPrunerParams::set_weight_tensor_names(int index, const char* value, size_t size) {
|
|
weight_tensor_names_.Mutable(index)->assign(
|
|
reinterpret_cast<const char*>(value), size);
|
|
// @@protoc_insertion_point(field_set_pointer:MNN.Compression.SIMDOCPrunerParams.weight_tensor_names)
|
|
}
|
|
inline std::string* SIMDOCPrunerParams::_internal_add_weight_tensor_names() {
|
|
return weight_tensor_names_.Add();
|
|
}
|
|
inline void SIMDOCPrunerParams::add_weight_tensor_names(const std::string& value) {
|
|
weight_tensor_names_.Add()->assign(value);
|
|
// @@protoc_insertion_point(field_add:MNN.Compression.SIMDOCPrunerParams.weight_tensor_names)
|
|
}
|
|
inline void SIMDOCPrunerParams::add_weight_tensor_names(std::string&& value) {
|
|
weight_tensor_names_.Add(std::move(value));
|
|
// @@protoc_insertion_point(field_add:MNN.Compression.SIMDOCPrunerParams.weight_tensor_names)
|
|
}
|
|
inline void SIMDOCPrunerParams::add_weight_tensor_names(const char* value) {
|
|
GOOGLE_DCHECK(value != nullptr);
|
|
weight_tensor_names_.Add()->assign(value);
|
|
// @@protoc_insertion_point(field_add_char:MNN.Compression.SIMDOCPrunerParams.weight_tensor_names)
|
|
}
|
|
inline void SIMDOCPrunerParams::add_weight_tensor_names(const char* value, size_t size) {
|
|
weight_tensor_names_.Add()->assign(reinterpret_cast<const char*>(value), size);
|
|
// @@protoc_insertion_point(field_add_pointer:MNN.Compression.SIMDOCPrunerParams.weight_tensor_names)
|
|
}
|
|
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
|
|
SIMDOCPrunerParams::weight_tensor_names() const {
|
|
// @@protoc_insertion_point(field_list:MNN.Compression.SIMDOCPrunerParams.weight_tensor_names)
|
|
return weight_tensor_names_;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
|
|
SIMDOCPrunerParams::mutable_weight_tensor_names() {
|
|
// @@protoc_insertion_point(field_mutable_list:MNN.Compression.SIMDOCPrunerParams.weight_tensor_names)
|
|
return &weight_tensor_names_;
|
|
}
|
|
|
|
// repeated float prune_ratios = 2;
|
|
inline int SIMDOCPrunerParams::_internal_prune_ratios_size() const {
|
|
return prune_ratios_.size();
|
|
}
|
|
inline int SIMDOCPrunerParams::prune_ratios_size() const {
|
|
return _internal_prune_ratios_size();
|
|
}
|
|
inline void SIMDOCPrunerParams::clear_prune_ratios() {
|
|
prune_ratios_.Clear();
|
|
}
|
|
inline float SIMDOCPrunerParams::_internal_prune_ratios(int index) const {
|
|
return prune_ratios_.Get(index);
|
|
}
|
|
inline float SIMDOCPrunerParams::prune_ratios(int index) const {
|
|
// @@protoc_insertion_point(field_get:MNN.Compression.SIMDOCPrunerParams.prune_ratios)
|
|
return _internal_prune_ratios(index);
|
|
}
|
|
inline void SIMDOCPrunerParams::set_prune_ratios(int index, float value) {
|
|
prune_ratios_.Set(index, value);
|
|
// @@protoc_insertion_point(field_set:MNN.Compression.SIMDOCPrunerParams.prune_ratios)
|
|
}
|
|
inline void SIMDOCPrunerParams::_internal_add_prune_ratios(float value) {
|
|
prune_ratios_.Add(value);
|
|
}
|
|
inline void SIMDOCPrunerParams::add_prune_ratios(float value) {
|
|
_internal_add_prune_ratios(value);
|
|
// @@protoc_insertion_point(field_add:MNN.Compression.SIMDOCPrunerParams.prune_ratios)
|
|
}
|
|
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
|
|
SIMDOCPrunerParams::_internal_prune_ratios() const {
|
|
return prune_ratios_;
|
|
}
|
|
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
|
|
SIMDOCPrunerParams::prune_ratios() const {
|
|
// @@protoc_insertion_point(field_list:MNN.Compression.SIMDOCPrunerParams.prune_ratios)
|
|
return _internal_prune_ratios();
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
|
|
SIMDOCPrunerParams::_internal_mutable_prune_ratios() {
|
|
return &prune_ratios_;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
|
|
SIMDOCPrunerParams::mutable_prune_ratios() {
|
|
// @@protoc_insertion_point(field_mutable_list:MNN.Compression.SIMDOCPrunerParams.prune_ratios)
|
|
return _internal_mutable_prune_ratios();
|
|
}
|
|
|
|
// repeated string layer_names = 3;
|
|
inline int SIMDOCPrunerParams::_internal_layer_names_size() const {
|
|
return layer_names_.size();
|
|
}
|
|
inline int SIMDOCPrunerParams::layer_names_size() const {
|
|
return _internal_layer_names_size();
|
|
}
|
|
inline void SIMDOCPrunerParams::clear_layer_names() {
|
|
layer_names_.Clear();
|
|
}
|
|
inline std::string* SIMDOCPrunerParams::add_layer_names() {
|
|
std::string* _s = _internal_add_layer_names();
|
|
// @@protoc_insertion_point(field_add_mutable:MNN.Compression.SIMDOCPrunerParams.layer_names)
|
|
return _s;
|
|
}
|
|
inline const std::string& SIMDOCPrunerParams::_internal_layer_names(int index) const {
|
|
return layer_names_.Get(index);
|
|
}
|
|
inline const std::string& SIMDOCPrunerParams::layer_names(int index) const {
|
|
// @@protoc_insertion_point(field_get:MNN.Compression.SIMDOCPrunerParams.layer_names)
|
|
return _internal_layer_names(index);
|
|
}
|
|
inline std::string* SIMDOCPrunerParams::mutable_layer_names(int index) {
|
|
// @@protoc_insertion_point(field_mutable:MNN.Compression.SIMDOCPrunerParams.layer_names)
|
|
return layer_names_.Mutable(index);
|
|
}
|
|
inline void SIMDOCPrunerParams::set_layer_names(int index, const std::string& value) {
|
|
layer_names_.Mutable(index)->assign(value);
|
|
// @@protoc_insertion_point(field_set:MNN.Compression.SIMDOCPrunerParams.layer_names)
|
|
}
|
|
inline void SIMDOCPrunerParams::set_layer_names(int index, std::string&& value) {
|
|
layer_names_.Mutable(index)->assign(std::move(value));
|
|
// @@protoc_insertion_point(field_set:MNN.Compression.SIMDOCPrunerParams.layer_names)
|
|
}
|
|
inline void SIMDOCPrunerParams::set_layer_names(int index, const char* value) {
|
|
GOOGLE_DCHECK(value != nullptr);
|
|
layer_names_.Mutable(index)->assign(value);
|
|
// @@protoc_insertion_point(field_set_char:MNN.Compression.SIMDOCPrunerParams.layer_names)
|
|
}
|
|
inline void SIMDOCPrunerParams::set_layer_names(int index, const char* value, size_t size) {
|
|
layer_names_.Mutable(index)->assign(
|
|
reinterpret_cast<const char*>(value), size);
|
|
// @@protoc_insertion_point(field_set_pointer:MNN.Compression.SIMDOCPrunerParams.layer_names)
|
|
}
|
|
inline std::string* SIMDOCPrunerParams::_internal_add_layer_names() {
|
|
return layer_names_.Add();
|
|
}
|
|
inline void SIMDOCPrunerParams::add_layer_names(const std::string& value) {
|
|
layer_names_.Add()->assign(value);
|
|
// @@protoc_insertion_point(field_add:MNN.Compression.SIMDOCPrunerParams.layer_names)
|
|
}
|
|
inline void SIMDOCPrunerParams::add_layer_names(std::string&& value) {
|
|
layer_names_.Add(std::move(value));
|
|
// @@protoc_insertion_point(field_add:MNN.Compression.SIMDOCPrunerParams.layer_names)
|
|
}
|
|
inline void SIMDOCPrunerParams::add_layer_names(const char* value) {
|
|
GOOGLE_DCHECK(value != nullptr);
|
|
layer_names_.Add()->assign(value);
|
|
// @@protoc_insertion_point(field_add_char:MNN.Compression.SIMDOCPrunerParams.layer_names)
|
|
}
|
|
inline void SIMDOCPrunerParams::add_layer_names(const char* value, size_t size) {
|
|
layer_names_.Add()->assign(reinterpret_cast<const char*>(value), size);
|
|
// @@protoc_insertion_point(field_add_pointer:MNN.Compression.SIMDOCPrunerParams.layer_names)
|
|
}
|
|
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
|
|
SIMDOCPrunerParams::layer_names() const {
|
|
// @@protoc_insertion_point(field_list:MNN.Compression.SIMDOCPrunerParams.layer_names)
|
|
return layer_names_;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
|
|
SIMDOCPrunerParams::mutable_layer_names() {
|
|
// @@protoc_insertion_point(field_mutable_list:MNN.Compression.SIMDOCPrunerParams.layer_names)
|
|
return &layer_names_;
|
|
}
|
|
|
|
// repeated int32 oc_blocks = 4;
|
|
inline int SIMDOCPrunerParams::_internal_oc_blocks_size() const {
|
|
return oc_blocks_.size();
|
|
}
|
|
inline int SIMDOCPrunerParams::oc_blocks_size() const {
|
|
return _internal_oc_blocks_size();
|
|
}
|
|
inline void SIMDOCPrunerParams::clear_oc_blocks() {
|
|
oc_blocks_.Clear();
|
|
}
|
|
inline int32_t SIMDOCPrunerParams::_internal_oc_blocks(int index) const {
|
|
return oc_blocks_.Get(index);
|
|
}
|
|
inline int32_t SIMDOCPrunerParams::oc_blocks(int index) const {
|
|
// @@protoc_insertion_point(field_get:MNN.Compression.SIMDOCPrunerParams.oc_blocks)
|
|
return _internal_oc_blocks(index);
|
|
}
|
|
inline void SIMDOCPrunerParams::set_oc_blocks(int index, int32_t value) {
|
|
oc_blocks_.Set(index, value);
|
|
// @@protoc_insertion_point(field_set:MNN.Compression.SIMDOCPrunerParams.oc_blocks)
|
|
}
|
|
inline void SIMDOCPrunerParams::_internal_add_oc_blocks(int32_t value) {
|
|
oc_blocks_.Add(value);
|
|
}
|
|
inline void SIMDOCPrunerParams::add_oc_blocks(int32_t value) {
|
|
_internal_add_oc_blocks(value);
|
|
// @@protoc_insertion_point(field_add:MNN.Compression.SIMDOCPrunerParams.oc_blocks)
|
|
}
|
|
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
|
|
SIMDOCPrunerParams::_internal_oc_blocks() const {
|
|
return oc_blocks_;
|
|
}
|
|
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
|
|
SIMDOCPrunerParams::oc_blocks() const {
|
|
// @@protoc_insertion_point(field_list:MNN.Compression.SIMDOCPrunerParams.oc_blocks)
|
|
return _internal_oc_blocks();
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
|
|
SIMDOCPrunerParams::_internal_mutable_oc_blocks() {
|
|
return &oc_blocks_;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
|
|
SIMDOCPrunerParams::mutable_oc_blocks() {
|
|
// @@protoc_insertion_point(field_mutable_list:MNN.Compression.SIMDOCPrunerParams.oc_blocks)
|
|
return _internal_mutable_oc_blocks();
|
|
}
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// PruneParams
|
|
|
|
// optional .MNN.Compression.PruneParams.PruneType type = 1 [default = RANDOM];
|
|
inline bool PruneParams::_internal_has_type() const {
|
|
bool value = (_has_bits_[0] & 0x00000004u) != 0;
|
|
return value;
|
|
}
|
|
inline bool PruneParams::has_type() const {
|
|
return _internal_has_type();
|
|
}
|
|
inline void PruneParams::clear_type() {
|
|
type_ = 0;
|
|
_has_bits_[0] &= ~0x00000004u;
|
|
}
|
|
inline ::MNN::Compression::PruneParams_PruneType PruneParams::_internal_type() const {
|
|
return static_cast< ::MNN::Compression::PruneParams_PruneType >(type_);
|
|
}
|
|
inline ::MNN::Compression::PruneParams_PruneType PruneParams::type() const {
|
|
// @@protoc_insertion_point(field_get:MNN.Compression.PruneParams.type)
|
|
return _internal_type();
|
|
}
|
|
inline void PruneParams::_internal_set_type(::MNN::Compression::PruneParams_PruneType value) {
|
|
assert(::MNN::Compression::PruneParams_PruneType_IsValid(value));
|
|
_has_bits_[0] |= 0x00000004u;
|
|
type_ = value;
|
|
}
|
|
inline void PruneParams::set_type(::MNN::Compression::PruneParams_PruneType value) {
|
|
_internal_set_type(value);
|
|
// @@protoc_insertion_point(field_set:MNN.Compression.PruneParams.type)
|
|
}
|
|
|
|
// optional .MNN.Compression.LevelPrunerParams level_pruner_params = 2;
|
|
inline bool PruneParams::_internal_has_level_pruner_params() const {
|
|
bool value = (_has_bits_[0] & 0x00000001u) != 0;
|
|
PROTOBUF_ASSUME(!value || level_pruner_params_ != nullptr);
|
|
return value;
|
|
}
|
|
inline bool PruneParams::has_level_pruner_params() const {
|
|
return _internal_has_level_pruner_params();
|
|
}
|
|
inline void PruneParams::clear_level_pruner_params() {
|
|
if (level_pruner_params_ != nullptr) level_pruner_params_->Clear();
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
inline const ::MNN::Compression::LevelPrunerParams& PruneParams::_internal_level_pruner_params() const {
|
|
const ::MNN::Compression::LevelPrunerParams* p = level_pruner_params_;
|
|
return p != nullptr ? *p : reinterpret_cast<const ::MNN::Compression::LevelPrunerParams&>(
|
|
::MNN::Compression::_LevelPrunerParams_default_instance_);
|
|
}
|
|
inline const ::MNN::Compression::LevelPrunerParams& PruneParams::level_pruner_params() const {
|
|
// @@protoc_insertion_point(field_get:MNN.Compression.PruneParams.level_pruner_params)
|
|
return _internal_level_pruner_params();
|
|
}
|
|
inline void PruneParams::unsafe_arena_set_allocated_level_pruner_params(
|
|
::MNN::Compression::LevelPrunerParams* level_pruner_params) {
|
|
if (GetArenaForAllocation() == nullptr) {
|
|
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(level_pruner_params_);
|
|
}
|
|
level_pruner_params_ = level_pruner_params;
|
|
if (level_pruner_params) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
} else {
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:MNN.Compression.PruneParams.level_pruner_params)
|
|
}
|
|
inline ::MNN::Compression::LevelPrunerParams* PruneParams::release_level_pruner_params() {
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
::MNN::Compression::LevelPrunerParams* temp = level_pruner_params_;
|
|
level_pruner_params_ = 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 ::MNN::Compression::LevelPrunerParams* PruneParams::unsafe_arena_release_level_pruner_params() {
|
|
// @@protoc_insertion_point(field_release:MNN.Compression.PruneParams.level_pruner_params)
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
::MNN::Compression::LevelPrunerParams* temp = level_pruner_params_;
|
|
level_pruner_params_ = nullptr;
|
|
return temp;
|
|
}
|
|
inline ::MNN::Compression::LevelPrunerParams* PruneParams::_internal_mutable_level_pruner_params() {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
if (level_pruner_params_ == nullptr) {
|
|
auto* p = CreateMaybeMessage<::MNN::Compression::LevelPrunerParams>(GetArenaForAllocation());
|
|
level_pruner_params_ = p;
|
|
}
|
|
return level_pruner_params_;
|
|
}
|
|
inline ::MNN::Compression::LevelPrunerParams* PruneParams::mutable_level_pruner_params() {
|
|
::MNN::Compression::LevelPrunerParams* _msg = _internal_mutable_level_pruner_params();
|
|
// @@protoc_insertion_point(field_mutable:MNN.Compression.PruneParams.level_pruner_params)
|
|
return _msg;
|
|
}
|
|
inline void PruneParams::set_allocated_level_pruner_params(::MNN::Compression::LevelPrunerParams* level_pruner_params) {
|
|
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
|
|
if (message_arena == nullptr) {
|
|
delete level_pruner_params_;
|
|
}
|
|
if (level_pruner_params) {
|
|
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
|
|
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::MNN::Compression::LevelPrunerParams>::GetOwningArena(level_pruner_params);
|
|
if (message_arena != submessage_arena) {
|
|
level_pruner_params = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
|
|
message_arena, level_pruner_params, submessage_arena);
|
|
}
|
|
_has_bits_[0] |= 0x00000001u;
|
|
} else {
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
level_pruner_params_ = level_pruner_params;
|
|
// @@protoc_insertion_point(field_set_allocated:MNN.Compression.PruneParams.level_pruner_params)
|
|
}
|
|
|
|
// optional .MNN.Compression.SIMDOCPrunerParams simd_oc_pruner_params = 3;
|
|
inline bool PruneParams::_internal_has_simd_oc_pruner_params() const {
|
|
bool value = (_has_bits_[0] & 0x00000002u) != 0;
|
|
PROTOBUF_ASSUME(!value || simd_oc_pruner_params_ != nullptr);
|
|
return value;
|
|
}
|
|
inline bool PruneParams::has_simd_oc_pruner_params() const {
|
|
return _internal_has_simd_oc_pruner_params();
|
|
}
|
|
inline void PruneParams::clear_simd_oc_pruner_params() {
|
|
if (simd_oc_pruner_params_ != nullptr) simd_oc_pruner_params_->Clear();
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
}
|
|
inline const ::MNN::Compression::SIMDOCPrunerParams& PruneParams::_internal_simd_oc_pruner_params() const {
|
|
const ::MNN::Compression::SIMDOCPrunerParams* p = simd_oc_pruner_params_;
|
|
return p != nullptr ? *p : reinterpret_cast<const ::MNN::Compression::SIMDOCPrunerParams&>(
|
|
::MNN::Compression::_SIMDOCPrunerParams_default_instance_);
|
|
}
|
|
inline const ::MNN::Compression::SIMDOCPrunerParams& PruneParams::simd_oc_pruner_params() const {
|
|
// @@protoc_insertion_point(field_get:MNN.Compression.PruneParams.simd_oc_pruner_params)
|
|
return _internal_simd_oc_pruner_params();
|
|
}
|
|
inline void PruneParams::unsafe_arena_set_allocated_simd_oc_pruner_params(
|
|
::MNN::Compression::SIMDOCPrunerParams* simd_oc_pruner_params) {
|
|
if (GetArenaForAllocation() == nullptr) {
|
|
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(simd_oc_pruner_params_);
|
|
}
|
|
simd_oc_pruner_params_ = simd_oc_pruner_params;
|
|
if (simd_oc_pruner_params) {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
} else {
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
}
|
|
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:MNN.Compression.PruneParams.simd_oc_pruner_params)
|
|
}
|
|
inline ::MNN::Compression::SIMDOCPrunerParams* PruneParams::release_simd_oc_pruner_params() {
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
::MNN::Compression::SIMDOCPrunerParams* temp = simd_oc_pruner_params_;
|
|
simd_oc_pruner_params_ = 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 ::MNN::Compression::SIMDOCPrunerParams* PruneParams::unsafe_arena_release_simd_oc_pruner_params() {
|
|
// @@protoc_insertion_point(field_release:MNN.Compression.PruneParams.simd_oc_pruner_params)
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
::MNN::Compression::SIMDOCPrunerParams* temp = simd_oc_pruner_params_;
|
|
simd_oc_pruner_params_ = nullptr;
|
|
return temp;
|
|
}
|
|
inline ::MNN::Compression::SIMDOCPrunerParams* PruneParams::_internal_mutable_simd_oc_pruner_params() {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
if (simd_oc_pruner_params_ == nullptr) {
|
|
auto* p = CreateMaybeMessage<::MNN::Compression::SIMDOCPrunerParams>(GetArenaForAllocation());
|
|
simd_oc_pruner_params_ = p;
|
|
}
|
|
return simd_oc_pruner_params_;
|
|
}
|
|
inline ::MNN::Compression::SIMDOCPrunerParams* PruneParams::mutable_simd_oc_pruner_params() {
|
|
::MNN::Compression::SIMDOCPrunerParams* _msg = _internal_mutable_simd_oc_pruner_params();
|
|
// @@protoc_insertion_point(field_mutable:MNN.Compression.PruneParams.simd_oc_pruner_params)
|
|
return _msg;
|
|
}
|
|
inline void PruneParams::set_allocated_simd_oc_pruner_params(::MNN::Compression::SIMDOCPrunerParams* simd_oc_pruner_params) {
|
|
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
|
|
if (message_arena == nullptr) {
|
|
delete simd_oc_pruner_params_;
|
|
}
|
|
if (simd_oc_pruner_params) {
|
|
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
|
|
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::MNN::Compression::SIMDOCPrunerParams>::GetOwningArena(simd_oc_pruner_params);
|
|
if (message_arena != submessage_arena) {
|
|
simd_oc_pruner_params = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
|
|
message_arena, simd_oc_pruner_params, submessage_arena);
|
|
}
|
|
_has_bits_[0] |= 0x00000002u;
|
|
} else {
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
}
|
|
simd_oc_pruner_params_ = simd_oc_pruner_params;
|
|
// @@protoc_insertion_point(field_set_allocated:MNN.Compression.PruneParams.simd_oc_pruner_params)
|
|
}
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// CompressionAlgo
|
|
|
|
// optional .MNN.Compression.CompressionAlgo.CompressionType type = 1 [default = QUANTIZE];
|
|
inline bool CompressionAlgo::_internal_has_type() const {
|
|
bool value = (_has_bits_[0] & 0x00000004u) != 0;
|
|
return value;
|
|
}
|
|
inline bool CompressionAlgo::has_type() const {
|
|
return _internal_has_type();
|
|
}
|
|
inline void CompressionAlgo::clear_type() {
|
|
type_ = 0;
|
|
_has_bits_[0] &= ~0x00000004u;
|
|
}
|
|
inline ::MNN::Compression::CompressionAlgo_CompressionType CompressionAlgo::_internal_type() const {
|
|
return static_cast< ::MNN::Compression::CompressionAlgo_CompressionType >(type_);
|
|
}
|
|
inline ::MNN::Compression::CompressionAlgo_CompressionType CompressionAlgo::type() const {
|
|
// @@protoc_insertion_point(field_get:MNN.Compression.CompressionAlgo.type)
|
|
return _internal_type();
|
|
}
|
|
inline void CompressionAlgo::_internal_set_type(::MNN::Compression::CompressionAlgo_CompressionType value) {
|
|
assert(::MNN::Compression::CompressionAlgo_CompressionType_IsValid(value));
|
|
_has_bits_[0] |= 0x00000004u;
|
|
type_ = value;
|
|
}
|
|
inline void CompressionAlgo::set_type(::MNN::Compression::CompressionAlgo_CompressionType value) {
|
|
_internal_set_type(value);
|
|
// @@protoc_insertion_point(field_set:MNN.Compression.CompressionAlgo.type)
|
|
}
|
|
|
|
// optional .MNN.Compression.QuantizeParams quant_params = 2;
|
|
inline bool CompressionAlgo::_internal_has_quant_params() const {
|
|
bool value = (_has_bits_[0] & 0x00000001u) != 0;
|
|
PROTOBUF_ASSUME(!value || quant_params_ != nullptr);
|
|
return value;
|
|
}
|
|
inline bool CompressionAlgo::has_quant_params() const {
|
|
return _internal_has_quant_params();
|
|
}
|
|
inline void CompressionAlgo::clear_quant_params() {
|
|
if (quant_params_ != nullptr) quant_params_->Clear();
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
inline const ::MNN::Compression::QuantizeParams& CompressionAlgo::_internal_quant_params() const {
|
|
const ::MNN::Compression::QuantizeParams* p = quant_params_;
|
|
return p != nullptr ? *p : reinterpret_cast<const ::MNN::Compression::QuantizeParams&>(
|
|
::MNN::Compression::_QuantizeParams_default_instance_);
|
|
}
|
|
inline const ::MNN::Compression::QuantizeParams& CompressionAlgo::quant_params() const {
|
|
// @@protoc_insertion_point(field_get:MNN.Compression.CompressionAlgo.quant_params)
|
|
return _internal_quant_params();
|
|
}
|
|
inline void CompressionAlgo::unsafe_arena_set_allocated_quant_params(
|
|
::MNN::Compression::QuantizeParams* quant_params) {
|
|
if (GetArenaForAllocation() == nullptr) {
|
|
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(quant_params_);
|
|
}
|
|
quant_params_ = quant_params;
|
|
if (quant_params) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
} else {
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:MNN.Compression.CompressionAlgo.quant_params)
|
|
}
|
|
inline ::MNN::Compression::QuantizeParams* CompressionAlgo::release_quant_params() {
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
::MNN::Compression::QuantizeParams* temp = quant_params_;
|
|
quant_params_ = 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 ::MNN::Compression::QuantizeParams* CompressionAlgo::unsafe_arena_release_quant_params() {
|
|
// @@protoc_insertion_point(field_release:MNN.Compression.CompressionAlgo.quant_params)
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
::MNN::Compression::QuantizeParams* temp = quant_params_;
|
|
quant_params_ = nullptr;
|
|
return temp;
|
|
}
|
|
inline ::MNN::Compression::QuantizeParams* CompressionAlgo::_internal_mutable_quant_params() {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
if (quant_params_ == nullptr) {
|
|
auto* p = CreateMaybeMessage<::MNN::Compression::QuantizeParams>(GetArenaForAllocation());
|
|
quant_params_ = p;
|
|
}
|
|
return quant_params_;
|
|
}
|
|
inline ::MNN::Compression::QuantizeParams* CompressionAlgo::mutable_quant_params() {
|
|
::MNN::Compression::QuantizeParams* _msg = _internal_mutable_quant_params();
|
|
// @@protoc_insertion_point(field_mutable:MNN.Compression.CompressionAlgo.quant_params)
|
|
return _msg;
|
|
}
|
|
inline void CompressionAlgo::set_allocated_quant_params(::MNN::Compression::QuantizeParams* quant_params) {
|
|
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
|
|
if (message_arena == nullptr) {
|
|
delete quant_params_;
|
|
}
|
|
if (quant_params) {
|
|
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
|
|
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::MNN::Compression::QuantizeParams>::GetOwningArena(quant_params);
|
|
if (message_arena != submessage_arena) {
|
|
quant_params = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
|
|
message_arena, quant_params, submessage_arena);
|
|
}
|
|
_has_bits_[0] |= 0x00000001u;
|
|
} else {
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
quant_params_ = quant_params;
|
|
// @@protoc_insertion_point(field_set_allocated:MNN.Compression.CompressionAlgo.quant_params)
|
|
}
|
|
|
|
// optional .MNN.Compression.PruneParams prune_params = 3;
|
|
inline bool CompressionAlgo::_internal_has_prune_params() const {
|
|
bool value = (_has_bits_[0] & 0x00000002u) != 0;
|
|
PROTOBUF_ASSUME(!value || prune_params_ != nullptr);
|
|
return value;
|
|
}
|
|
inline bool CompressionAlgo::has_prune_params() const {
|
|
return _internal_has_prune_params();
|
|
}
|
|
inline void CompressionAlgo::clear_prune_params() {
|
|
if (prune_params_ != nullptr) prune_params_->Clear();
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
}
|
|
inline const ::MNN::Compression::PruneParams& CompressionAlgo::_internal_prune_params() const {
|
|
const ::MNN::Compression::PruneParams* p = prune_params_;
|
|
return p != nullptr ? *p : reinterpret_cast<const ::MNN::Compression::PruneParams&>(
|
|
::MNN::Compression::_PruneParams_default_instance_);
|
|
}
|
|
inline const ::MNN::Compression::PruneParams& CompressionAlgo::prune_params() const {
|
|
// @@protoc_insertion_point(field_get:MNN.Compression.CompressionAlgo.prune_params)
|
|
return _internal_prune_params();
|
|
}
|
|
inline void CompressionAlgo::unsafe_arena_set_allocated_prune_params(
|
|
::MNN::Compression::PruneParams* prune_params) {
|
|
if (GetArenaForAllocation() == nullptr) {
|
|
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(prune_params_);
|
|
}
|
|
prune_params_ = prune_params;
|
|
if (prune_params) {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
} else {
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
}
|
|
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:MNN.Compression.CompressionAlgo.prune_params)
|
|
}
|
|
inline ::MNN::Compression::PruneParams* CompressionAlgo::release_prune_params() {
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
::MNN::Compression::PruneParams* temp = prune_params_;
|
|
prune_params_ = 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 ::MNN::Compression::PruneParams* CompressionAlgo::unsafe_arena_release_prune_params() {
|
|
// @@protoc_insertion_point(field_release:MNN.Compression.CompressionAlgo.prune_params)
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
::MNN::Compression::PruneParams* temp = prune_params_;
|
|
prune_params_ = nullptr;
|
|
return temp;
|
|
}
|
|
inline ::MNN::Compression::PruneParams* CompressionAlgo::_internal_mutable_prune_params() {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
if (prune_params_ == nullptr) {
|
|
auto* p = CreateMaybeMessage<::MNN::Compression::PruneParams>(GetArenaForAllocation());
|
|
prune_params_ = p;
|
|
}
|
|
return prune_params_;
|
|
}
|
|
inline ::MNN::Compression::PruneParams* CompressionAlgo::mutable_prune_params() {
|
|
::MNN::Compression::PruneParams* _msg = _internal_mutable_prune_params();
|
|
// @@protoc_insertion_point(field_mutable:MNN.Compression.CompressionAlgo.prune_params)
|
|
return _msg;
|
|
}
|
|
inline void CompressionAlgo::set_allocated_prune_params(::MNN::Compression::PruneParams* prune_params) {
|
|
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
|
|
if (message_arena == nullptr) {
|
|
delete prune_params_;
|
|
}
|
|
if (prune_params) {
|
|
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
|
|
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::MNN::Compression::PruneParams>::GetOwningArena(prune_params);
|
|
if (message_arena != submessage_arena) {
|
|
prune_params = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
|
|
message_arena, prune_params, submessage_arena);
|
|
}
|
|
_has_bits_[0] |= 0x00000002u;
|
|
} else {
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
}
|
|
prune_params_ = prune_params;
|
|
// @@protoc_insertion_point(field_set_allocated:MNN.Compression.CompressionAlgo.prune_params)
|
|
}
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// Pipeline
|
|
|
|
// required string version = 1 [default = "0.0.0"];
|
|
inline bool Pipeline::_internal_has_version() const {
|
|
bool value = (_has_bits_[0] & 0x00000001u) != 0;
|
|
return value;
|
|
}
|
|
inline bool Pipeline::has_version() const {
|
|
return _internal_has_version();
|
|
}
|
|
inline void Pipeline::clear_version() {
|
|
version_.ClearToDefault(::MNN::Compression::Pipeline::_i_give_permission_to_break_this_code_default_version_, GetArenaForAllocation());
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
inline const std::string& Pipeline::version() const {
|
|
// @@protoc_insertion_point(field_get:MNN.Compression.Pipeline.version)
|
|
if (version_.IsDefault(nullptr)) return _i_give_permission_to_break_this_code_default_version_.get();
|
|
return _internal_version();
|
|
}
|
|
template <typename ArgT0, typename... ArgT>
|
|
inline PROTOBUF_ALWAYS_INLINE
|
|
void Pipeline::set_version(ArgT0&& arg0, ArgT... args) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set:MNN.Compression.Pipeline.version)
|
|
}
|
|
inline std::string* Pipeline::mutable_version() {
|
|
std::string* _s = _internal_mutable_version();
|
|
// @@protoc_insertion_point(field_mutable:MNN.Compression.Pipeline.version)
|
|
return _s;
|
|
}
|
|
inline const std::string& Pipeline::_internal_version() const {
|
|
return version_.Get();
|
|
}
|
|
inline void Pipeline::_internal_set_version(const std::string& value) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, value, GetArenaForAllocation());
|
|
}
|
|
inline std::string* Pipeline::_internal_mutable_version() {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
return version_.Mutable(::MNN::Compression::Pipeline::_i_give_permission_to_break_this_code_default_version_, GetArenaForAllocation());
|
|
}
|
|
inline std::string* Pipeline::release_version() {
|
|
// @@protoc_insertion_point(field_release:MNN.Compression.Pipeline.version)
|
|
if (!_internal_has_version()) {
|
|
return nullptr;
|
|
}
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
auto* p = version_.ReleaseNonDefault(nullptr, GetArenaForAllocation());
|
|
return p;
|
|
}
|
|
inline void Pipeline::set_allocated_version(std::string* version) {
|
|
if (version != nullptr) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
} else {
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
version_.SetAllocated(nullptr, version,
|
|
GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set_allocated:MNN.Compression.Pipeline.version)
|
|
}
|
|
|
|
// repeated .MNN.Compression.CompressionAlgo algo = 2;
|
|
inline int Pipeline::_internal_algo_size() const {
|
|
return algo_.size();
|
|
}
|
|
inline int Pipeline::algo_size() const {
|
|
return _internal_algo_size();
|
|
}
|
|
inline void Pipeline::clear_algo() {
|
|
algo_.Clear();
|
|
}
|
|
inline ::MNN::Compression::CompressionAlgo* Pipeline::mutable_algo(int index) {
|
|
// @@protoc_insertion_point(field_mutable:MNN.Compression.Pipeline.algo)
|
|
return algo_.Mutable(index);
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MNN::Compression::CompressionAlgo >*
|
|
Pipeline::mutable_algo() {
|
|
// @@protoc_insertion_point(field_mutable_list:MNN.Compression.Pipeline.algo)
|
|
return &algo_;
|
|
}
|
|
inline const ::MNN::Compression::CompressionAlgo& Pipeline::_internal_algo(int index) const {
|
|
return algo_.Get(index);
|
|
}
|
|
inline const ::MNN::Compression::CompressionAlgo& Pipeline::algo(int index) const {
|
|
// @@protoc_insertion_point(field_get:MNN.Compression.Pipeline.algo)
|
|
return _internal_algo(index);
|
|
}
|
|
inline ::MNN::Compression::CompressionAlgo* Pipeline::_internal_add_algo() {
|
|
return algo_.Add();
|
|
}
|
|
inline ::MNN::Compression::CompressionAlgo* Pipeline::add_algo() {
|
|
::MNN::Compression::CompressionAlgo* _add = _internal_add_algo();
|
|
// @@protoc_insertion_point(field_add:MNN.Compression.Pipeline.algo)
|
|
return _add;
|
|
}
|
|
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MNN::Compression::CompressionAlgo >&
|
|
Pipeline::algo() const {
|
|
// @@protoc_insertion_point(field_list:MNN.Compression.Pipeline.algo)
|
|
return algo_;
|
|
}
|
|
|
|
// optional string mnn_uuid = 3;
|
|
inline bool Pipeline::_internal_has_mnn_uuid() const {
|
|
bool value = (_has_bits_[0] & 0x00000002u) != 0;
|
|
return value;
|
|
}
|
|
inline bool Pipeline::has_mnn_uuid() const {
|
|
return _internal_has_mnn_uuid();
|
|
}
|
|
inline void Pipeline::clear_mnn_uuid() {
|
|
mnn_uuid_.ClearToEmpty();
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
}
|
|
inline const std::string& Pipeline::mnn_uuid() const {
|
|
// @@protoc_insertion_point(field_get:MNN.Compression.Pipeline.mnn_uuid)
|
|
return _internal_mnn_uuid();
|
|
}
|
|
template <typename ArgT0, typename... ArgT>
|
|
inline PROTOBUF_ALWAYS_INLINE
|
|
void Pipeline::set_mnn_uuid(ArgT0&& arg0, ArgT... args) {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
mnn_uuid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set:MNN.Compression.Pipeline.mnn_uuid)
|
|
}
|
|
inline std::string* Pipeline::mutable_mnn_uuid() {
|
|
std::string* _s = _internal_mutable_mnn_uuid();
|
|
// @@protoc_insertion_point(field_mutable:MNN.Compression.Pipeline.mnn_uuid)
|
|
return _s;
|
|
}
|
|
inline const std::string& Pipeline::_internal_mnn_uuid() const {
|
|
return mnn_uuid_.Get();
|
|
}
|
|
inline void Pipeline::_internal_set_mnn_uuid(const std::string& value) {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
mnn_uuid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
|
|
}
|
|
inline std::string* Pipeline::_internal_mutable_mnn_uuid() {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
return mnn_uuid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
|
|
}
|
|
inline std::string* Pipeline::release_mnn_uuid() {
|
|
// @@protoc_insertion_point(field_release:MNN.Compression.Pipeline.mnn_uuid)
|
|
if (!_internal_has_mnn_uuid()) {
|
|
return nullptr;
|
|
}
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
auto* p = mnn_uuid_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
|
|
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
if (mnn_uuid_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
|
|
mnn_uuid_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
|
|
}
|
|
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
return p;
|
|
}
|
|
inline void Pipeline::set_allocated_mnn_uuid(std::string* mnn_uuid) {
|
|
if (mnn_uuid != nullptr) {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
} else {
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
}
|
|
mnn_uuid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), mnn_uuid,
|
|
GetArenaForAllocation());
|
|
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
if (mnn_uuid_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
|
|
mnn_uuid_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
|
|
}
|
|
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
// @@protoc_insertion_point(field_set_allocated:MNN.Compression.Pipeline.mnn_uuid)
|
|
}
|
|
|
|
// optional bool for_guide = 4 [default = false];
|
|
inline bool Pipeline::_internal_has_for_guide() const {
|
|
bool value = (_has_bits_[0] & 0x00000004u) != 0;
|
|
return value;
|
|
}
|
|
inline bool Pipeline::has_for_guide() const {
|
|
return _internal_has_for_guide();
|
|
}
|
|
inline void Pipeline::clear_for_guide() {
|
|
for_guide_ = false;
|
|
_has_bits_[0] &= ~0x00000004u;
|
|
}
|
|
inline bool Pipeline::_internal_for_guide() const {
|
|
return for_guide_;
|
|
}
|
|
inline bool Pipeline::for_guide() const {
|
|
// @@protoc_insertion_point(field_get:MNN.Compression.Pipeline.for_guide)
|
|
return _internal_for_guide();
|
|
}
|
|
inline void Pipeline::_internal_set_for_guide(bool value) {
|
|
_has_bits_[0] |= 0x00000004u;
|
|
for_guide_ = value;
|
|
}
|
|
inline void Pipeline::set_for_guide(bool value) {
|
|
_internal_set_for_guide(value);
|
|
// @@protoc_insertion_point(field_set:MNN.Compression.Pipeline.for_guide)
|
|
}
|
|
|
|
#ifdef __GNUC__
|
|
#pragma GCC diagnostic pop
|
|
#endif // __GNUC__
|
|
// -------------------------------------------------------------------
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
|
|
// @@protoc_insertion_point(namespace_scope)
|
|
|
|
} // namespace Compression
|
|
} // namespace MNN
|
|
|
|
PROTOBUF_NAMESPACE_OPEN
|
|
|
|
template <> struct is_proto_enum< ::MNN::Compression::QuantizeParams_RoundMode> : ::std::true_type {};
|
|
template <>
|
|
inline const EnumDescriptor* GetEnumDescriptor< ::MNN::Compression::QuantizeParams_RoundMode>() {
|
|
return ::MNN::Compression::QuantizeParams_RoundMode_descriptor();
|
|
}
|
|
template <> struct is_proto_enum< ::MNN::Compression::LayerQuantizeParams_QuantMethod> : ::std::true_type {};
|
|
template <>
|
|
inline const EnumDescriptor* GetEnumDescriptor< ::MNN::Compression::LayerQuantizeParams_QuantMethod>() {
|
|
return ::MNN::Compression::LayerQuantizeParams_QuantMethod_descriptor();
|
|
}
|
|
template <> struct is_proto_enum< ::MNN::Compression::PruneParams_PruneType> : ::std::true_type {};
|
|
template <>
|
|
inline const EnumDescriptor* GetEnumDescriptor< ::MNN::Compression::PruneParams_PruneType>() {
|
|
return ::MNN::Compression::PruneParams_PruneType_descriptor();
|
|
}
|
|
template <> struct is_proto_enum< ::MNN::Compression::CompressionAlgo_CompressionType> : ::std::true_type {};
|
|
template <>
|
|
inline const EnumDescriptor* GetEnumDescriptor< ::MNN::Compression::CompressionAlgo_CompressionType>() {
|
|
return ::MNN::Compression::CompressionAlgo_CompressionType_descriptor();
|
|
}
|
|
|
|
PROTOBUF_NAMESPACE_CLOSE
|
|
|
|
// @@protoc_insertion_point(global_scope)
|
|
|
|
#include <google/protobuf/port_undef.inc>
|
|
#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_MNN_5fcompression_2eproto
|