1From 881a1c16aeac375bb92d32e80d70239694d0b34b Mon Sep 17 00:00:00 2001 2From: chengfeng27 <chengfeng27@huawei.com> 3Date: Wed, 5 Jun 2024 19:33:58 +0800 4Subject: fix MindIR_ScatterElements_CreatePrimitive 5 6--- 7 mindspore/lite/mindir/BUILD.gn | 2 + 8 mindspore/lite/mindir/include/mindir.h | 406 ++++ 9 mindspore/lite/mindir/include/mindir_tensor.h | 1 + 10 mindspore/lite/mindir/include/mindir_types.h | 60 + 11 mindspore/lite/mindir/src/mindir.cc | 106 +- 12 mindspore/lite/mindir/src/mindir_1.cc | 2061 ++++++++++++++++ 13 mindspore/lite/mindir/src/mindir_2.cc | 2152 +++++++++++++++++ 14 mindspore/lite/mindir/src/mindir_tensor.cc | 13 + 15 8 files changed, 4797 insertions(+), 4 deletions(-) 16 create mode 100644 mindspore/lite/mindir/src/mindir_1.cc 17 create mode 100644 mindspore/lite/mindir/src/mindir_2.cc 18 19diff --git a/mindspore/lite/mindir/BUILD.gn b/mindspore/lite/mindir/BUILD.gn 20index ad4eff84..ec87d1da 100644 21--- a/mindspore/lite/mindir/BUILD.gn 22+++ b/mindspore/lite/mindir/BUILD.gn 23@@ -38,6 +38,8 @@ ohos_shared_library("mindir_lib") { 24 sources = [ 25 "../src/common/log.cc", 26 "src/mindir.cc", 27+ "src/mindir_1.cc", 28+ "src/mindir_2.cc", 29 "src/mindir_memory_manager.cc", 30 "src/mindir_nnrt_lite_graph.cc", 31 "src/mindir_tensor.cc", 32diff --git a/mindspore/lite/mindir/include/mindir.h b/mindspore/lite/mindir/include/mindir.h 33index 7eb3a744..d236b6cc 100644 34--- a/mindspore/lite/mindir/include/mindir.h 35+++ b/mindspore/lite/mindir/include/mindir.h 36@@ -666,6 +666,412 @@ PrimitivePtr MindIR_Rank_CreatePrimitive(); 37 // ********** GatherNd ********** 38 PrimitivePtr MindIR_GatherNd_CreatePrimitive(); 39 40+// ********** BatchToSpace ********** 41+PrimitivePtr MindIR_BatchToSpace_CreatePrimitive(const std::vector<int64_t>& block_size, const std::vector<std::vector<int64_t>>& crops); 42+std::vector<int64_t> MindIR_BatchToSpace_GetBlockSize(ConstPrimitivePtr primitive); 43+void MindIR_BatchToSpace_SetBlockSize(PrimitivePtr *primitive, const std::vector<int64_t>& block_size); 44+std::vector<std::vector<int64_t>> MindIR_BatchToSpace_GetCrops(ConstPrimitivePtr primitive); 45+void MindIR_BatchToSpace_SetCrops(PrimitivePtr *primitive, const std::vector<std::vector<int64_t>>& crops); 46+ 47+// ********** Depend ********** 48+PrimitivePtr MindIR_Depend_CreatePrimitive(); 49+ 50+// ********** Dropout ********** 51+PrimitivePtr MindIR_Dropout_CreatePrimitive(float keep_prob); 52+float MindIR_Dropout_GetKeepProb(ConstPrimitivePtr primitive); 53+void MindIR_Dropout_SetKeepProb(PrimitivePtr *primitive, float keep_prob); 54+ 55+// ********** Elu ********** 56+PrimitivePtr MindIR_Elu_CreatePrimitive(float alpha); 57+float MindIR_Elu_GetAlpha(ConstPrimitivePtr primitive); 58+void MindIR_Elu_SetAlpha(PrimitivePtr *primitive, float alpha); 59+ 60+// ********** EmbeddingLookupFusion ********** 61+PrimitivePtr MindIR_EmbeddingLookupFusion_CreatePrimitive(float max_norm); 62+float MindIR_EmbeddingLookupFusion_GetMaxNorm(ConstPrimitivePtr primitive); 63+void MindIR_EmbeddingLookupFusion_SetMaxNorm(PrimitivePtr *primitive, float max_norm); 64+ 65+// ********** FakeQuantWithMinMaxVars ********** 66+PrimitivePtr MindIR_FakeQuantWithMinMaxVars_CreatePrimitive(int64_t num_bits, bool narrow_range); 67+int64_t MindIR_FakeQuantWithMinMaxVars_GetNumBits(ConstPrimitivePtr primitive); 68+void MindIR_FakeQuantWithMinMaxVars_SetNumBits(PrimitivePtr *primitive, int64_t num_bits); 69+bool MindIR_FakeQuantWithMinMaxVars_GetNarrowRange(ConstPrimitivePtr primitive); 70+void MindIR_FakeQuantWithMinMaxVars_SetNarrowRange(PrimitivePtr *primitive, bool narrow_range); 71+ 72+// ********** FakeQuantWithMinMaxVarsPerChannel ********** 73+PrimitivePtr MindIR_FakeQuantWithMinMaxVarsPerChannel_CreatePrimitive(int64_t num_bits, bool narrow_range); 74+int64_t MindIR_FakeQuantWithMinMaxVarsPerChannel_GetNumBits(ConstPrimitivePtr primitive); 75+void MindIR_FakeQuantWithMinMaxVarsPerChannel_SetNumBits(PrimitivePtr *primitive, int64_t num_bits); 76+bool MindIR_FakeQuantWithMinMaxVarsPerChannel_GetNarrowRange(ConstPrimitivePtr primitive); 77+void MindIR_FakeQuantWithMinMaxVarsPerChannel_SetNarrowRange(PrimitivePtr *primitive, bool narrow_range); 78+ 79+// ********** FftReal ********** 80+PrimitivePtr MindIR_FftReal_CreatePrimitive(); 81+ 82+// ********** FftImag ********** 83+PrimitivePtr MindIR_FftImag_CreatePrimitive(); 84+ 85+// ********** FloorDiv ********** 86+PrimitivePtr MindIR_FloorDiv_CreatePrimitive(); 87+ 88+// ********** FloorMod ********** 89+PrimitivePtr MindIR_FloorMod_CreatePrimitive(); 90+ 91+// ********** HashtableLookup ********** 92+PrimitivePtr MindIR_HashtableLookup_CreatePrimitive(); 93+ 94+// ********** LpNormalization ********** 95+PrimitivePtr MindIR_LpNormalization_CreatePrimitive(int64_t axis, int64_t p); 96+int64_t MindIR_LpNormalization_GetAxis(ConstPrimitivePtr primitive); 97+void MindIR_LpNormalization_SetAxis(PrimitivePtr *primitive, int64_t axis); 98+int64_t MindIR_LpNormalization_GetP(ConstPrimitivePtr primitive); 99+void MindIR_LpNormalization_SetP(PrimitivePtr *primitive, int64_t p); 100+ 101+// ********** LshProjection ********** 102+PrimitivePtr MindIR_LshProjection_CreatePrimitive(LshProjectionType type); 103+LshProjectionType MindIR_LshProjection_GetType(ConstPrimitivePtr primitive); 104+void MindIR_LshProjection_SetType(PrimitivePtr *primitive, LshProjectionType type); 105+ 106+// ********** SwitchLayer ********** 107+PrimitivePtr MindIR_SwitchLayer_CreatePrimitive(); 108+ 109+// ********** Mfcc ********** 110+PrimitivePtr MindIR_Mfcc_CreatePrimitive(float freq_upper_limit, float freq_lower_limit, int64_t filter_bank_channel_num, int64_t dct_coeff_num); 111+float MindIR_Mfcc_GetFreqUpperLimit(ConstPrimitivePtr primitive); 112+void MindIR_Mfcc_SetFreqUpperLimit(PrimitivePtr *primitive, float freq_upper_limit); 113+float MindIR_Mfcc_GetFreqLowerLimit(ConstPrimitivePtr primitive); 114+void MindIR_Mfcc_SetFreqLowerLimit(PrimitivePtr *primitive, float freq_lower_limit); 115+int64_t MindIR_Mfcc_GetFilterBankChannelNum(ConstPrimitivePtr primitive); 116+void MindIR_Mfcc_SetFilterBankChannelNum(PrimitivePtr *primitive, int64_t filter_bank_channel_num); 117+int64_t MindIR_Mfcc_GetDctCoeffNum(ConstPrimitivePtr primitive); 118+void MindIR_Mfcc_SetDctCoeffNum(PrimitivePtr *primitive, int64_t dct_coeff_num); 119+ 120+// ********** NonMaxSuppression ********** 121+PrimitivePtr MindIR_NonMaxSuppression_CreatePrimitive(int64_t center_point_box); 122+int64_t MindIR_NonMaxSuppression_GetCenterPointBox(ConstPrimitivePtr primitive); 123+void MindIR_NonMaxSuppression_SetCenterPointBox(PrimitivePtr *primitive, int64_t center_point_box); 124+ 125+// ********** OnesLike ********** 126+PrimitivePtr MindIR_OnesLike_CreatePrimitive(); 127+ 128+// ********** PartialFusion ********** 129+PrimitivePtr MindIR_PartialFusion_CreatePrimitive(int64_t sub_graph_index); 130+int64_t MindIR_PartialFusion_GetSubGraphIndex(ConstPrimitivePtr primitive); 131+void MindIR_PartialFusion_SetSubGraphIndex(PrimitivePtr *primitive, int64_t sub_graph_index); 132+ 133+// ********** PriorBox ********** 134+PrimitivePtr MindIR_PriorBox_CreatePrimitive(const std::vector<int64_t>& min_sizes, const std::vector<int64_t>& max_sizes, const std::vector<float>& aspect_ratios, const std::vector<float>& variances, int64_t image_size_w, int64_t image_size_h, float step_w, float step_h, bool clip, bool flip, float offset); 135+std::vector<int64_t> MindIR_PriorBox_GetMinSizes(ConstPrimitivePtr primitive); 136+void MindIR_PriorBox_SetMinSizes(PrimitivePtr *primitive, const std::vector<int64_t>& min_sizes); 137+std::vector<int64_t> MindIR_PriorBox_GetMaxSizes(ConstPrimitivePtr primitive); 138+void MindIR_PriorBox_SetMaxSizes(PrimitivePtr *primitive, const std::vector<int64_t>& max_sizes); 139+std::vector<float> MindIR_PriorBox_GetAspectRatios(ConstPrimitivePtr primitive); 140+void MindIR_PriorBox_SetAspectRatios(PrimitivePtr *primitive, const std::vector<float>& aspect_ratios); 141+std::vector<float> MindIR_PriorBox_GetVariances(ConstPrimitivePtr primitive); 142+void MindIR_PriorBox_SetVariances(PrimitivePtr *primitive, const std::vector<float>& variances); 143+int64_t MindIR_PriorBox_GetImageSizeW(ConstPrimitivePtr primitive); 144+void MindIR_PriorBox_SetImageSizeW(PrimitivePtr *primitive, int64_t image_size_w); 145+int64_t MindIR_PriorBox_GetImageSizeH(ConstPrimitivePtr primitive); 146+void MindIR_PriorBox_SetImageSizeH(PrimitivePtr *primitive, int64_t image_size_h); 147+float MindIR_PriorBox_GetStepW(ConstPrimitivePtr primitive); 148+void MindIR_PriorBox_SetStepW(PrimitivePtr *primitive, float step_w); 149+float MindIR_PriorBox_GetStepH(ConstPrimitivePtr primitive); 150+void MindIR_PriorBox_SetStepH(PrimitivePtr *primitive, float step_h); 151+bool MindIR_PriorBox_GetClip(ConstPrimitivePtr primitive); 152+void MindIR_PriorBox_SetClip(PrimitivePtr *primitive, bool clip); 153+bool MindIR_PriorBox_GetFlip(ConstPrimitivePtr primitive); 154+void MindIR_PriorBox_SetFlip(PrimitivePtr *primitive, bool flip); 155+float MindIR_PriorBox_GetOffset(ConstPrimitivePtr primitive); 156+void MindIR_PriorBox_SetOffset(PrimitivePtr *primitive, float offset); 157+ 158+// ********** ReverseSequence ********** 159+PrimitivePtr MindIR_ReverseSequence_CreatePrimitive(int64_t seq_dim, int64_t batch_dim); 160+int64_t MindIR_ReverseSequence_GetSeqDim(ConstPrimitivePtr primitive); 161+void MindIR_ReverseSequence_SetSeqDim(PrimitivePtr *primitive, int64_t seq_dim); 162+int64_t MindIR_ReverseSequence_GetBatchDim(ConstPrimitivePtr primitive); 163+void MindIR_ReverseSequence_SetBatchDim(PrimitivePtr *primitive, int64_t batch_dim); 164+ 165+// ********** ReverseV2 ********** 166+PrimitivePtr MindIR_ReverseV2_CreatePrimitive(const std::vector<int64_t>& axis); 167+std::vector<int64_t> MindIR_ReverseV2_GetAxis(ConstPrimitivePtr primitive); 168+void MindIR_ReverseV2_SetAxis(PrimitivePtr *primitive, const std::vector<int64_t>& axis); 169+ 170+// ********** Rfft ********** 171+PrimitivePtr MindIR_Rfft_CreatePrimitive(int64_t fft_length); 172+int64_t MindIR_Rfft_GetFftLength(ConstPrimitivePtr primitive); 173+void MindIR_Rfft_SetFftLength(PrimitivePtr *primitive, int64_t fft_length); 174+ 175+// ********** ROIPooling ********** 176+PrimitivePtr MindIR_ROIPooling_CreatePrimitive(int64_t pooled_h, int64_t pooled_w, float scale); 177+int64_t MindIR_ROIPooling_GetPooledH(ConstPrimitivePtr primitive); 178+void MindIR_ROIPooling_SetPooledH(PrimitivePtr *primitive, int64_t pooled_h); 179+int64_t MindIR_ROIPooling_GetPooledW(ConstPrimitivePtr primitive); 180+void MindIR_ROIPooling_SetPooledW(PrimitivePtr *primitive, int64_t pooled_w); 181+float MindIR_ROIPooling_GetScale(ConstPrimitivePtr primitive); 182+void MindIR_ROIPooling_SetScale(PrimitivePtr *primitive, float scale); 183+ 184+// ********** SkipGram ********** 185+PrimitivePtr MindIR_SkipGram_CreatePrimitive(bool include_all_grams, int64_t max_skip_size, int64_t ngram_size); 186+bool MindIR_SkipGram_GetIncludeAllGrams(ConstPrimitivePtr primitive); 187+void MindIR_SkipGram_SetIncludeAllGrams(PrimitivePtr *primitive, bool include_all_grams); 188+int64_t MindIR_SkipGram_GetMaxSkipSize(ConstPrimitivePtr primitive); 189+void MindIR_SkipGram_SetMaxSkipSize(PrimitivePtr *primitive, int64_t max_skip_size); 190+int64_t MindIR_SkipGram_GetNgramSize(ConstPrimitivePtr primitive); 191+void MindIR_SkipGram_SetNgramSize(PrimitivePtr *primitive, int64_t ngram_size); 192+ 193+// ********** Switch ********** 194+PrimitivePtr MindIR_Switch_CreatePrimitive(); 195+ 196+// ********** Unique ********** 197+PrimitivePtr MindIR_Unique_CreatePrimitive(); 198+ 199+// ********** UnsortedSegmentSum ********** 200+PrimitivePtr MindIR_UnsortedSegmentSum_CreatePrimitive(); 201+ 202+// ********** ZerosLike ********** 203+PrimitivePtr MindIR_ZerosLike_CreatePrimitive(); 204+ 205+// ********** GRU ********** 206+PrimitivePtr MindIR_GRU_CreatePrimitive( bool bidirectional); 207+bool MindIR_GRU_GetBidirectional(ConstPrimitivePtr primitive); 208+void MindIR_GRU_SetBidirectional(PrimitivePtr *primitive, bool bidirectional); 209+ 210+// ********** NonZero ********** 211+PrimitivePtr MindIR_NonZero_CreatePrimitive(); 212+ 213+// ********** InvertPermutation ********** 214+PrimitivePtr MindIR_InvertPermutation_CreatePrimitive(); 215+ 216+// ********** Size ********** 217+PrimitivePtr MindIR_Size_CreatePrimitive(); 218+ 219+// ********** RandomStandardNormal ********** 220+PrimitivePtr MindIR_RandomStandardNormal_CreatePrimitive(int64_t seed, int64_t seed2); 221+int64_t MindIR_RandomStandardNormal_GetSeed(ConstPrimitivePtr primitive); 222+void MindIR_RandomStandardNormal_SetSeed(PrimitivePtr *primitive, int64_t seed); 223+int64_t MindIR_RandomStandardNormal_GetSeed2(ConstPrimitivePtr primitive); 224+void MindIR_RandomStandardNormal_SetSeed2(PrimitivePtr *primitive, int64_t seed2); 225+ 226+// ********** CropAndResize ********** 227+PrimitivePtr MindIR_CropAndResize_CreatePrimitive(ResizeMethod method, float extrapolation_value); 228+ResizeMethod MindIR_CropAndResize_GetMethod(ConstPrimitivePtr primitive); 229+void MindIR_CropAndResize_SetMethod(PrimitivePtr *primitive, ResizeMethod method); 230+float MindIR_CropAndResize_GetExtrapolationValue(ConstPrimitivePtr primitive); 231+void MindIR_CropAndResize_SetExtrapolationValue(PrimitivePtr *primitive, float extrapolation_value); 232+ 233+// ********** IsFinite ********** 234+PrimitivePtr MindIR_IsFinite_CreatePrimitive(); 235+ 236+// ********** LinSpace ********** 237+PrimitivePtr MindIR_LinSpace_CreatePrimitive(); 238+ 239+// ********** UniformReal ********** 240+PrimitivePtr MindIR_UniformReal_CreatePrimitive(int64_t seed, int64_t seed2); 241+int64_t MindIR_UniformReal_GetSeed(ConstPrimitivePtr primitive); 242+void MindIR_UniformReal_SetSeed(PrimitivePtr *primitive, int64_t seed); 243+int64_t MindIR_UniformReal_GetSeed2(ConstPrimitivePtr primitive); 244+void MindIR_UniformReal_SetSeed2(PrimitivePtr *primitive, int64_t seed2); 245+ 246+// ********** Splice ********** 247+PrimitivePtr MindIR_Splice_CreatePrimitive(const std::vector<int64_t>& context, const std::vector<int64_t>& forward_indexes, int64_t output_dim); 248+std::vector<int64_t> MindIR_Splice_GetContext(ConstPrimitivePtr primitive); 249+void MindIR_Splice_SetContext(PrimitivePtr *primitive, const std::vector<int64_t>& context); 250+std::vector<int64_t> MindIR_Splice_GetForwardIndexes(ConstPrimitivePtr primitive); 251+void MindIR_Splice_SetForwardIndexes(PrimitivePtr *primitive, const std::vector<int64_t>& forward_indexes); 252+int64_t MindIR_Splice_GetOutputDim(ConstPrimitivePtr primitive); 253+void MindIR_Splice_SetOutputDim(PrimitivePtr *primitive, int64_t output_dim); 254+ 255+// ********** Call ********** 256+PrimitivePtr MindIR_Call_CreatePrimitive(bool is_tail_call); 257+bool MindIR_Call_GetIsTailCall(ConstPrimitivePtr primitive); 258+void MindIR_Call_SetIsTailCall(PrimitivePtr *primitive, bool is_tail_call); 259+ 260+// ********** CumSum ********** 261+PrimitivePtr MindIR_CumSum_CreatePrimitive(bool exclusive, bool reverse); 262+bool MindIR_CumSum_GetExclusive(ConstPrimitivePtr primitive); 263+void MindIR_CumSum_SetExclusive(PrimitivePtr *primitive, bool exclusive); 264+bool MindIR_CumSum_GetReverse(ConstPrimitivePtr primitive); 265+void MindIR_CumSum_SetReverse(PrimitivePtr *primitive, bool reverse); 266+ 267+// ********** SplitWithOverlap ********** 268+PrimitivePtr MindIR_SplitWithOverlap_CreatePrimitive(int64_t split_dim, int64_t number_split, const std::vector<int64_t>& ratio, const std::vector<int64_t>& extend_top, const std::vector<int64_t>& extend_bottom); 269+int64_t MindIR_SplitWithOverlap_GetSplitDim(ConstPrimitivePtr primitive); 270+void MindIR_SplitWithOverlap_SetSplitDim(PrimitivePtr *primitive, int64_t split_dim); 271+int64_t MindIR_SplitWithOverlap_GetNumberSplit(ConstPrimitivePtr primitive); 272+void MindIR_SplitWithOverlap_SetNumberSplit(PrimitivePtr *primitive, int64_t number_split); 273+std::vector<int64_t> MindIR_SplitWithOverlap_GetRatio(ConstPrimitivePtr primitive); 274+void MindIR_SplitWithOverlap_SetRatio(PrimitivePtr *primitive, const std::vector<int64_t>& ratio); 275+std::vector<int64_t> MindIR_SplitWithOverlap_GetExtendTop(ConstPrimitivePtr primitive); 276+void MindIR_SplitWithOverlap_SetExtendTop(PrimitivePtr *primitive, const std::vector<int64_t>& extend_top); 277+std::vector<int64_t> MindIR_SplitWithOverlap_GetExtendBottom(ConstPrimitivePtr primitive); 278+void MindIR_SplitWithOverlap_SetExtendBottom(PrimitivePtr *primitive, const std::vector<int64_t>& extend_bottom); 279+ 280+// ********** GenOP ********** 281+PrimitivePtr MindIR_GenOP_CreatePrimitive(ActivationType activation_type, float alpha, float min_val, float max_val, bool is_training, Format format, const std::vector<int64_t>& kernel_size, const std::vector<int64_t>& stride, const std::vector<int64_t>& dilation, PadMode pad_mode, const std::vector<int64_t>& pad_list, int64_t mode, int64_t group, int64_t in_channel, int64_t out_channel, EltwiseMode eltwise_mode, bool has_bias, bool use_axis, int64_t axis, float epsilon, float momentum, bool transpose_a, bool transpose_b, const std::vector<int64_t>& pad, RoundMode round_mode, bool global, bool channel_shared, const std::vector<int64_t>& axes, bool keep_dims, ReduceMode reduce_mode, bool reduce_to_end, float coeff); 282+ActivationType MindIR_GenOP_GetActivationType(ConstPrimitivePtr primitive); 283+void MindIR_GenOP_SetActivationType(PrimitivePtr *primitive, ActivationType activation_type); 284+float MindIR_GenOP_GetAlpha(ConstPrimitivePtr primitive); 285+void MindIR_GenOP_SetAlpha(PrimitivePtr *primitive, float alpha); 286+float MindIR_GenOP_GetMinVal(ConstPrimitivePtr primitive); 287+void MindIR_GenOP_SetMinVal(PrimitivePtr *primitive, float min_val); 288+float MindIR_GenOP_GetMaxVal(ConstPrimitivePtr primitive); 289+void MindIR_GenOP_SetMaxVal(PrimitivePtr *primitive, float max_val); 290+bool MindIR_GenOP_GetIsTraining(ConstPrimitivePtr primitive); 291+void MindIR_GenOP_SetIsTraining(PrimitivePtr *primitive, bool is_training); 292+Format MindIR_GenOP_GetFormat(ConstPrimitivePtr primitive); 293+void MindIR_GenOP_SetFormat(PrimitivePtr *primitive, Format format); 294+std::vector<int64_t> MindIR_GenOP_GetKernelSize(ConstPrimitivePtr primitive); 295+void MindIR_GenOP_SetKernelSize(PrimitivePtr *primitive, const std::vector<int64_t>& kernel_size); 296+std::vector<int64_t> MindIR_GenOP_GetStride(ConstPrimitivePtr primitive); 297+void MindIR_GenOP_SetStride(PrimitivePtr *primitive, const std::vector<int64_t>& stride); 298+std::vector<int64_t> MindIR_GenOP_GetDilation(ConstPrimitivePtr primitive); 299+void MindIR_GenOP_SetDilation(PrimitivePtr *primitive, const std::vector<int64_t>& dilation); 300+PadMode MindIR_GenOP_GetPadMode(ConstPrimitivePtr primitive); 301+void MindIR_GenOP_SetPadMode(PrimitivePtr *primitive, PadMode pad_mode); 302+std::vector<int64_t> MindIR_GenOP_GetPadList(ConstPrimitivePtr primitive); 303+void MindIR_GenOP_SetPadList(PrimitivePtr *primitive, const std::vector<int64_t>& pad_list); 304+int64_t MindIR_GenOP_GetMode(ConstPrimitivePtr primitive); 305+void MindIR_GenOP_SetMode(PrimitivePtr *primitive, int64_t mode); 306+int64_t MindIR_GenOP_GetGroup(ConstPrimitivePtr primitive); 307+void MindIR_GenOP_SetGroup(PrimitivePtr *primitive, int64_t group); 308+int64_t MindIR_GenOP_GetInChannel(ConstPrimitivePtr primitive); 309+void MindIR_GenOP_SetInChannel(PrimitivePtr *primitive, int64_t in_channel); 310+int64_t MindIR_GenOP_GetOutChannel(ConstPrimitivePtr primitive); 311+void MindIR_GenOP_SetOutChannel(PrimitivePtr *primitive, int64_t out_channel); 312+EltwiseMode MindIR_GenOP_GetEltwiseMode(ConstPrimitivePtr primitive); 313+void MindIR_GenOP_SetEltwiseMode(PrimitivePtr *primitive, EltwiseMode eltwise_mode); 314+bool MindIR_GenOP_GetHasBias(ConstPrimitivePtr primitive); 315+void MindIR_GenOP_SetHasBias(PrimitivePtr *primitive, bool has_bias); 316+bool MindIR_GenOP_GetUseAxis(ConstPrimitivePtr primitive); 317+void MindIR_GenOP_SetUseAxis(PrimitivePtr *primitive, bool use_axis); 318+int64_t MindIR_GenOP_GetAxis(ConstPrimitivePtr primitive); 319+void MindIR_GenOP_SetAxis(PrimitivePtr *primitive, int64_t axis); 320+float MindIR_GenOP_GetEpsilon(ConstPrimitivePtr primitive); 321+void MindIR_GenOP_SetEpsilon(PrimitivePtr *primitive, float epsilon); 322+float MindIR_GenOP_GetMomentum(ConstPrimitivePtr primitive); 323+void MindIR_GenOP_SetMomentum(PrimitivePtr *primitive, float momentum); 324+bool MindIR_GenOP_GetTransposeA(ConstPrimitivePtr primitive); 325+void MindIR_GenOP_SetTransposeA(PrimitivePtr *primitive, bool transpose_a); 326+bool MindIR_GenOP_GetTransposeB(ConstPrimitivePtr primitive); 327+void MindIR_GenOP_SetTransposeB(PrimitivePtr *primitive, bool transpose_b); 328+std::vector<int64_t> MindIR_GenOP_GetPad(ConstPrimitivePtr primitive); 329+void MindIR_GenOP_SetPad(PrimitivePtr *primitive, const std::vector<int64_t>& pad); 330+RoundMode MindIR_GenOP_GetRoundMode(ConstPrimitivePtr primitive); 331+void MindIR_GenOP_SetRoundMode(PrimitivePtr *primitive, RoundMode round_mode); 332+bool MindIR_GenOP_GetGlobal(ConstPrimitivePtr primitive); 333+void MindIR_GenOP_SetGlobal(PrimitivePtr *primitive, bool global); 334+bool MindIR_GenOP_GetChannelShared(ConstPrimitivePtr primitive); 335+void MindIR_GenOP_SetChannelShared(PrimitivePtr *primitive, bool channel_shared); 336+std::vector<int64_t> MindIR_GenOP_GetAxes(ConstPrimitivePtr primitive); 337+void MindIR_GenOP_SetAxes(PrimitivePtr *primitive, const std::vector<int64_t>& axes); 338+bool MindIR_GenOP_GetKeepDims(ConstPrimitivePtr primitive); 339+void MindIR_GenOP_SetKeepDims(PrimitivePtr *primitive, bool keep_dims); 340+ReduceMode MindIR_GenOP_GetReduceMode(ConstPrimitivePtr primitive); 341+void MindIR_GenOP_SetReduceMode(PrimitivePtr *primitive, ReduceMode reduce_mode); 342+bool MindIR_GenOP_GetReduceToEnd(ConstPrimitivePtr primitive); 343+void MindIR_GenOP_SetReduceToEnd(PrimitivePtr *primitive, bool reduce_to_end); 344+float MindIR_GenOP_GetCoeff(ConstPrimitivePtr primitive); 345+void MindIR_GenOP_SetCoeff(PrimitivePtr *primitive, float coeff); 346+ 347+// ********** RaggedRange ********** 348+PrimitivePtr MindIR_RaggedRange_CreatePrimitive(); 349+ 350+// ********** GLU ********** 351+PrimitivePtr MindIR_GLU_CreatePrimitive(int64_t axis); 352+int64_t MindIR_GLU_GetAxis(ConstPrimitivePtr primitive); 353+void MindIR_GLU_SetAxis(PrimitivePtr *primitive, int64_t axis); 354+ 355+// ********** Affine ********** 356+PrimitivePtr MindIR_Affine_CreatePrimitive(const std::vector<int64_t>& context, int64_t output_dim, ActivationType activation_type, bool transpose_a, bool transpose_b); 357+std::vector<int64_t> MindIR_Affine_GetContext(ConstPrimitivePtr primitive); 358+void MindIR_Affine_SetContext(PrimitivePtr *primitive, const std::vector<int64_t>& context); 359+int64_t MindIR_Affine_GetOutputDim(ConstPrimitivePtr primitive); 360+void MindIR_Affine_SetOutputDim(PrimitivePtr *primitive, int64_t output_dim); 361+ActivationType MindIR_Affine_GetActivationType(ConstPrimitivePtr primitive); 362+void MindIR_Affine_SetActivationType(PrimitivePtr *primitive, ActivationType activation_type); 363+bool MindIR_Affine_GetTransposeA(ConstPrimitivePtr primitive); 364+void MindIR_Affine_SetTransposeA(PrimitivePtr *primitive, bool transpose_a); 365+bool MindIR_Affine_GetTransposeB(ConstPrimitivePtr primitive); 366+void MindIR_Affine_SetTransposeB(PrimitivePtr *primitive, bool transpose_b); 367+ 368+// ********** AllGather ********** 369+PrimitivePtr MindIR_AllGather_CreatePrimitive(const std::string& group, int32_t rank_size); 370+std::string MindIR_AllGather_GetGroup(ConstPrimitivePtr primitive); 371+void MindIR_AllGather_SetGroup(PrimitivePtr *primitive, const std::string& group); 372+int32_t MindIR_AllGather_GetRankSize(ConstPrimitivePtr primitive); 373+void MindIR_AllGather_SetRankSize(PrimitivePtr *primitive, int32_t rank_size); 374+ 375+ 376+ 377+// ********** ReduceScatter ********** 378+PrimitivePtr MindIR_ReduceScatter_CreatePrimitive(const std::string& group, ReduceMode mode, int32_t rank_size); 379+std::string MindIR_ReduceScatter_GetGroup(ConstPrimitivePtr primitive); 380+void MindIR_ReduceScatter_SetGroup(PrimitivePtr *primitive, const std::string& group); 381+ReduceMode MindIR_ReduceScatter_GetMode(ConstPrimitivePtr primitive); 382+void MindIR_ReduceScatter_SetMode(PrimitivePtr *primitive, ReduceMode mode); 383+int32_t MindIR_ReduceScatter_GetRankSize(ConstPrimitivePtr primitive); 384+void MindIR_ReduceScatter_SetRankSize(PrimitivePtr *primitive, int32_t rank_size); 385+ 386+ 387+ 388+// ********** DynamicQuant ********** 389+PrimitivePtr MindIR_DynamicQuant_CreatePrimitive(bool symmetric, int64_t dst_type); 390+bool MindIR_DynamicQuant_GetSymmetric(ConstPrimitivePtr primitive); 391+void MindIR_DynamicQuant_SetSymmetric(PrimitivePtr *primitive, bool symmetric); 392+int64_t MindIR_DynamicQuant_GetDstType(ConstPrimitivePtr primitive); 393+void MindIR_DynamicQuant_SetDstType(PrimitivePtr *primitive, int64_t dst_type); 394+ 395+// ********** RandomNormal ********** 396+PrimitivePtr MindIR_RandomNormal_CreatePrimitive(float seed, float mean, float scale); 397+float MindIR_RandomNormal_GetSeed(ConstPrimitivePtr primitive); 398+void MindIR_RandomNormal_SetSeed(PrimitivePtr *primitive, float seed); 399+float MindIR_RandomNormal_GetMean(ConstPrimitivePtr primitive); 400+void MindIR_RandomNormal_SetMean(PrimitivePtr *primitive, float mean); 401+float MindIR_RandomNormal_GetScale(ConstPrimitivePtr primitive); 402+void MindIR_RandomNormal_SetScale(PrimitivePtr *primitive, float scale); 403+ 404+// ********** FormatTranspose ********** 405+PrimitivePtr MindIR_FormatTranspose_CreatePrimitive(Format src_format, Format dst_format); 406+Format MindIR_FormatTranspose_GetSrcFormat(ConstPrimitivePtr primitive); 407+void MindIR_FormatTranspose_SetSrcFormat(PrimitivePtr *primitive, Format src_format); 408+Format MindIR_FormatTranspose_GetDstFormat(ConstPrimitivePtr primitive); 409+void MindIR_FormatTranspose_SetDstFormat(PrimitivePtr *primitive, Format dst_format); 410+ 411+// ********** GatherD ********** 412+PrimitivePtr MindIR_GatherD_CreatePrimitive(); 413+ 414+// ********** GroupNormFusion ********** 415+PrimitivePtr MindIR_GroupNormFusion_CreatePrimitive(int64_t num_groups, float epsilon, bool affine); 416+int64_t MindIR_GroupNormFusion_GetNumGroups(ConstPrimitivePtr primitive); 417+void MindIR_GroupNormFusion_SetNumGroups(PrimitivePtr *primitive, int64_t num_groups); 418+float MindIR_GroupNormFusion_GetEpsilon(ConstPrimitivePtr primitive); 419+void MindIR_GroupNormFusion_SetEpsilon(PrimitivePtr *primitive, float epsilon); 420+bool MindIR_GroupNormFusion_GetAffine(ConstPrimitivePtr primitive); 421+void MindIR_GroupNormFusion_SetAffine(PrimitivePtr *primitive, bool affine); 422+ 423+// ********** Log1p ********** 424+PrimitivePtr MindIR_Log1p_CreatePrimitive(); 425+ 426+// ********** SparseFillEmptyRows ********** 427+PrimitivePtr MindIR_SparseFillEmptyRows_CreatePrimitive(); 428+ 429+// ********** SparseReshape ********** 430+PrimitivePtr MindIR_SparseReshape_CreatePrimitive(); 431+ 432+// ********** SparseSegmentSum ********** 433+PrimitivePtr MindIR_SparseSegmentSum_CreatePrimitive(); 434+ 435+// ********** ScatterElements ********** 436+PrimitivePtr MindIR_ScatterElements_CreatePrimitive(int64_t axis); 437+int64_t MindIR_ScatterElements_GetAxis(ConstPrimitivePtr primitive); 438+void MindIR_ScatterElements_SetAxis(PrimitivePtr *primitive, int64_t axis); 439+ 440+// ********** Triu ********** 441+PrimitivePtr MindIR_Triu_CreatePrimitive(); 442+ 443+// ********** Tril ********** 444+PrimitivePtr MindIR_Tril_CreatePrimitive(); 445+ 446 // ********** Custom ********** 447 std::vector<const mindspore::schema::Attribute *> MindIR_Custom_GetAttr(ConstPrimitivePtr primitive); 448 std::string MindIR_Attribute_GetName(const mindspore::schema::Attribute &attr); 449diff --git a/mindspore/lite/mindir/include/mindir_tensor.h b/mindspore/lite/mindir/include/mindir_tensor.h 450index 43c1478c..d8b4aa37 100644 451--- a/mindspore/lite/mindir/include/mindir_tensor.h 452+++ b/mindspore/lite/mindir/include/mindir_tensor.h 453@@ -23,6 +23,7 @@ void MindIR_Tensor_SetData(TensorPtr *tensor, const std::vector<uint8_t> &data); 454 std::vector<uint8_t> MindIR_Tensor_GetData(ConstTensorPtr tensor); 455 std::vector<QuantParam> MindIR_Tensor_GetQuantParams(ConstTensorPtr tensor); 456 void MindIR_Tensor_SetQuantParams(TensorPtr *tensor, const std::vector<QuantParam> &quant_params); 457+int32_t MindIR_Tensor_GetNodeType(ConstTensorPtr tensor); 458 459 void MindIR_Tensor_Destroy(TensorPtr *tensor); 460 461diff --git a/mindspore/lite/mindir/include/mindir_types.h b/mindspore/lite/mindir/include/mindir_types.h 462index 196995fa..ec224b2c 100644 463--- a/mindspore/lite/mindir/include/mindir_types.h 464+++ b/mindspore/lite/mindir/include/mindir_types.h 465@@ -84,6 +84,7 @@ enum NodeType : uint32_t { 466 NODE_TYPE_ARGMAX_FUSION = 11, 467 NODE_TYPE_ASSERT = 13, 468 NODE_TYPE_AVG_POOL_FUSION = 17, 469+ NODE_TYPE_BATCH_TO_SPACE = 21, 470 NODE_TYPE_BATCH_TO_SPACE_ND = 22, 471 NODE_TYPE_BIAS_ADD = 23, 472 NODE_TYPE_BROADCAST_TO = 27, 473@@ -96,15 +97,25 @@ enum NodeType : uint32_t { 474 NODE_TYPE_COS = 37, 475 NODE_TYPE_CONSTANT_OF_SHAPE = 38, 476 NODE_TYPE_CROP = 39, 477+ NODE_TYPE_DEPEND = 44, 478 NODE_TYPE_DEPTH_TO_SPACE = 45, 479 NODE_TYPE_DETECTION_POST_PROCESS = 46, 480 NODE_TYPE_DIV_FUSION = 47, 481+ NODE_TYPE_DROPOUT = 49, 482+ NODE_TYPE_ELU = 51, 483 NODE_TYPE_ELTWISE = 52, 484 NODE_TYPE_EQUAL = 53, 485+ NODE_TYPE_EMBEDDING_LOOKUP_FUSION = 54, 486 NODE_TYPE_EXPFUSION = 55, 487 NODE_TYPE_EXPAND_DIMS = 56, 488+ NODE_TYPE_FAKE_QUANT_WITH_MIN_MAX_VARS = 57, 489+ NODE_TYPE_FAKE_QUANT_WITH_MIN_MAX_VARS_PER_CHANNEL = 58, 490+ NODE_TYPE_FFT_REAL = 59, 491+ NODE_TYPE_FFT_IMAG = 60, 492 NODE_TYPE_FLATTEN = 61, 493 NODE_TYPE_FLOOR = 63, 494+ NODE_TYPE_FLOOR_DIV = 64, 495+ NODE_TYPE_FLOOR_MOD = 65, 496 NODE_TYPE_FILL = 66, 497 NODE_TYPE_FULL_CONNECTION = 67, 498 NODE_TYPE_FUSED_BATCH_NORM = 68, 499@@ -112,6 +123,7 @@ enum NodeType : uint32_t { 500 NODE_TYPE_GATHER_ND = 70, 501 NODE_TYPE_GREATER = 71, 502 NODE_TYPE_GREATER_EQUAL = 72, 503+ NODE_TYPE_HASHTABLE_LOOKUP = 73, 504 NODE_TYPE_INSTANCE_NORM = 74, 505 NODE_TYPE_LAYER_NORM_FUSION = 75, 506 NODE_TYPE_LEAKY_RELU = 76, 507@@ -121,20 +133,28 @@ enum NodeType : uint32_t { 508 NODE_TYPE_LOGICAL_AND = 81, 509 NODE_TYPE_LOGICAL_NOT = 82, 510 NODE_TYPE_LOGICAL_OR = 83, 511+ NODE_TYPE_LP_NORMALIZATION = 84, 512 NODE_TYPE_L_R_N = 85, 513+ NODE_TYPE_LSH_PROJECTION = 86, 514 NODE_TYPE_LSTM = 87, 515 NODE_TYPE_L2_NORMALIZE_FUSION = 88, 516 NODE_TYPE_MATMUL_FUSION = 89, 517 NODE_TYPE_MAXIMUM = 90, 518 NODE_TYPE_MAX_POOL_FUSION = 92, 519+ NODE_TYPE_SWITCH_LAYER = 94, 520+ NODE_TYPE_MFCC = 95, 521 NODE_TYPE_MINIMUM = 96, 522 NODE_TYPE_MOD = 98, 523 NODE_TYPE_MUL_FUSION = 99, 524 NODE_TYPE_NEG = 101, 525 NODE_TYPE_NOT_EQUAL = 103, 526+ NODE_TYPE_NON_MAX_SUPPRESSION = 104, 527 NODE_TYPE_ONE_HOT = 105, 528+ NODE_TYPE_ONES_LIKE = 106, 529 NODE_TYPE_PAD_FUSION = 107, 530+ NODE_TYPE_PARTIAL_FUSION = 108, 531 NODE_TYPE_POW_FUSION = 110, 532+ NODE_TYPE_PRIOR_BOX = 111, 533 NODE_TYPE_PRELU_FUSION = 112, 534 NODE_TYPE_QUANT_DTYPE_CAST = 113, 535 NODE_TYPE_RANK = 114, 536@@ -144,12 +164,17 @@ enum NodeType : uint32_t { 537 NODE_TYPE_REDUCE_FUSION = 118, 538 NODE_TYPE_RESHAPE = 119, 539 NODE_TYPE_RESIZE = 120, 540+ NODE_TYPE_REVERSE_SEQUENCE = 121, 541+ NODE_TYPE_REVERSE_V2 = 122, 542+ NODE_TYPE_RFFT = 123, 543+ NODE_TYPE_R_O_I_POOLING = 124, 544 NODE_TYPE_ROUND = 125, 545 NODE_TYPE_RSQRT = 126, 546 NODE_TYPE_SCALE_FUSION = 127, 547 NODE_TYPE_SCATTER_ND = 128, 548 NODE_TYPE_SHAPE = 130, 549 NODE_TYPE_SIN = 133, 550+ NODE_TYPE_SKIP_GRAM = 134, 551 NODE_TYPE_SLICE_FUSION = 135, 552 NODE_TYPE_SOFTMAX = 138, 553 NODE_TYPE_SPACE_TO_BATCH_ND = 141, 554@@ -163,16 +188,51 @@ enum NodeType : uint32_t { 555 NODE_TYPE_STACK = 150, 556 NODE_TYPE_STRIDED_SLICE = 151, 557 NODE_TYPE_SUB_FUSION = 152, 558+ NODE_TYPE_SWITCH = 154, 559 NODE_TYPE_TILE_FUSION = 160, 560 NODE_TYPE_TOPK_FUSION = 161, 561 NODE_TYPE_TRANSPOSE = 162, 562+ NODE_TYPE_UNIQUE = 163, 563+ NODE_TYPE_UNSORTED_SEGMENT_SUM = 164, 564 NODE_TYPE_UNSQUEEZE = 165, 565 NODE_TYPE_UNSTACK = 166, 566 NODE_TYPE_WHERE = 168, 567+ NODE_TYPE_ZEROS_LIKE = 169, 568 NODE_TYPE_SELECT = 170, 569+ NODE_TYPE_G_R_U = 172, 570+ NODE_TYPE_NON_ZERO = 173, 571+ NODE_TYPE_INVERT_PERMUTATION = 174, 572+ NODE_TYPE_SIZE = 175, 573+ NODE_TYPE_RANDOM_STANDARD_NORMAL = 176, 574+ NODE_TYPE_CROP_AND_RESIZE = 177, 575 NODE_TYPE_ERF = 178, 576+ NODE_TYPE_IS_FINITE = 180, 577+ NODE_TYPE_LIN_SPACE = 181, 578+ NODE_TYPE_UNIFORM_REAL = 182, 579+ NODE_TYPE_SPLICE = 188, 580 NODE_TYPE_LOG_SOFTMAX = 189, 581+ NODE_TYPE_CALL = 190, 582 NODE_TYPE_CUSTOM = 191, 583+ NODE_TYPE_CUM_SUM = 192, 584+ NODE_TYPE_SPLIT_WITH_OVERLAP = 193, 585+ NODE_TYPE_GEN_O_P = 194, 586+ NODE_TYPE_RAGGED_RANGE = 195, 587+ NODE_TYPE_G_L_U = 196, 588+ NODE_TYPE_AFFINE = 200, 589+ NODE_TYPE_ALL_GATHER = 201, 590+ NODE_TYPE_REDUCE_SCATTER = 202, 591+ NODE_TYPE_DYNAMIC_QUANT = 203, 592+ NODE_TYPE_RANDOM_NORMAL = 206, 593+ NODE_TYPE_FORMAT_TRANSPOSE = 209, 594+ NODE_TYPE_GATHER_D = 210, 595+ NODE_TYPE_GROUP_NORM_FUSION = 211, 596+ NODE_TYPE_LOG1P = 212, 597+ NODE_TYPE_SPARSE_FILL_EMPTY_ROWS = 214, 598+ NODE_TYPE_SPARSE_RESHAPE = 215, 599+ NODE_TYPE_SPARSE_SEGMENT_SUM = 216, 600+ NODE_TYPE_SCATTER_ELEMENTS = 217, 601+ NODE_TYPE_TRIU = 218, 602+ NODE_TYPE_TRIL = 219, 603 }; 604 605 enum ResizeMethod : int8_t { 606diff --git a/mindspore/lite/mindir/src/mindir.cc b/mindspore/lite/mindir/src/mindir.cc 607index a1f86671..39600e4d 100644 608--- a/mindspore/lite/mindir/src/mindir.cc 609+++ b/mindspore/lite/mindir/src/mindir.cc 610@@ -4674,10 +4674,10 @@ std::string MindIR_DepthToSpace_GetMode(ConstPrimitivePtr primitive) { 611 if (prim != nullptr && value != nullptr) { 612 return std::string(value->mode()->c_str(),value->mode()->size()); 613 } else { 614- return nullptr; 615+ return ""; 616 } 617 } else { 618- return nullptr; 619+ return ""; 620 } 621 } 622 623@@ -6210,10 +6210,10 @@ std::string MindIR_LRN_GetNormRegion(ConstPrimitivePtr primitive) { 624 if (prim != nullptr && value != nullptr) { 625 return std::string(value->norm_region()->c_str(),value->norm_region()->size()); 626 } else { 627- return nullptr; 628+ return ""; 629 } 630 } else { 631- return nullptr; 632+ return ""; 633 } 634 } 635 636@@ -6750,6 +6750,104 @@ PrimitivePtr MindIR_GatherNd_CreatePrimitive() { 637 return ret_value; 638 } 639 640+// ********** BatchToSpace ********** 641+PrimitivePtr MindIR_BatchToSpace_CreatePrimitive(const std::vector<int64_t> &block_size, 642+ const std::vector<std::vector<int64_t>> &crops) { 643+ flatbuffers::FlatBufferBuilder fbb; 644+ auto ops_offset = schema::CreateBatchToSpace(fbb, fbb.CreateVector(block_size.data(), block_size.size()), 645+ CreateVec2D(fbb, crops)); 646+ auto prim_offset = 647+ schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_BATCH_TO_SPACE), ops_offset.o); 648+ fbb.Finish(prim_offset); 649+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 650+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 651+ return ret_value; 652+} 653+ 654+std::vector<int64_t> MindIR_BatchToSpace_GetBlockSize(ConstPrimitivePtr primitive) { 655+ if (primitive != nullptr) { 656+ auto prim = static_cast<const schema::Primitive *>(primitive); 657+ auto value = prim->value_as_BatchToSpace(); 658+ if (prim != nullptr && value != nullptr) { 659+ std::vector<int64_t> result; 660+ auto src = value->block_size(); 661+ if (src == nullptr) { 662+ return {}; 663+ } 664+ result.resize(src->size()); 665+ std::transform(src->begin(), src->end(), result.begin(), [](int64_t item) { return item; }); 666+ return result; 667+ } else { 668+ return {}; 669+ } 670+ } else { 671+ return {}; 672+ } 673+} 674+ 675+void MindIR_BatchToSpace_SetBlockSize(PrimitivePtr *primitive, const std::vector<int64_t> &block_size) { 676+ if (primitive != nullptr && *primitive != nullptr) { 677+ auto prim = static_cast<schema::Primitive *>(*primitive); 678+ auto value = prim->value_as_BatchToSpace(); 679+ if (prim != nullptr && value != nullptr) { 680+ flatbuffers::FlatBufferBuilder fbb; 681+ auto ops_offset = schema::CreateBatchToSpace(fbb, fbb.CreateVector(block_size.data(), block_size.size()), 682+ CreateVec2D(fbb, value->crops())); 683+ auto prim_offset = 684+ schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_BATCH_TO_SPACE), ops_offset.o); 685+ fbb.Finish(prim_offset); 686+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 687+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 688+ free(*primitive); 689+ *primitive = ret_value; 690+ } 691+ } 692+} 693+ 694+std::vector<std::vector<int64_t>> MindIR_BatchToSpace_GetCrops(ConstPrimitivePtr primitive) { 695+ if (primitive != nullptr) { 696+ auto prim = static_cast<const schema::Primitive *>(primitive); 697+ auto value = prim->value_as_BatchToSpace(); 698+ if (prim != nullptr && value != nullptr) { 699+ std::vector<std::vector<int64_t>> out; 700+ auto src = value->crops(); 701+ if (src == nullptr) { 702+ return {}; 703+ } 704+ for (auto sub_list : *src->data()) { 705+ std::vector<int64_t> result_tmp; 706+ result_tmp.resize(sub_list->data()->size()); 707+ std::transform(sub_list->data()->begin(), sub_list->data()->end(), result_tmp.begin(), 708+ [](int64_t item) { return item; }); 709+ out.emplace_back(result_tmp); 710+ } 711+ return out; 712+ } else { 713+ return {}; 714+ } 715+ } else { 716+ return {}; 717+ } 718+} 719+ 720+void MindIR_BatchToSpace_SetCrops(PrimitivePtr *primitive, const std::vector<std::vector<int64_t>> &crops) { 721+ if (primitive != nullptr && *primitive != nullptr) { 722+ auto prim = static_cast<schema::Primitive *>(*primitive); 723+ auto value = prim->value_as_BatchToSpace(); 724+ if (prim != nullptr && value != nullptr) { 725+ flatbuffers::FlatBufferBuilder fbb; 726+ auto ops_offset = schema::CreateBatchToSpace( 727+ fbb, fbb.CreateVector(value->block_size()->data(), value->block_size()->size()), CreateVec2D(fbb, crops)); 728+ auto prim_offset = 729+ schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_BATCH_TO_SPACE), ops_offset.o); 730+ fbb.Finish(prim_offset); 731+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, prim); 732+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 733+ *primitive = ret_value; 734+ } 735+ } 736+} 737+ 738 // ********** Custom ********** 739 std::vector<const mindspore::schema::Attribute *> MindIR_Custom_GetAttr(ConstPrimitivePtr primitive) { 740 if (primitive == nullptr) { 741diff --git a/mindspore/lite/mindir/src/mindir_1.cc b/mindspore/lite/mindir/src/mindir_1.cc 742new file mode 100644 743index 00000000..5177e881 744--- /dev/null 745+++ b/mindspore/lite/mindir/src/mindir_1.cc 746@@ -0,0 +1,2061 @@ 747+/** 748+ * Copyright 2024 Huawei Technologies Co., Ltd 749+ * 750+ * Licensed under the Apache License, Version 2.0 (the "License"); 751+ * you may not use this file except in compliance with the License. 752+ * You may obtain a copy of the License at 753+ * 754+ * http://www.apache.org/licenses/LICENSE-2.0 755+ * 756+ * Unless required by applicable law or agreed to in writing, software 757+ * distributed under the License is distributed on an "AS IS" BASIS, 758+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 759+ * See the License for the specific language governing permissions and 760+ * limitations under the License. 761+ */ 762+ 763+#include "mindir.h" 764+#include "utils.h" 765+#include "schema/model_generated.h" 766+#include "mindir_memory_manager.h" 767+ 768+namespace mindspore { 769+namespace lite { 770+// ********** Depend ********** 771+PrimitivePtr MindIR_Depend_CreatePrimitive() { 772+ flatbuffers::FlatBufferBuilder fbb; 773+ auto ops_offset = schema::CreateDepend(fbb); 774+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_DEPEND), ops_offset.o); 775+ fbb.Finish(prim_offset); 776+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 777+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 778+ return ret_value; 779+} 780+ 781+// ********** Dropout ********** 782+PrimitivePtr MindIR_Dropout_CreatePrimitive(float keep_prob) { 783+ flatbuffers::FlatBufferBuilder fbb; 784+ auto ops_offset = schema::CreateDropout(fbb, keep_prob); 785+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_DROPOUT), ops_offset.o); 786+ fbb.Finish(prim_offset); 787+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 788+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 789+ return ret_value; 790+} 791+ 792+float MindIR_Dropout_GetKeepProb(ConstPrimitivePtr primitive) { 793+ if (primitive != nullptr) { 794+ auto prim = static_cast<const schema::Primitive *>(primitive); 795+ auto value = prim->value_as_Dropout(); 796+ if (prim != nullptr && value != nullptr) { 797+ return value->keep_prob(); 798+ } else { 799+ return .0; 800+ } 801+ } else { 802+ return .0; 803+ } 804+} 805+ 806+void MindIR_Dropout_SetKeepProb(PrimitivePtr *primitive, float keep_prob) { 807+ if (primitive != nullptr && *primitive != nullptr) { 808+ auto prim = static_cast<schema::Primitive *>(*primitive); 809+ auto value = prim->value_as_Dropout(); 810+ if (prim != nullptr && value != nullptr) { 811+ flatbuffers::FlatBufferBuilder fbb; 812+ auto ops_offset = schema::CreateDropout(fbb, keep_prob); 813+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_DROPOUT), ops_offset.o); 814+ fbb.Finish(prim_offset); 815+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, prim); 816+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 817+ *primitive = ret_value; 818+ } 819+ } 820+} 821+ 822+// ********** Elu ********** 823+PrimitivePtr MindIR_Elu_CreatePrimitive(float alpha) { 824+ flatbuffers::FlatBufferBuilder fbb; 825+ auto ops_offset = schema::CreateElu(fbb, alpha); 826+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_ELU), ops_offset.o); 827+ fbb.Finish(prim_offset); 828+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 829+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 830+ return ret_value; 831+} 832+ 833+float MindIR_Elu_GetAlpha(ConstPrimitivePtr primitive) { 834+ if (primitive != nullptr) { 835+ auto prim = static_cast<const schema::Primitive *>(primitive); 836+ auto value = prim->value_as_Elu(); 837+ if (prim != nullptr && value != nullptr) { 838+ return value->alpha(); 839+ } else { 840+ return .0; 841+ } 842+ } else { 843+ return .0; 844+ } 845+} 846+ 847+void MindIR_Elu_SetAlpha(PrimitivePtr *primitive, float alpha) { 848+ if (primitive != nullptr && *primitive != nullptr) { 849+ auto prim = static_cast<schema::Primitive *>(*primitive); 850+ auto value = prim->value_as_Elu(); 851+ if (prim != nullptr && value != nullptr) { 852+ flatbuffers::FlatBufferBuilder fbb; 853+ auto ops_offset = schema::CreateElu(fbb, alpha); 854+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_ELU), ops_offset.o); 855+ fbb.Finish(prim_offset); 856+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, prim); 857+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 858+ *primitive = ret_value; 859+ } 860+ } 861+} 862+ 863+// ********** EmbeddingLookupFusion ********** 864+PrimitivePtr MindIR_EmbeddingLookupFusion_CreatePrimitive(float max_norm) { 865+ flatbuffers::FlatBufferBuilder fbb; 866+ auto ops_offset = schema::CreateEmbeddingLookupFusion(fbb, max_norm); 867+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_EMBEDDING_LOOKUP_FUSION), ops_offset.o); 868+ fbb.Finish(prim_offset); 869+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 870+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 871+ return ret_value; 872+} 873+ 874+float MindIR_EmbeddingLookupFusion_GetMaxNorm(ConstPrimitivePtr primitive) { 875+ if (primitive != nullptr) { 876+ auto prim = static_cast<const schema::Primitive *>(primitive); 877+ auto value = prim->value_as_EmbeddingLookupFusion(); 878+ if (prim != nullptr && value != nullptr) { 879+ return value->max_norm(); 880+ } else { 881+ return .0; 882+ } 883+ } else { 884+ return .0; 885+ } 886+} 887+ 888+void MindIR_EmbeddingLookupFusion_SetMaxNorm(PrimitivePtr *primitive, float max_norm) { 889+ if (primitive != nullptr && *primitive != nullptr) { 890+ auto prim = static_cast<schema::Primitive *>(*primitive); 891+ auto value = prim->value_as_EmbeddingLookupFusion(); 892+ if (prim != nullptr && value != nullptr) { 893+ flatbuffers::FlatBufferBuilder fbb; 894+ auto ops_offset = schema::CreateEmbeddingLookupFusion(fbb, max_norm); 895+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_EMBEDDING_LOOKUP_FUSION), ops_offset.o); 896+ fbb.Finish(prim_offset); 897+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, prim); 898+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 899+ *primitive = ret_value; 900+ } 901+ } 902+} 903+ 904+// ********** FakeQuantWithMinMaxVars ********** 905+PrimitivePtr MindIR_FakeQuantWithMinMaxVars_CreatePrimitive(int64_t num_bits, bool narrow_range) { 906+ flatbuffers::FlatBufferBuilder fbb; 907+ auto ops_offset = schema::CreateFakeQuantWithMinMaxVars(fbb, num_bits, narrow_range); 908+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_FAKE_QUANT_WITH_MIN_MAX_VARS), ops_offset.o); 909+ fbb.Finish(prim_offset); 910+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 911+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 912+ return ret_value; 913+} 914+ 915+int64_t MindIR_FakeQuantWithMinMaxVars_GetNumBits(ConstPrimitivePtr primitive) { 916+ if (primitive != nullptr) { 917+ auto prim = static_cast<const schema::Primitive *>(primitive); 918+ auto value = prim->value_as_FakeQuantWithMinMaxVars(); 919+ if (prim != nullptr && value != nullptr) { 920+ return value->num_bits(); 921+ } else { 922+ return 0; 923+ } 924+ } else { 925+ return 0; 926+ } 927+} 928+ 929+void MindIR_FakeQuantWithMinMaxVars_SetNumBits(PrimitivePtr *primitive, int64_t num_bits) { 930+ if (primitive != nullptr && *primitive != nullptr) { 931+ auto prim = static_cast<schema::Primitive *>(*primitive); 932+ auto value = prim->value_as_FakeQuantWithMinMaxVars(); 933+ if (prim != nullptr && value != nullptr) { 934+ flatbuffers::FlatBufferBuilder fbb; 935+ auto ops_offset = schema::CreateFakeQuantWithMinMaxVars(fbb, num_bits, value->narrow_range()); 936+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_FAKE_QUANT_WITH_MIN_MAX_VARS), ops_offset.o); 937+ fbb.Finish(prim_offset); 938+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 939+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 940+ free(*primitive); 941+ *primitive = ret_value; 942+ } 943+ } 944+} 945+ 946+bool MindIR_FakeQuantWithMinMaxVars_GetNarrowRange(ConstPrimitivePtr primitive) { 947+ if (primitive != nullptr) { 948+ auto prim = static_cast<const schema::Primitive *>(primitive); 949+ auto value = prim->value_as_FakeQuantWithMinMaxVars(); 950+ if (prim != nullptr && value != nullptr) { 951+ return value->narrow_range(); 952+ } else { 953+ return false; 954+ } 955+ } else { 956+ return false; 957+ } 958+} 959+ 960+void MindIR_FakeQuantWithMinMaxVars_SetNarrowRange(PrimitivePtr *primitive, bool narrow_range) { 961+ if (primitive != nullptr && *primitive != nullptr) { 962+ auto prim = static_cast<schema::Primitive *>(*primitive); 963+ auto value = prim->value_as_FakeQuantWithMinMaxVars(); 964+ if (prim != nullptr && value != nullptr) { 965+ flatbuffers::FlatBufferBuilder fbb; 966+ auto ops_offset = schema::CreateFakeQuantWithMinMaxVars(fbb, value->num_bits(), narrow_range); 967+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_FAKE_QUANT_WITH_MIN_MAX_VARS), ops_offset.o); 968+ fbb.Finish(prim_offset); 969+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 970+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 971+ free(*primitive); 972+ *primitive = ret_value; 973+ } 974+ } 975+} 976+ 977+// ********** FakeQuantWithMinMaxVarsPerChannel ********** 978+PrimitivePtr MindIR_FakeQuantWithMinMaxVarsPerChannel_CreatePrimitive(int64_t num_bits, bool narrow_range) { 979+ flatbuffers::FlatBufferBuilder fbb; 980+ auto ops_offset = schema::CreateFakeQuantWithMinMaxVarsPerChannel(fbb, num_bits, narrow_range); 981+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_FAKE_QUANT_WITH_MIN_MAX_VARS_PER_CHANNEL), ops_offset.o); 982+ fbb.Finish(prim_offset); 983+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 984+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 985+ return ret_value; 986+} 987+ 988+int64_t MindIR_FakeQuantWithMinMaxVarsPerChannel_GetNumBits(ConstPrimitivePtr primitive) { 989+ if (primitive != nullptr) { 990+ auto prim = static_cast<const schema::Primitive *>(primitive); 991+ auto value = prim->value_as_FakeQuantWithMinMaxVarsPerChannel(); 992+ if (prim != nullptr && value != nullptr) { 993+ return value->num_bits(); 994+ } else { 995+ return 0; 996+ } 997+ } else { 998+ return 0; 999+ } 1000+} 1001+ 1002+void MindIR_FakeQuantWithMinMaxVarsPerChannel_SetNumBits(PrimitivePtr *primitive, int64_t num_bits) { 1003+ if (primitive != nullptr && *primitive != nullptr) { 1004+ auto prim = static_cast<schema::Primitive *>(*primitive); 1005+ auto value = prim->value_as_FakeQuantWithMinMaxVarsPerChannel(); 1006+ if (prim != nullptr && value != nullptr) { 1007+ flatbuffers::FlatBufferBuilder fbb; 1008+ auto ops_offset = schema::CreateFakeQuantWithMinMaxVarsPerChannel(fbb, num_bits, value->narrow_range()); 1009+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_FAKE_QUANT_WITH_MIN_MAX_VARS_PER_CHANNEL), ops_offset.o); 1010+ fbb.Finish(prim_offset); 1011+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1012+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1013+ free(*primitive); 1014+ *primitive = ret_value; 1015+ } 1016+ } 1017+} 1018+ 1019+bool MindIR_FakeQuantWithMinMaxVarsPerChannel_GetNarrowRange(ConstPrimitivePtr primitive) { 1020+ if (primitive != nullptr) { 1021+ auto prim = static_cast<const schema::Primitive *>(primitive); 1022+ auto value = prim->value_as_FakeQuantWithMinMaxVarsPerChannel(); 1023+ if (prim != nullptr && value != nullptr) { 1024+ return value->narrow_range(); 1025+ } else { 1026+ return false; 1027+ } 1028+ } else { 1029+ return false; 1030+ } 1031+} 1032+ 1033+void MindIR_FakeQuantWithMinMaxVarsPerChannel_SetNarrowRange(PrimitivePtr *primitive, bool narrow_range) { 1034+ if (primitive != nullptr && *primitive != nullptr) { 1035+ auto prim = static_cast<schema::Primitive *>(*primitive); 1036+ auto value = prim->value_as_FakeQuantWithMinMaxVarsPerChannel(); 1037+ if (prim != nullptr && value != nullptr) { 1038+ flatbuffers::FlatBufferBuilder fbb; 1039+ auto ops_offset = schema::CreateFakeQuantWithMinMaxVarsPerChannel(fbb, value->num_bits(), narrow_range); 1040+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_FAKE_QUANT_WITH_MIN_MAX_VARS_PER_CHANNEL), ops_offset.o); 1041+ fbb.Finish(prim_offset); 1042+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1043+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1044+ free(*primitive); 1045+ *primitive = ret_value; 1046+ } 1047+ } 1048+} 1049+ 1050+// ********** FftReal ********** 1051+PrimitivePtr MindIR_FftReal_CreatePrimitive() { 1052+ flatbuffers::FlatBufferBuilder fbb; 1053+ auto ops_offset = schema::CreateFftReal(fbb); 1054+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_FFT_REAL), ops_offset.o); 1055+ fbb.Finish(prim_offset); 1056+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1057+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1058+ return ret_value; 1059+} 1060+ 1061+// ********** FftImag ********** 1062+PrimitivePtr MindIR_FftImag_CreatePrimitive() { 1063+ flatbuffers::FlatBufferBuilder fbb; 1064+ auto ops_offset = schema::CreateFftImag(fbb); 1065+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_FFT_IMAG), ops_offset.o); 1066+ fbb.Finish(prim_offset); 1067+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1068+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1069+ return ret_value; 1070+} 1071+ 1072+// ********** FloorDiv ********** 1073+PrimitivePtr MindIR_FloorDiv_CreatePrimitive() { 1074+ flatbuffers::FlatBufferBuilder fbb; 1075+ auto ops_offset = schema::CreateFloorDiv(fbb); 1076+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_FLOOR_DIV), ops_offset.o); 1077+ fbb.Finish(prim_offset); 1078+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1079+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1080+ return ret_value; 1081+} 1082+ 1083+// ********** FloorMod ********** 1084+PrimitivePtr MindIR_FloorMod_CreatePrimitive() { 1085+ flatbuffers::FlatBufferBuilder fbb; 1086+ auto ops_offset = schema::CreateFloorMod(fbb); 1087+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_FLOOR_MOD), ops_offset.o); 1088+ fbb.Finish(prim_offset); 1089+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1090+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1091+ return ret_value; 1092+} 1093+ 1094+// ********** HashtableLookup ********** 1095+PrimitivePtr MindIR_HashtableLookup_CreatePrimitive() { 1096+ flatbuffers::FlatBufferBuilder fbb; 1097+ auto ops_offset = schema::CreateHashtableLookup(fbb); 1098+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_HASHTABLE_LOOKUP), ops_offset.o); 1099+ fbb.Finish(prim_offset); 1100+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1101+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1102+ return ret_value; 1103+} 1104+ 1105+// ********** LpNormalization ********** 1106+PrimitivePtr MindIR_LpNormalization_CreatePrimitive(int64_t axis, int64_t p) { 1107+ flatbuffers::FlatBufferBuilder fbb; 1108+ auto ops_offset = schema::CreateLpNormalization(fbb, axis, p); 1109+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_LP_NORMALIZATION), ops_offset.o); 1110+ fbb.Finish(prim_offset); 1111+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1112+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1113+ return ret_value; 1114+} 1115+ 1116+int64_t MindIR_LpNormalization_GetAxis(ConstPrimitivePtr primitive) { 1117+ if (primitive != nullptr) { 1118+ auto prim = static_cast<const schema::Primitive *>(primitive); 1119+ auto value = prim->value_as_LpNormalization(); 1120+ if (prim != nullptr && value != nullptr) { 1121+ return value->axis(); 1122+ } else { 1123+ return 0; 1124+ } 1125+ } else { 1126+ return 0; 1127+ } 1128+} 1129+ 1130+void MindIR_LpNormalization_SetAxis(PrimitivePtr *primitive, int64_t axis) { 1131+ if (primitive != nullptr && *primitive != nullptr) { 1132+ auto prim = static_cast<schema::Primitive *>(*primitive); 1133+ auto value = prim->value_as_LpNormalization(); 1134+ if (prim != nullptr && value != nullptr) { 1135+ flatbuffers::FlatBufferBuilder fbb; 1136+ auto ops_offset = schema::CreateLpNormalization(fbb, axis, value->p()); 1137+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_LP_NORMALIZATION), ops_offset.o); 1138+ fbb.Finish(prim_offset); 1139+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, prim); 1140+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1141+ *primitive = ret_value; 1142+ } 1143+ } 1144+} 1145+ 1146+int64_t MindIR_LpNormalization_GetP(ConstPrimitivePtr primitive) { 1147+ if (primitive != nullptr) { 1148+ auto prim = static_cast<const schema::Primitive *>(primitive); 1149+ auto value = prim->value_as_LpNormalization(); 1150+ if (prim != nullptr && value != nullptr) { 1151+ return value->p(); 1152+ } else { 1153+ return 0; 1154+ } 1155+ } else { 1156+ return 0; 1157+ } 1158+} 1159+ 1160+void MindIR_LpNormalization_SetP(PrimitivePtr *primitive, int64_t p) { 1161+ if (primitive != nullptr && *primitive != nullptr) { 1162+ auto prim = static_cast<schema::Primitive *>(*primitive); 1163+ auto value = prim->value_as_LpNormalization(); 1164+ if (prim != nullptr && value != nullptr) { 1165+ flatbuffers::FlatBufferBuilder fbb; 1166+ auto ops_offset = schema::CreateLpNormalization(fbb, value->axis(), p); 1167+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_LP_NORMALIZATION), ops_offset.o); 1168+ fbb.Finish(prim_offset); 1169+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, prim); 1170+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1171+ *primitive = ret_value; 1172+ } 1173+ } 1174+} 1175+ 1176+// ********** LshProjection ********** 1177+PrimitivePtr MindIR_LshProjection_CreatePrimitive(LshProjectionType type) { 1178+ flatbuffers::FlatBufferBuilder fbb; 1179+ auto ops_offset = schema::CreateLshProjection(fbb, static_cast<schema::LshProjectionType>(type)); 1180+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_LSH_PROJECTION), ops_offset.o); 1181+ fbb.Finish(prim_offset); 1182+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1183+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1184+ return ret_value; 1185+} 1186+ 1187+LshProjectionType MindIR_LshProjection_GetType(ConstPrimitivePtr primitive) { 1188+ if (primitive != nullptr) { 1189+ auto prim = static_cast<const schema::Primitive *>(primitive); 1190+ auto value = prim->value_as_LshProjection(); 1191+ if (prim != nullptr && value != nullptr) { 1192+ return static_cast<LshProjectionType>(value->type()); 1193+ } else { 1194+ LshProjectionType en = static_cast<LshProjectionType>(0); 1195+ return en; 1196+ } 1197+ } else { 1198+ LshProjectionType en = static_cast<LshProjectionType>(0); 1199+ return en; 1200+ } 1201+} 1202+ 1203+void MindIR_LshProjection_SetType(PrimitivePtr *primitive, LshProjectionType type) { 1204+ if (primitive != nullptr && *primitive != nullptr) { 1205+ auto prim = static_cast<schema::Primitive *>(*primitive); 1206+ auto value = prim->value_as_LshProjection(); 1207+ if (prim != nullptr && value != nullptr) { 1208+ flatbuffers::FlatBufferBuilder fbb; 1209+ auto ops_offset = schema::CreateLshProjection(fbb, static_cast<schema::LshProjectionType>(type)); 1210+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_LSH_PROJECTION), ops_offset.o); 1211+ fbb.Finish(prim_offset); 1212+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1213+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1214+ free(*primitive); 1215+ *primitive = ret_value; 1216+ } 1217+ } 1218+} 1219+ 1220+// ********** SwitchLayer ********** 1221+PrimitivePtr MindIR_SwitchLayer_CreatePrimitive() { 1222+ flatbuffers::FlatBufferBuilder fbb; 1223+ auto ops_offset = schema::CreateSwitchLayer(fbb); 1224+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_SWITCH_LAYER), ops_offset.o); 1225+ fbb.Finish(prim_offset); 1226+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1227+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1228+ return ret_value; 1229+} 1230+ 1231+// ********** Mfcc ********** 1232+PrimitivePtr MindIR_Mfcc_CreatePrimitive(float freq_upper_limit, float freq_lower_limit, int64_t filter_bank_channel_num, int64_t dct_coeff_num) { 1233+ flatbuffers::FlatBufferBuilder fbb; 1234+ auto ops_offset = schema::CreateMfcc(fbb, freq_upper_limit, freq_lower_limit, filter_bank_channel_num, dct_coeff_num); 1235+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_MFCC), ops_offset.o); 1236+ fbb.Finish(prim_offset); 1237+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1238+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1239+ return ret_value; 1240+} 1241+ 1242+float MindIR_Mfcc_GetFreqUpperLimit(ConstPrimitivePtr primitive) { 1243+ if (primitive != nullptr) { 1244+ auto prim = static_cast<const schema::Primitive *>(primitive); 1245+ auto value = prim->value_as_Mfcc(); 1246+ if (prim != nullptr && value != nullptr) { 1247+ return value->freq_upper_limit(); 1248+ } else { 1249+ return .0; 1250+ } 1251+ } else { 1252+ return .0; 1253+ } 1254+} 1255+ 1256+void MindIR_Mfcc_SetFreqUpperLimit(PrimitivePtr *primitive, float freq_upper_limit) { 1257+ if (primitive != nullptr && *primitive != nullptr) { 1258+ auto prim = static_cast<schema::Primitive *>(*primitive); 1259+ auto value = prim->value_as_Mfcc(); 1260+ if (prim != nullptr && value != nullptr) { 1261+ flatbuffers::FlatBufferBuilder fbb; 1262+ auto ops_offset = schema::CreateMfcc(fbb, freq_upper_limit, value->freq_lower_limit(), value->filter_bank_channel_num(), value->dct_coeff_num()); 1263+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_MFCC), ops_offset.o); 1264+ fbb.Finish(prim_offset); 1265+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1266+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1267+ free(*primitive); 1268+ *primitive = ret_value; 1269+ } 1270+ } 1271+} 1272+ 1273+float MindIR_Mfcc_GetFreqLowerLimit(ConstPrimitivePtr primitive) { 1274+ if (primitive != nullptr) { 1275+ auto prim = static_cast<const schema::Primitive *>(primitive); 1276+ auto value = prim->value_as_Mfcc(); 1277+ if (prim != nullptr && value != nullptr) { 1278+ return value->freq_lower_limit(); 1279+ } else { 1280+ return .0; 1281+ } 1282+ } else { 1283+ return .0; 1284+ } 1285+} 1286+ 1287+void MindIR_Mfcc_SetFreqLowerLimit(PrimitivePtr *primitive, float freq_lower_limit) { 1288+ if (primitive != nullptr && *primitive != nullptr) { 1289+ auto prim = static_cast<schema::Primitive *>(*primitive); 1290+ auto value = prim->value_as_Mfcc(); 1291+ if (prim != nullptr && value != nullptr) { 1292+ flatbuffers::FlatBufferBuilder fbb; 1293+ auto ops_offset = schema::CreateMfcc(fbb, value->freq_upper_limit(), freq_lower_limit, value->filter_bank_channel_num(), value->dct_coeff_num()); 1294+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_MFCC), ops_offset.o); 1295+ fbb.Finish(prim_offset); 1296+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1297+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1298+ free(*primitive); 1299+ *primitive = ret_value; 1300+ } 1301+ } 1302+} 1303+ 1304+int64_t MindIR_Mfcc_GetFilterBankChannelNum(ConstPrimitivePtr primitive) { 1305+ if (primitive != nullptr) { 1306+ auto prim = static_cast<const schema::Primitive *>(primitive); 1307+ auto value = prim->value_as_Mfcc(); 1308+ if (prim != nullptr && value != nullptr) { 1309+ return value->filter_bank_channel_num(); 1310+ } else { 1311+ return 0; 1312+ } 1313+ } else { 1314+ return 0; 1315+ } 1316+} 1317+ 1318+void MindIR_Mfcc_SetFilterBankChannelNum(PrimitivePtr *primitive, int64_t filter_bank_channel_num) { 1319+ if (primitive != nullptr && *primitive != nullptr) { 1320+ auto prim = static_cast<schema::Primitive *>(*primitive); 1321+ auto value = prim->value_as_Mfcc(); 1322+ if (prim != nullptr && value != nullptr) { 1323+ flatbuffers::FlatBufferBuilder fbb; 1324+ auto ops_offset = schema::CreateMfcc(fbb, value->freq_upper_limit(), value->freq_lower_limit(), filter_bank_channel_num, value->dct_coeff_num()); 1325+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_MFCC), ops_offset.o); 1326+ fbb.Finish(prim_offset); 1327+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1328+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1329+ free(*primitive); 1330+ *primitive = ret_value; 1331+ } 1332+ } 1333+} 1334+ 1335+int64_t MindIR_Mfcc_GetDctCoeffNum(ConstPrimitivePtr primitive) { 1336+ if (primitive != nullptr) { 1337+ auto prim = static_cast<const schema::Primitive *>(primitive); 1338+ auto value = prim->value_as_Mfcc(); 1339+ if (prim != nullptr && value != nullptr) { 1340+ return value->dct_coeff_num(); 1341+ } else { 1342+ return 0; 1343+ } 1344+ } else { 1345+ return 0; 1346+ } 1347+} 1348+ 1349+void MindIR_Mfcc_SetDctCoeffNum(PrimitivePtr *primitive, int64_t dct_coeff_num) { 1350+ if (primitive != nullptr && *primitive != nullptr) { 1351+ auto prim = static_cast<schema::Primitive *>(*primitive); 1352+ auto value = prim->value_as_Mfcc(); 1353+ if (prim != nullptr && value != nullptr) { 1354+ flatbuffers::FlatBufferBuilder fbb; 1355+ auto ops_offset = schema::CreateMfcc(fbb, value->freq_upper_limit(), value->freq_lower_limit(), value->filter_bank_channel_num(), dct_coeff_num); 1356+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_MFCC), ops_offset.o); 1357+ fbb.Finish(prim_offset); 1358+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1359+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1360+ free(*primitive); 1361+ *primitive = ret_value; 1362+ } 1363+ } 1364+} 1365+ 1366+// ********** NonMaxSuppression ********** 1367+PrimitivePtr MindIR_NonMaxSuppression_CreatePrimitive(int64_t center_point_box) { 1368+ flatbuffers::FlatBufferBuilder fbb; 1369+ auto ops_offset = schema::CreateNonMaxSuppression(fbb, center_point_box); 1370+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_NON_MAX_SUPPRESSION), ops_offset.o); 1371+ fbb.Finish(prim_offset); 1372+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1373+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1374+ return ret_value; 1375+} 1376+ 1377+int64_t MindIR_NonMaxSuppression_GetCenterPointBox(ConstPrimitivePtr primitive) { 1378+ if (primitive != nullptr) { 1379+ auto prim = static_cast<const schema::Primitive *>(primitive); 1380+ auto value = prim->value_as_NonMaxSuppression(); 1381+ if (prim != nullptr && value != nullptr) { 1382+ return value->center_point_box(); 1383+ } else { 1384+ return 0; 1385+ } 1386+ } else { 1387+ return 0; 1388+ } 1389+} 1390+ 1391+void MindIR_NonMaxSuppression_SetCenterPointBox(PrimitivePtr *primitive, int64_t center_point_box) { 1392+ if (primitive != nullptr && *primitive != nullptr) { 1393+ auto prim = static_cast<schema::Primitive *>(*primitive); 1394+ auto value = prim->value_as_NonMaxSuppression(); 1395+ if (prim != nullptr && value != nullptr) { 1396+ flatbuffers::FlatBufferBuilder fbb; 1397+ auto ops_offset = schema::CreateNonMaxSuppression(fbb, center_point_box); 1398+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_NON_MAX_SUPPRESSION), ops_offset.o); 1399+ fbb.Finish(prim_offset); 1400+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1401+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1402+ free(*primitive); 1403+ *primitive = ret_value; 1404+ } 1405+ } 1406+} 1407+ 1408+// ********** OnesLike ********** 1409+PrimitivePtr MindIR_OnesLike_CreatePrimitive() { 1410+ flatbuffers::FlatBufferBuilder fbb; 1411+ auto ops_offset = schema::CreateOnesLike(fbb); 1412+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_ONES_LIKE), ops_offset.o); 1413+ fbb.Finish(prim_offset); 1414+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1415+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1416+ return ret_value; 1417+} 1418+ 1419+// ********** PartialFusion ********** 1420+PrimitivePtr MindIR_PartialFusion_CreatePrimitive(int64_t sub_graph_index) { 1421+ flatbuffers::FlatBufferBuilder fbb; 1422+ auto ops_offset = schema::CreatePartialFusion(fbb, sub_graph_index); 1423+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_PARTIAL_FUSION), ops_offset.o); 1424+ fbb.Finish(prim_offset); 1425+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1426+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1427+ return ret_value; 1428+} 1429+ 1430+int64_t MindIR_PartialFusion_GetSubGraphIndex(ConstPrimitivePtr primitive) { 1431+ if (primitive != nullptr) { 1432+ auto prim = static_cast<const schema::Primitive *>(primitive); 1433+ auto value = prim->value_as_PartialFusion(); 1434+ if (prim != nullptr && value != nullptr) { 1435+ return value->sub_graph_index(); 1436+ } else { 1437+ return 0; 1438+ } 1439+ } else { 1440+ return 0; 1441+ } 1442+} 1443+ 1444+void MindIR_PartialFusion_SetSubGraphIndex(PrimitivePtr *primitive, int64_t sub_graph_index) { 1445+ if (primitive != nullptr && *primitive != nullptr) { 1446+ auto prim = static_cast<schema::Primitive *>(*primitive); 1447+ auto value = prim->value_as_PartialFusion(); 1448+ if (prim != nullptr && value != nullptr) { 1449+ flatbuffers::FlatBufferBuilder fbb; 1450+ auto ops_offset = schema::CreatePartialFusion(fbb, sub_graph_index); 1451+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_PARTIAL_FUSION), ops_offset.o); 1452+ fbb.Finish(prim_offset); 1453+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1454+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1455+ free(*primitive); 1456+ *primitive = ret_value; 1457+ } 1458+ } 1459+} 1460+ 1461+// ********** PriorBox ********** 1462+PrimitivePtr MindIR_PriorBox_CreatePrimitive(const std::vector<int64_t> &min_sizes, const std::vector<int64_t> &max_sizes, const std::vector<float> &aspect_ratios, const std::vector<float> &variances, int64_t image_size_w, int64_t image_size_h, float step_w, float step_h, bool clip, bool flip, float offset) { 1463+ flatbuffers::FlatBufferBuilder fbb; 1464+ auto ops_offset = schema::CreatePriorBox(fbb, fbb.CreateVector(min_sizes.data(), min_sizes.size()), fbb.CreateVector(max_sizes.data(), max_sizes.size()), fbb.CreateVector(aspect_ratios.data(), aspect_ratios.size()), fbb.CreateVector(variances.data(), variances.size()), image_size_w, image_size_h, step_w, step_h, clip, flip, offset); 1465+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_PRIOR_BOX), ops_offset.o); 1466+ fbb.Finish(prim_offset); 1467+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1468+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1469+ return ret_value; 1470+} 1471+ 1472+std::vector<int64_t> MindIR_PriorBox_GetMinSizes(ConstPrimitivePtr primitive) { 1473+ if (primitive != nullptr) { 1474+ auto prim = static_cast<const schema::Primitive *>(primitive); 1475+ auto value = prim->value_as_PriorBox(); 1476+ if (prim != nullptr && value != nullptr) { 1477+ std::vector<int64_t> result; 1478+ auto src = value->min_sizes(); 1479+ if (src == nullptr) { 1480+ return {}; 1481+ } 1482+ result.resize(src->size()); 1483+ std::transform(src->begin(), src->end(), result.begin(), [](int64_t item) { return item; }); 1484+ return result; 1485+ } else { 1486+ return {}; 1487+ } 1488+ } else { 1489+ return {}; 1490+ } 1491+} 1492+ 1493+void MindIR_PriorBox_SetMinSizes(PrimitivePtr *primitive, const std::vector<int64_t> &min_sizes) { 1494+ if (primitive != nullptr && *primitive != nullptr) { 1495+ auto prim = static_cast<schema::Primitive *>(*primitive); 1496+ auto value = prim->value_as_PriorBox(); 1497+ if (prim != nullptr && value != nullptr) { 1498+ flatbuffers::FlatBufferBuilder fbb; 1499+ auto ops_offset = schema::CreatePriorBox(fbb, fbb.CreateVector(min_sizes.data(), min_sizes.size()), fbb.CreateVector(value->max_sizes()->data(), value->max_sizes()->size()), fbb.CreateVector(value->aspect_ratios()->data(), value->aspect_ratios()->size()), fbb.CreateVector(value->variances()->data(), value->variances()->size()), value->image_size_w(), value->image_size_h(), value->step_w(), value->step_h(), value->clip(), value->flip(), value->offset()); 1500+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_PRIOR_BOX), ops_offset.o); 1501+ fbb.Finish(prim_offset); 1502+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1503+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1504+ free(*primitive); 1505+ *primitive = ret_value; 1506+ } 1507+ } 1508+} 1509+ 1510+std::vector<int64_t> MindIR_PriorBox_GetMaxSizes(ConstPrimitivePtr primitive) { 1511+ if (primitive != nullptr) { 1512+ auto prim = static_cast<const schema::Primitive *>(primitive); 1513+ auto value = prim->value_as_PriorBox(); 1514+ if (prim != nullptr && value != nullptr) { 1515+ std::vector<int64_t> result; 1516+ auto src = value->max_sizes(); 1517+ if (src == nullptr) { 1518+ return {}; 1519+ } 1520+ result.resize(src->size()); 1521+ std::transform(src->begin(), src->end(), result.begin(), [](int64_t item) { return item; }); 1522+ return result; 1523+ } else { 1524+ return {}; 1525+ } 1526+ } else { 1527+ return {}; 1528+ } 1529+} 1530+ 1531+void MindIR_PriorBox_SetMaxSizes(PrimitivePtr *primitive, const std::vector<int64_t> &max_sizes) { 1532+ if (primitive != nullptr && *primitive != nullptr) { 1533+ auto prim = static_cast<schema::Primitive *>(*primitive); 1534+ auto value = prim->value_as_PriorBox(); 1535+ if (prim != nullptr && value != nullptr) { 1536+ flatbuffers::FlatBufferBuilder fbb; 1537+ auto ops_offset = schema::CreatePriorBox(fbb, fbb.CreateVector(value->min_sizes()->data(), value->min_sizes()->size()), fbb.CreateVector(max_sizes.data(), max_sizes.size()), fbb.CreateVector(value->aspect_ratios()->data(), value->aspect_ratios()->size()), fbb.CreateVector(value->variances()->data(), value->variances()->size()), value->image_size_w(), value->image_size_h(), value->step_w(), value->step_h(), value->clip(), value->flip(), value->offset()); 1538+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_PRIOR_BOX), ops_offset.o); 1539+ fbb.Finish(prim_offset); 1540+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1541+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1542+ free(*primitive); 1543+ *primitive = ret_value; 1544+ } 1545+ } 1546+} 1547+ 1548+std::vector<float> MindIR_PriorBox_GetAspectRatios(ConstPrimitivePtr primitive) { 1549+ if (primitive != nullptr) { 1550+ auto prim = static_cast<const schema::Primitive *>(primitive); 1551+ auto value = prim->value_as_PriorBox(); 1552+ if (prim != nullptr && value != nullptr) { 1553+ std::vector<float> result; 1554+ auto src = value->aspect_ratios(); 1555+ if (src == nullptr) { 1556+ return {}; 1557+ } 1558+ result.resize(src->size()); 1559+ std::transform(src->begin(), src->end(), result.begin(), [](float item) { return item; }); 1560+ return result; 1561+ } else { 1562+ return {}; 1563+ } 1564+ } else { 1565+ return {}; 1566+ } 1567+} 1568+ 1569+void MindIR_PriorBox_SetAspectRatios(PrimitivePtr *primitive, const std::vector<float> &aspect_ratios) { 1570+ if (primitive != nullptr && *primitive != nullptr) { 1571+ auto prim = static_cast<schema::Primitive *>(*primitive); 1572+ auto value = prim->value_as_PriorBox(); 1573+ if (prim != nullptr && value != nullptr) { 1574+ flatbuffers::FlatBufferBuilder fbb; 1575+ auto ops_offset = schema::CreatePriorBox(fbb, fbb.CreateVector(value->min_sizes()->data(), value->min_sizes()->size()), fbb.CreateVector(value->max_sizes()->data(), value->max_sizes()->size()), fbb.CreateVector(aspect_ratios.data(), aspect_ratios.size()), fbb.CreateVector(value->variances()->data(), value->variances()->size()), value->image_size_w(), value->image_size_h(), value->step_w(), value->step_h(), value->clip(), value->flip(), value->offset()); 1576+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_PRIOR_BOX), ops_offset.o); 1577+ fbb.Finish(prim_offset); 1578+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1579+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1580+ free(*primitive); 1581+ *primitive = ret_value; 1582+ } 1583+ } 1584+} 1585+ 1586+std::vector<float> MindIR_PriorBox_GetVariances(ConstPrimitivePtr primitive) { 1587+ if (primitive != nullptr) { 1588+ auto prim = static_cast<const schema::Primitive *>(primitive); 1589+ auto value = prim->value_as_PriorBox(); 1590+ if (prim != nullptr && value != nullptr) { 1591+ std::vector<float> result; 1592+ auto src = value->variances(); 1593+ if (src == nullptr) { 1594+ return {}; 1595+ } 1596+ result.resize(src->size()); 1597+ std::transform(src->begin(), src->end(), result.begin(), [](float item) { return item; }); 1598+ return result; 1599+ } else { 1600+ return {}; 1601+ } 1602+ } else { 1603+ return {}; 1604+ } 1605+} 1606+ 1607+void MindIR_PriorBox_SetVariances(PrimitivePtr *primitive, const std::vector<float> &variances) { 1608+ if (primitive != nullptr && *primitive != nullptr) { 1609+ auto prim = static_cast<schema::Primitive *>(*primitive); 1610+ auto value = prim->value_as_PriorBox(); 1611+ if (prim != nullptr && value != nullptr) { 1612+ flatbuffers::FlatBufferBuilder fbb; 1613+ auto ops_offset = schema::CreatePriorBox(fbb, fbb.CreateVector(value->min_sizes()->data(), value->min_sizes()->size()), fbb.CreateVector(value->max_sizes()->data(), value->max_sizes()->size()), fbb.CreateVector(value->aspect_ratios()->data(), value->aspect_ratios()->size()), fbb.CreateVector(variances.data(), variances.size()), value->image_size_w(), value->image_size_h(), value->step_w(), value->step_h(), value->clip(), value->flip(), value->offset()); 1614+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_PRIOR_BOX), ops_offset.o); 1615+ fbb.Finish(prim_offset); 1616+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1617+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1618+ free(*primitive); 1619+ *primitive = ret_value; 1620+ } 1621+ } 1622+} 1623+ 1624+int64_t MindIR_PriorBox_GetImageSizeW(ConstPrimitivePtr primitive) { 1625+ if (primitive != nullptr) { 1626+ auto prim = static_cast<const schema::Primitive *>(primitive); 1627+ auto value = prim->value_as_PriorBox(); 1628+ if (prim != nullptr && value != nullptr) { 1629+ return value->image_size_w(); 1630+ } else { 1631+ return 0; 1632+ } 1633+ } else { 1634+ return 0; 1635+ } 1636+} 1637+ 1638+void MindIR_PriorBox_SetImageSizeW(PrimitivePtr *primitive, int64_t image_size_w) { 1639+ if (primitive != nullptr && *primitive != nullptr) { 1640+ auto prim = static_cast<schema::Primitive *>(*primitive); 1641+ auto value = prim->value_as_PriorBox(); 1642+ if (prim != nullptr && value != nullptr) { 1643+ flatbuffers::FlatBufferBuilder fbb; 1644+ auto ops_offset = schema::CreatePriorBox(fbb, fbb.CreateVector(value->min_sizes()->data(), value->min_sizes()->size()), fbb.CreateVector(value->max_sizes()->data(), value->max_sizes()->size()), fbb.CreateVector(value->aspect_ratios()->data(), value->aspect_ratios()->size()), fbb.CreateVector(value->variances()->data(), value->variances()->size()), image_size_w, value->image_size_h(), value->step_w(), value->step_h(), value->clip(), value->flip(), value->offset()); 1645+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_PRIOR_BOX), ops_offset.o); 1646+ fbb.Finish(prim_offset); 1647+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1648+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1649+ free(*primitive); 1650+ *primitive = ret_value; 1651+ } 1652+ } 1653+} 1654+ 1655+int64_t MindIR_PriorBox_GetImageSizeH(ConstPrimitivePtr primitive) { 1656+ if (primitive != nullptr) { 1657+ auto prim = static_cast<const schema::Primitive *>(primitive); 1658+ auto value = prim->value_as_PriorBox(); 1659+ if (prim != nullptr && value != nullptr) { 1660+ return value->image_size_h(); 1661+ } else { 1662+ return 0; 1663+ } 1664+ } else { 1665+ return 0; 1666+ } 1667+} 1668+ 1669+void MindIR_PriorBox_SetImageSizeH(PrimitivePtr *primitive, int64_t image_size_h) { 1670+ if (primitive != nullptr && *primitive != nullptr) { 1671+ auto prim = static_cast<schema::Primitive *>(*primitive); 1672+ auto value = prim->value_as_PriorBox(); 1673+ if (prim != nullptr && value != nullptr) { 1674+ flatbuffers::FlatBufferBuilder fbb; 1675+ auto ops_offset = schema::CreatePriorBox(fbb, fbb.CreateVector(value->min_sizes()->data(), value->min_sizes()->size()), fbb.CreateVector(value->max_sizes()->data(), value->max_sizes()->size()), fbb.CreateVector(value->aspect_ratios()->data(), value->aspect_ratios()->size()), fbb.CreateVector(value->variances()->data(), value->variances()->size()), value->image_size_w(), image_size_h, value->step_w(), value->step_h(), value->clip(), value->flip(), value->offset()); 1676+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_PRIOR_BOX), ops_offset.o); 1677+ fbb.Finish(prim_offset); 1678+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1679+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1680+ free(*primitive); 1681+ *primitive = ret_value; 1682+ } 1683+ } 1684+} 1685+ 1686+float MindIR_PriorBox_GetStepW(ConstPrimitivePtr primitive) { 1687+ if (primitive != nullptr) { 1688+ auto prim = static_cast<const schema::Primitive *>(primitive); 1689+ auto value = prim->value_as_PriorBox(); 1690+ if (prim != nullptr && value != nullptr) { 1691+ return value->step_w(); 1692+ } else { 1693+ return .0; 1694+ } 1695+ } else { 1696+ return .0; 1697+ } 1698+} 1699+ 1700+void MindIR_PriorBox_SetStepW(PrimitivePtr *primitive, float step_w) { 1701+ if (primitive != nullptr && *primitive != nullptr) { 1702+ auto prim = static_cast<schema::Primitive *>(*primitive); 1703+ auto value = prim->value_as_PriorBox(); 1704+ if (prim != nullptr && value != nullptr) { 1705+ flatbuffers::FlatBufferBuilder fbb; 1706+ auto ops_offset = schema::CreatePriorBox(fbb, fbb.CreateVector(value->min_sizes()->data(), value->min_sizes()->size()), fbb.CreateVector(value->max_sizes()->data(), value->max_sizes()->size()), fbb.CreateVector(value->aspect_ratios()->data(), value->aspect_ratios()->size()), fbb.CreateVector(value->variances()->data(), value->variances()->size()), value->image_size_w(), value->image_size_h(), step_w, value->step_h(), value->clip(), value->flip(), value->offset()); 1707+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_PRIOR_BOX), ops_offset.o); 1708+ fbb.Finish(prim_offset); 1709+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1710+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1711+ free(*primitive); 1712+ *primitive = ret_value; 1713+ } 1714+ } 1715+} 1716+ 1717+float MindIR_PriorBox_GetStepH(ConstPrimitivePtr primitive) { 1718+ if (primitive != nullptr) { 1719+ auto prim = static_cast<const schema::Primitive *>(primitive); 1720+ auto value = prim->value_as_PriorBox(); 1721+ if (prim != nullptr && value != nullptr) { 1722+ return value->step_h(); 1723+ } else { 1724+ return .0; 1725+ } 1726+ } else { 1727+ return .0; 1728+ } 1729+} 1730+ 1731+void MindIR_PriorBox_SetStepH(PrimitivePtr *primitive, float step_h) { 1732+ if (primitive != nullptr && *primitive != nullptr) { 1733+ auto prim = static_cast<schema::Primitive *>(*primitive); 1734+ auto value = prim->value_as_PriorBox(); 1735+ if (prim != nullptr && value != nullptr) { 1736+ flatbuffers::FlatBufferBuilder fbb; 1737+ auto ops_offset = schema::CreatePriorBox(fbb, fbb.CreateVector(value->min_sizes()->data(), value->min_sizes()->size()), fbb.CreateVector(value->max_sizes()->data(), value->max_sizes()->size()), fbb.CreateVector(value->aspect_ratios()->data(), value->aspect_ratios()->size()), fbb.CreateVector(value->variances()->data(), value->variances()->size()), value->image_size_w(), value->image_size_h(), value->step_w(), step_h, value->clip(), value->flip(), value->offset()); 1738+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_PRIOR_BOX), ops_offset.o); 1739+ fbb.Finish(prim_offset); 1740+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1741+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1742+ free(*primitive); 1743+ *primitive = ret_value; 1744+ } 1745+ } 1746+} 1747+ 1748+bool MindIR_PriorBox_GetClip(ConstPrimitivePtr primitive) { 1749+ if (primitive != nullptr) { 1750+ auto prim = static_cast<const schema::Primitive *>(primitive); 1751+ auto value = prim->value_as_PriorBox(); 1752+ if (prim != nullptr && value != nullptr) { 1753+ return value->clip(); 1754+ } else { 1755+ return false; 1756+ } 1757+ } else { 1758+ return false; 1759+ } 1760+} 1761+ 1762+void MindIR_PriorBox_SetClip(PrimitivePtr *primitive, bool clip) { 1763+ if (primitive != nullptr && *primitive != nullptr) { 1764+ auto prim = static_cast<schema::Primitive *>(*primitive); 1765+ auto value = prim->value_as_PriorBox(); 1766+ if (prim != nullptr && value != nullptr) { 1767+ flatbuffers::FlatBufferBuilder fbb; 1768+ auto ops_offset = schema::CreatePriorBox(fbb, fbb.CreateVector(value->min_sizes()->data(), value->min_sizes()->size()), fbb.CreateVector(value->max_sizes()->data(), value->max_sizes()->size()), fbb.CreateVector(value->aspect_ratios()->data(), value->aspect_ratios()->size()), fbb.CreateVector(value->variances()->data(), value->variances()->size()), value->image_size_w(), value->image_size_h(), value->step_w(), value->step_h(), clip, value->flip(), value->offset()); 1769+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_PRIOR_BOX), ops_offset.o); 1770+ fbb.Finish(prim_offset); 1771+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1772+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1773+ free(*primitive); 1774+ *primitive = ret_value; 1775+ } 1776+ } 1777+} 1778+ 1779+bool MindIR_PriorBox_GetFlip(ConstPrimitivePtr primitive) { 1780+ if (primitive != nullptr) { 1781+ auto prim = static_cast<const schema::Primitive *>(primitive); 1782+ auto value = prim->value_as_PriorBox(); 1783+ if (prim != nullptr && value != nullptr) { 1784+ return value->flip(); 1785+ } else { 1786+ return false; 1787+ } 1788+ } else { 1789+ return false; 1790+ } 1791+} 1792+ 1793+void MindIR_PriorBox_SetFlip(PrimitivePtr *primitive, bool flip) { 1794+ if (primitive != nullptr && *primitive != nullptr) { 1795+ auto prim = static_cast<schema::Primitive *>(*primitive); 1796+ auto value = prim->value_as_PriorBox(); 1797+ if (prim != nullptr && value != nullptr) { 1798+ flatbuffers::FlatBufferBuilder fbb; 1799+ auto ops_offset = schema::CreatePriorBox(fbb, fbb.CreateVector(value->min_sizes()->data(), value->min_sizes()->size()), fbb.CreateVector(value->max_sizes()->data(), value->max_sizes()->size()), fbb.CreateVector(value->aspect_ratios()->data(), value->aspect_ratios()->size()), fbb.CreateVector(value->variances()->data(), value->variances()->size()), value->image_size_w(), value->image_size_h(), value->step_w(), value->step_h(), value->clip(), flip, value->offset()); 1800+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_PRIOR_BOX), ops_offset.o); 1801+ fbb.Finish(prim_offset); 1802+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1803+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1804+ free(*primitive); 1805+ *primitive = ret_value; 1806+ } 1807+ } 1808+} 1809+ 1810+float MindIR_PriorBox_GetOffset(ConstPrimitivePtr primitive) { 1811+ if (primitive != nullptr) { 1812+ auto prim = static_cast<const schema::Primitive *>(primitive); 1813+ auto value = prim->value_as_PriorBox(); 1814+ if (prim != nullptr && value != nullptr) { 1815+ return value->offset(); 1816+ } else { 1817+ return .0; 1818+ } 1819+ } else { 1820+ return .0; 1821+ } 1822+} 1823+ 1824+void MindIR_PriorBox_SetOffset(PrimitivePtr *primitive, float offset) { 1825+ if (primitive != nullptr && *primitive != nullptr) { 1826+ auto prim = static_cast<schema::Primitive *>(*primitive); 1827+ auto value = prim->value_as_PriorBox(); 1828+ if (prim != nullptr && value != nullptr) { 1829+ flatbuffers::FlatBufferBuilder fbb; 1830+ auto ops_offset = schema::CreatePriorBox(fbb, fbb.CreateVector(value->min_sizes()->data(), value->min_sizes()->size()), fbb.CreateVector(value->max_sizes()->data(), value->max_sizes()->size()), fbb.CreateVector(value->aspect_ratios()->data(), value->aspect_ratios()->size()), fbb.CreateVector(value->variances()->data(), value->variances()->size()), value->image_size_w(), value->image_size_h(), value->step_w(), value->step_h(), value->clip(), value->flip(), offset); 1831+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_PRIOR_BOX), ops_offset.o); 1832+ fbb.Finish(prim_offset); 1833+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1834+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1835+ free(*primitive); 1836+ *primitive = ret_value; 1837+ } 1838+ } 1839+} 1840+ 1841+// ********** ReverseSequence ********** 1842+PrimitivePtr MindIR_ReverseSequence_CreatePrimitive(int64_t seq_dim, int64_t batch_dim) { 1843+ flatbuffers::FlatBufferBuilder fbb; 1844+ auto ops_offset = schema::CreateReverseSequence(fbb, seq_dim, batch_dim); 1845+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_REVERSE_SEQUENCE), ops_offset.o); 1846+ fbb.Finish(prim_offset); 1847+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1848+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1849+ return ret_value; 1850+} 1851+ 1852+int64_t MindIR_ReverseSequence_GetSeqDim(ConstPrimitivePtr primitive) { 1853+ if (primitive != nullptr) { 1854+ auto prim = static_cast<const schema::Primitive *>(primitive); 1855+ auto value = prim->value_as_ReverseSequence(); 1856+ if (prim != nullptr && value != nullptr) { 1857+ return value->seq_dim(); 1858+ } else { 1859+ return 0; 1860+ } 1861+ } else { 1862+ return 0; 1863+ } 1864+} 1865+ 1866+void MindIR_ReverseSequence_SetSeqDim(PrimitivePtr *primitive, int64_t seq_dim) { 1867+ if (primitive != nullptr && *primitive != nullptr) { 1868+ auto prim = static_cast<schema::Primitive *>(*primitive); 1869+ auto value = prim->value_as_ReverseSequence(); 1870+ if (prim != nullptr && value != nullptr) { 1871+ flatbuffers::FlatBufferBuilder fbb; 1872+ auto ops_offset = schema::CreateReverseSequence(fbb, seq_dim, value->batch_dim()); 1873+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_REVERSE_SEQUENCE), ops_offset.o); 1874+ fbb.Finish(prim_offset); 1875+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1876+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1877+ free(*primitive); 1878+ *primitive = ret_value; 1879+ } 1880+ } 1881+} 1882+ 1883+int64_t MindIR_ReverseSequence_GetBatchDim(ConstPrimitivePtr primitive) { 1884+ if (primitive != nullptr) { 1885+ auto prim = static_cast<const schema::Primitive *>(primitive); 1886+ auto value = prim->value_as_ReverseSequence(); 1887+ if (prim != nullptr && value != nullptr) { 1888+ return value->batch_dim(); 1889+ } else { 1890+ return 0; 1891+ } 1892+ } else { 1893+ return 0; 1894+ } 1895+} 1896+ 1897+void MindIR_ReverseSequence_SetBatchDim(PrimitivePtr *primitive, int64_t batch_dim) { 1898+ if (primitive != nullptr && *primitive != nullptr) { 1899+ auto prim = static_cast<schema::Primitive *>(*primitive); 1900+ auto value = prim->value_as_ReverseSequence(); 1901+ if (prim != nullptr && value != nullptr) { 1902+ flatbuffers::FlatBufferBuilder fbb; 1903+ auto ops_offset = schema::CreateReverseSequence(fbb, value->seq_dim(), batch_dim); 1904+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_REVERSE_SEQUENCE), ops_offset.o); 1905+ fbb.Finish(prim_offset); 1906+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1907+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1908+ free(*primitive); 1909+ *primitive = ret_value; 1910+ } 1911+ } 1912+} 1913+ 1914+// ********** ReverseV2 ********** 1915+PrimitivePtr MindIR_ReverseV2_CreatePrimitive(const std::vector<int64_t> &axis) { 1916+ flatbuffers::FlatBufferBuilder fbb; 1917+ auto ops_offset = schema::CreateReverseV2(fbb, fbb.CreateVector(axis.data(), axis.size())); 1918+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_REVERSE_V2), ops_offset.o); 1919+ fbb.Finish(prim_offset); 1920+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1921+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1922+ return ret_value; 1923+} 1924+ 1925+std::vector<int64_t> MindIR_ReverseV2_GetAxis(ConstPrimitivePtr primitive) { 1926+ if (primitive != nullptr) { 1927+ auto prim = static_cast<const schema::Primitive *>(primitive); 1928+ auto value = prim->value_as_ReverseV2(); 1929+ if (prim != nullptr && value != nullptr) { 1930+ std::vector<int64_t> result; 1931+ auto src = value->axis(); 1932+ if (src == nullptr) { 1933+ return {}; 1934+ } 1935+ result.resize(src->size()); 1936+ std::transform(src->begin(), src->end(), result.begin(), [](int64_t item) { return item; }); 1937+ return result; 1938+ } else { 1939+ return {}; 1940+ } 1941+ } else { 1942+ return {}; 1943+ } 1944+} 1945+ 1946+void MindIR_ReverseV2_SetAxis(PrimitivePtr *primitive, const std::vector<int64_t> &axis) { 1947+ if (primitive != nullptr && *primitive != nullptr) { 1948+ auto prim = static_cast<schema::Primitive *>(*primitive); 1949+ auto value = prim->value_as_ReverseV2(); 1950+ if (prim != nullptr && value != nullptr) { 1951+ flatbuffers::FlatBufferBuilder fbb; 1952+ auto ops_offset = schema::CreateReverseV2(fbb, fbb.CreateVector(axis.data(), axis.size())); 1953+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_REVERSE_V2), ops_offset.o); 1954+ fbb.Finish(prim_offset); 1955+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1956+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1957+ free(*primitive); 1958+ *primitive = ret_value; 1959+ } 1960+ } 1961+} 1962+ 1963+// ********** Rfft ********** 1964+PrimitivePtr MindIR_Rfft_CreatePrimitive(int64_t fft_length) { 1965+ flatbuffers::FlatBufferBuilder fbb; 1966+ auto ops_offset = schema::CreateRfft(fbb, fft_length); 1967+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_RFFT), ops_offset.o); 1968+ fbb.Finish(prim_offset); 1969+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1970+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1971+ return ret_value; 1972+} 1973+ 1974+int64_t MindIR_Rfft_GetFftLength(ConstPrimitivePtr primitive) { 1975+ if (primitive != nullptr) { 1976+ auto prim = static_cast<const schema::Primitive *>(primitive); 1977+ auto value = prim->value_as_Rfft(); 1978+ if (prim != nullptr && value != nullptr) { 1979+ return value->fft_length(); 1980+ } else { 1981+ return 0; 1982+ } 1983+ } else { 1984+ return 0; 1985+ } 1986+} 1987+ 1988+void MindIR_Rfft_SetFftLength(PrimitivePtr *primitive, int64_t fft_length) { 1989+ if (primitive != nullptr && *primitive != nullptr) { 1990+ auto prim = static_cast<schema::Primitive *>(*primitive); 1991+ auto value = prim->value_as_Rfft(); 1992+ if (prim != nullptr && value != nullptr) { 1993+ flatbuffers::FlatBufferBuilder fbb; 1994+ auto ops_offset = schema::CreateRfft(fbb, fft_length); 1995+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_RFFT), ops_offset.o); 1996+ fbb.Finish(prim_offset); 1997+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1998+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1999+ free(*primitive); 2000+ *primitive = ret_value; 2001+ } 2002+ } 2003+} 2004+ 2005+// ********** ROIPooling ********** 2006+PrimitivePtr MindIR_ROIPooling_CreatePrimitive(int64_t pooled_h, int64_t pooled_w, float scale) { 2007+ flatbuffers::FlatBufferBuilder fbb; 2008+ auto ops_offset = schema::CreateROIPooling(fbb, pooled_h, pooled_w, scale); 2009+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_R_O_I_POOLING), ops_offset.o); 2010+ fbb.Finish(prim_offset); 2011+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 2012+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 2013+ return ret_value; 2014+} 2015+ 2016+int64_t MindIR_ROIPooling_GetPooledH(ConstPrimitivePtr primitive) { 2017+ if (primitive != nullptr) { 2018+ auto prim = static_cast<const schema::Primitive *>(primitive); 2019+ auto value = prim->value_as_ROIPooling(); 2020+ if (prim != nullptr && value != nullptr) { 2021+ return value->pooled_h(); 2022+ } else { 2023+ return 0; 2024+ } 2025+ } else { 2026+ return 0; 2027+ } 2028+} 2029+ 2030+void MindIR_ROIPooling_SetPooledH(PrimitivePtr *primitive, int64_t pooled_h) { 2031+ if (primitive != nullptr && *primitive != nullptr) { 2032+ auto prim = static_cast<schema::Primitive *>(*primitive); 2033+ auto value = prim->value_as_ROIPooling(); 2034+ if (prim != nullptr && value != nullptr) { 2035+ flatbuffers::FlatBufferBuilder fbb; 2036+ auto ops_offset = schema::CreateROIPooling(fbb, pooled_h, value->pooled_w(), value->scale()); 2037+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_R_O_I_POOLING), ops_offset.o); 2038+ fbb.Finish(prim_offset); 2039+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 2040+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 2041+ free(*primitive); 2042+ *primitive = ret_value; 2043+ } 2044+ } 2045+} 2046+ 2047+int64_t MindIR_ROIPooling_GetPooledW(ConstPrimitivePtr primitive) { 2048+ if (primitive != nullptr) { 2049+ auto prim = static_cast<const schema::Primitive *>(primitive); 2050+ auto value = prim->value_as_ROIPooling(); 2051+ if (prim != nullptr && value != nullptr) { 2052+ return value->pooled_w(); 2053+ } else { 2054+ return 0; 2055+ } 2056+ } else { 2057+ return 0; 2058+ } 2059+} 2060+ 2061+void MindIR_ROIPooling_SetPooledW(PrimitivePtr *primitive, int64_t pooled_w) { 2062+ if (primitive != nullptr && *primitive != nullptr) { 2063+ auto prim = static_cast<schema::Primitive *>(*primitive); 2064+ auto value = prim->value_as_ROIPooling(); 2065+ if (prim != nullptr && value != nullptr) { 2066+ flatbuffers::FlatBufferBuilder fbb; 2067+ auto ops_offset = schema::CreateROIPooling(fbb, value->pooled_h(), pooled_w, value->scale()); 2068+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_R_O_I_POOLING), ops_offset.o); 2069+ fbb.Finish(prim_offset); 2070+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 2071+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 2072+ free(*primitive); 2073+ *primitive = ret_value; 2074+ } 2075+ } 2076+} 2077+ 2078+float MindIR_ROIPooling_GetScale(ConstPrimitivePtr primitive) { 2079+ if (primitive != nullptr) { 2080+ auto prim = static_cast<const schema::Primitive *>(primitive); 2081+ auto value = prim->value_as_ROIPooling(); 2082+ if (prim != nullptr && value != nullptr) { 2083+ return value->scale(); 2084+ } else { 2085+ return .0; 2086+ } 2087+ } else { 2088+ return .0; 2089+ } 2090+} 2091+ 2092+void MindIR_ROIPooling_SetScale(PrimitivePtr *primitive, float scale) { 2093+ if (primitive != nullptr && *primitive != nullptr) { 2094+ auto prim = static_cast<schema::Primitive *>(*primitive); 2095+ auto value = prim->value_as_ROIPooling(); 2096+ if (prim != nullptr && value != nullptr) { 2097+ flatbuffers::FlatBufferBuilder fbb; 2098+ auto ops_offset = schema::CreateROIPooling(fbb, value->pooled_h(), value->pooled_w(), scale); 2099+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_R_O_I_POOLING), ops_offset.o); 2100+ fbb.Finish(prim_offset); 2101+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 2102+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 2103+ free(*primitive); 2104+ *primitive = ret_value; 2105+ } 2106+ } 2107+} 2108+ 2109+// ********** SkipGram ********** 2110+PrimitivePtr MindIR_SkipGram_CreatePrimitive(bool include_all_grams, int64_t max_skip_size, int64_t ngram_size) { 2111+ flatbuffers::FlatBufferBuilder fbb; 2112+ auto ops_offset = schema::CreateSkipGram(fbb, include_all_grams, max_skip_size, ngram_size); 2113+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_SKIP_GRAM), ops_offset.o); 2114+ fbb.Finish(prim_offset); 2115+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 2116+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 2117+ return ret_value; 2118+} 2119+ 2120+bool MindIR_SkipGram_GetIncludeAllGrams(ConstPrimitivePtr primitive) { 2121+ if (primitive != nullptr) { 2122+ auto prim = static_cast<const schema::Primitive *>(primitive); 2123+ auto value = prim->value_as_SkipGram(); 2124+ if (prim != nullptr && value != nullptr) { 2125+ return value->include_all_grams(); 2126+ } else { 2127+ return false; 2128+ } 2129+ } else { 2130+ return false; 2131+ } 2132+} 2133+ 2134+void MindIR_SkipGram_SetIncludeAllGrams(PrimitivePtr *primitive, bool include_all_grams) { 2135+ if (primitive != nullptr && *primitive != nullptr) { 2136+ auto prim = static_cast<schema::Primitive *>(*primitive); 2137+ auto value = prim->value_as_SkipGram(); 2138+ if (prim != nullptr && value != nullptr) { 2139+ flatbuffers::FlatBufferBuilder fbb; 2140+ auto ops_offset = schema::CreateSkipGram(fbb, include_all_grams, value->max_skip_size(), value->ngram_size()); 2141+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_SKIP_GRAM), ops_offset.o); 2142+ fbb.Finish(prim_offset); 2143+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 2144+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 2145+ free(*primitive); 2146+ *primitive = ret_value; 2147+ } 2148+ } 2149+} 2150+ 2151+int64_t MindIR_SkipGram_GetMaxSkipSize(ConstPrimitivePtr primitive) { 2152+ if (primitive != nullptr) { 2153+ auto prim = static_cast<const schema::Primitive *>(primitive); 2154+ auto value = prim->value_as_SkipGram(); 2155+ if (prim != nullptr && value != nullptr) { 2156+ return value->max_skip_size(); 2157+ } else { 2158+ return 0; 2159+ } 2160+ } else { 2161+ return 0; 2162+ } 2163+} 2164+ 2165+void MindIR_SkipGram_SetMaxSkipSize(PrimitivePtr *primitive, int64_t max_skip_size) { 2166+ if (primitive != nullptr && *primitive != nullptr) { 2167+ auto prim = static_cast<schema::Primitive *>(*primitive); 2168+ auto value = prim->value_as_SkipGram(); 2169+ if (prim != nullptr && value != nullptr) { 2170+ flatbuffers::FlatBufferBuilder fbb; 2171+ auto ops_offset = schema::CreateSkipGram(fbb, value->include_all_grams(), max_skip_size, value->ngram_size()); 2172+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_SKIP_GRAM), ops_offset.o); 2173+ fbb.Finish(prim_offset); 2174+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 2175+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 2176+ free(*primitive); 2177+ *primitive = ret_value; 2178+ } 2179+ } 2180+} 2181+ 2182+int64_t MindIR_SkipGram_GetNgramSize(ConstPrimitivePtr primitive) { 2183+ if (primitive != nullptr) { 2184+ auto prim = static_cast<const schema::Primitive *>(primitive); 2185+ auto value = prim->value_as_SkipGram(); 2186+ if (prim != nullptr && value != nullptr) { 2187+ return value->ngram_size(); 2188+ } else { 2189+ return 0; 2190+ } 2191+ } else { 2192+ return 0; 2193+ } 2194+} 2195+ 2196+void MindIR_SkipGram_SetNgramSize(PrimitivePtr *primitive, int64_t ngram_size) { 2197+ if (primitive != nullptr && *primitive != nullptr) { 2198+ auto prim = static_cast<schema::Primitive *>(*primitive); 2199+ auto value = prim->value_as_SkipGram(); 2200+ if (prim != nullptr && value != nullptr) { 2201+ flatbuffers::FlatBufferBuilder fbb; 2202+ auto ops_offset = schema::CreateSkipGram(fbb, value->include_all_grams(), value->max_skip_size(), ngram_size); 2203+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_SKIP_GRAM), ops_offset.o); 2204+ fbb.Finish(prim_offset); 2205+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 2206+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 2207+ free(*primitive); 2208+ *primitive = ret_value; 2209+ } 2210+ } 2211+} 2212+ 2213+// ********** Switch ********** 2214+PrimitivePtr MindIR_Switch_CreatePrimitive() { 2215+ flatbuffers::FlatBufferBuilder fbb; 2216+ auto ops_offset = schema::CreateSwitch(fbb); 2217+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_SWITCH), ops_offset.o); 2218+ fbb.Finish(prim_offset); 2219+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 2220+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 2221+ return ret_value; 2222+} 2223+ 2224+// ********** Unique ********** 2225+PrimitivePtr MindIR_Unique_CreatePrimitive() { 2226+ flatbuffers::FlatBufferBuilder fbb; 2227+ auto ops_offset = schema::CreateUnique(fbb); 2228+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_UNIQUE), ops_offset.o); 2229+ fbb.Finish(prim_offset); 2230+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 2231+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 2232+ return ret_value; 2233+} 2234+ 2235+// ********** UnsortedSegmentSum ********** 2236+PrimitivePtr MindIR_UnsortedSegmentSum_CreatePrimitive() { 2237+ flatbuffers::FlatBufferBuilder fbb; 2238+ auto ops_offset = schema::CreateUnsortedSegmentSum(fbb); 2239+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_UNSORTED_SEGMENT_SUM), ops_offset.o); 2240+ fbb.Finish(prim_offset); 2241+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 2242+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 2243+ return ret_value; 2244+} 2245+ 2246+// ********** ZerosLike ********** 2247+PrimitivePtr MindIR_ZerosLike_CreatePrimitive() { 2248+ flatbuffers::FlatBufferBuilder fbb; 2249+ auto ops_offset = schema::CreateZerosLike(fbb); 2250+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_ZEROS_LIKE), ops_offset.o); 2251+ fbb.Finish(prim_offset); 2252+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 2253+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 2254+ return ret_value; 2255+} 2256+ 2257+// ********** GRU ********** 2258+PrimitivePtr MindIR_GRU_CreatePrimitive(bool bidirectional) { 2259+ flatbuffers::FlatBufferBuilder fbb; 2260+ auto ops_offset = schema::CreateGRU(fbb, bidirectional); 2261+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_G_R_U), ops_offset.o); 2262+ fbb.Finish(prim_offset); 2263+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 2264+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 2265+ return ret_value; 2266+} 2267+ 2268+bool MindIR_GRU_GetBidirectional(ConstPrimitivePtr primitive) { 2269+ if (primitive != nullptr) { 2270+ auto prim = static_cast<const schema::Primitive *>(primitive); 2271+ auto value = prim->value_as_GRU(); 2272+ if (prim != nullptr && value != nullptr) { 2273+ return value->bidirectional(); 2274+ } else { 2275+ return false; 2276+ } 2277+ } else { 2278+ return false; 2279+ } 2280+} 2281+ 2282+void MindIR_GRU_SetBidirectional(PrimitivePtr *primitive, bool bidirectional) { 2283+ if (primitive != nullptr && *primitive != nullptr) { 2284+ auto prim = static_cast<schema::Primitive *>(*primitive); 2285+ auto value = prim->value_as_GRU(); 2286+ if (prim != nullptr && value != nullptr) { 2287+ flatbuffers::FlatBufferBuilder fbb; 2288+ auto ops_offset = schema::CreateGRU(fbb, bidirectional); 2289+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_G_R_U), ops_offset.o); 2290+ fbb.Finish(prim_offset); 2291+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 2292+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 2293+ free(*primitive); 2294+ *primitive = ret_value; 2295+ } 2296+ } 2297+} 2298+ 2299+// ********** NonZero ********** 2300+PrimitivePtr MindIR_NonZero_CreatePrimitive() { 2301+ flatbuffers::FlatBufferBuilder fbb; 2302+ auto ops_offset = schema::CreateNonZero(fbb); 2303+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_NON_ZERO), ops_offset.o); 2304+ fbb.Finish(prim_offset); 2305+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 2306+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 2307+ return ret_value; 2308+} 2309+ 2310+// ********** InvertPermutation ********** 2311+PrimitivePtr MindIR_InvertPermutation_CreatePrimitive() { 2312+ flatbuffers::FlatBufferBuilder fbb; 2313+ auto ops_offset = schema::CreateInvertPermutation(fbb); 2314+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_INVERT_PERMUTATION), ops_offset.o); 2315+ fbb.Finish(prim_offset); 2316+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 2317+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 2318+ return ret_value; 2319+} 2320+ 2321+// ********** Size ********** 2322+PrimitivePtr MindIR_Size_CreatePrimitive() { 2323+ flatbuffers::FlatBufferBuilder fbb; 2324+ auto ops_offset = schema::CreateSize(fbb); 2325+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_SIZE), ops_offset.o); 2326+ fbb.Finish(prim_offset); 2327+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 2328+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 2329+ return ret_value; 2330+} 2331+ 2332+// ********** RandomStandardNormal ********** 2333+PrimitivePtr MindIR_RandomStandardNormal_CreatePrimitive(int64_t seed, int64_t seed2) { 2334+ flatbuffers::FlatBufferBuilder fbb; 2335+ auto ops_offset = schema::CreateRandomStandardNormal(fbb, seed, seed2); 2336+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_RANDOM_STANDARD_NORMAL), ops_offset.o); 2337+ fbb.Finish(prim_offset); 2338+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 2339+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 2340+ return ret_value; 2341+} 2342+ 2343+int64_t MindIR_RandomStandardNormal_GetSeed(ConstPrimitivePtr primitive) { 2344+ if (primitive != nullptr) { 2345+ auto prim = static_cast<const schema::Primitive *>(primitive); 2346+ auto value = prim->value_as_RandomStandardNormal(); 2347+ if (prim != nullptr && value != nullptr) { 2348+ return value->seed(); 2349+ } else { 2350+ return 0; 2351+ } 2352+ } else { 2353+ return 0; 2354+ } 2355+} 2356+ 2357+void MindIR_RandomStandardNormal_SetSeed(PrimitivePtr *primitive, int64_t seed) { 2358+ if (primitive != nullptr && *primitive != nullptr) { 2359+ auto prim = static_cast<schema::Primitive *>(*primitive); 2360+ auto value = prim->value_as_RandomStandardNormal(); 2361+ if (prim != nullptr && value != nullptr) { 2362+ flatbuffers::FlatBufferBuilder fbb; 2363+ auto ops_offset = schema::CreateRandomStandardNormal(fbb, seed, value->seed2()); 2364+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_RANDOM_STANDARD_NORMAL), ops_offset.o); 2365+ fbb.Finish(prim_offset); 2366+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 2367+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 2368+ free(*primitive); 2369+ *primitive = ret_value; 2370+ } 2371+ } 2372+} 2373+int64_t MindIR_RandomStandardNormal_GetSeed2(ConstPrimitivePtr primitive) { 2374+ if (primitive != nullptr) { 2375+ auto prim = static_cast<const schema::Primitive *>(primitive); 2376+ auto value = prim->value_as_RandomStandardNormal(); 2377+ if (prim != nullptr && value != nullptr) { 2378+ return value->seed2(); 2379+ } else { 2380+ return 0; 2381+ } 2382+ } else { 2383+ return 0; 2384+ } 2385+} 2386+ 2387+void MindIR_RandomStandardNormal_SetSeed2(PrimitivePtr *primitive, int64_t seed2) { 2388+ if (primitive != nullptr && *primitive != nullptr) { 2389+ auto prim = static_cast<schema::Primitive *>(*primitive); 2390+ auto value = prim->value_as_RandomStandardNormal(); 2391+ if (prim != nullptr && value != nullptr) { 2392+ flatbuffers::FlatBufferBuilder fbb; 2393+ auto ops_offset = schema::CreateRandomStandardNormal(fbb, value->seed(), seed2); 2394+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_RANDOM_STANDARD_NORMAL), ops_offset.o); 2395+ fbb.Finish(prim_offset); 2396+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 2397+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 2398+ free(*primitive); 2399+ *primitive = ret_value; 2400+ } 2401+ } 2402+} 2403+ 2404+// ********** CropAndResize ********** 2405+PrimitivePtr MindIR_CropAndResize_CreatePrimitive(ResizeMethod method, float extrapolation_value) { 2406+ flatbuffers::FlatBufferBuilder fbb; 2407+ auto ops_offset = schema::CreateCropAndResize(fbb, static_cast<schema::ResizeMethod>(method), extrapolation_value); 2408+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_CROP_AND_RESIZE), ops_offset.o); 2409+ fbb.Finish(prim_offset); 2410+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 2411+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 2412+ return ret_value; 2413+} 2414+ 2415+ResizeMethod MindIR_CropAndResize_GetMethod(ConstPrimitivePtr primitive) { 2416+ if (primitive != nullptr) { 2417+ auto prim = static_cast<const schema::Primitive *>(primitive); 2418+ auto value = prim->value_as_CropAndResize(); 2419+ if (prim != nullptr && value != nullptr) { 2420+ return static_cast<ResizeMethod>(value->method()); 2421+ } else { 2422+ ResizeMethod en = static_cast<ResizeMethod>(0); 2423+ return en; 2424+ } 2425+ } else { 2426+ ResizeMethod en = static_cast<ResizeMethod>(0); 2427+ return en; 2428+ } 2429+} 2430+ 2431+void MindIR_CropAndResize_SetMethod(PrimitivePtr *primitive, ResizeMethod method) { 2432+ if (primitive != nullptr && *primitive != nullptr) { 2433+ auto prim = static_cast<schema::Primitive *>(*primitive); 2434+ auto value = prim->value_as_CropAndResize(); 2435+ if (prim != nullptr && value != nullptr) { 2436+ flatbuffers::FlatBufferBuilder fbb; 2437+ auto ops_offset = schema::CreateCropAndResize(fbb, static_cast<schema::ResizeMethod>(method), value->extrapolation_value()); 2438+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_CROP_AND_RESIZE), ops_offset.o); 2439+ fbb.Finish(prim_offset); 2440+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 2441+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 2442+ free(*primitive); 2443+ *primitive = ret_value; 2444+ } 2445+ } 2446+} 2447+ 2448+float MindIR_CropAndResize_GetExtrapolationValue(ConstPrimitivePtr primitive) { 2449+ if (primitive != nullptr) { 2450+ auto prim = static_cast<const schema::Primitive *>(primitive); 2451+ auto value = prim->value_as_CropAndResize(); 2452+ if (prim != nullptr && value != nullptr) { 2453+ return value->extrapolation_value(); 2454+ } else { 2455+ return .0; 2456+ } 2457+ } else { 2458+ return .0; 2459+ } 2460+} 2461+ 2462+void MindIR_CropAndResize_SetExtrapolationValue(PrimitivePtr *primitive, float extrapolation_value) { 2463+ if (primitive != nullptr && *primitive != nullptr) { 2464+ auto prim = static_cast<schema::Primitive *>(*primitive); 2465+ auto value = prim->value_as_CropAndResize(); 2466+ if (prim != nullptr && value != nullptr) { 2467+ flatbuffers::FlatBufferBuilder fbb; 2468+ auto ops_offset = schema::CreateCropAndResize(fbb, static_cast<schema::ResizeMethod>(value->method()), extrapolation_value); 2469+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_CROP_AND_RESIZE), ops_offset.o); 2470+ fbb.Finish(prim_offset); 2471+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 2472+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 2473+ free(*primitive); 2474+ *primitive = ret_value; 2475+ } 2476+ } 2477+} 2478+ 2479+// ********** IsFinite ********** 2480+PrimitivePtr MindIR_IsFinite_CreatePrimitive() { 2481+ flatbuffers::FlatBufferBuilder fbb; 2482+ auto ops_offset = schema::CreateIsFinite(fbb); 2483+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_IS_FINITE), ops_offset.o); 2484+ fbb.Finish(prim_offset); 2485+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 2486+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 2487+ return ret_value; 2488+} 2489+ 2490+// ********** LinSpace ********** 2491+PrimitivePtr MindIR_LinSpace_CreatePrimitive() { 2492+ flatbuffers::FlatBufferBuilder fbb; 2493+ auto ops_offset = schema::CreateLinSpace(fbb); 2494+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_LIN_SPACE), ops_offset.o); 2495+ fbb.Finish(prim_offset); 2496+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 2497+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 2498+ return ret_value; 2499+} 2500+ 2501+// ********** UniformReal ********** 2502+PrimitivePtr MindIR_UniformReal_CreatePrimitive(int64_t seed, int64_t seed2) { 2503+ flatbuffers::FlatBufferBuilder fbb; 2504+ auto ops_offset = schema::CreateUniformReal(fbb, seed, seed2); 2505+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_UNIFORM_REAL), ops_offset.o); 2506+ fbb.Finish(prim_offset); 2507+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 2508+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 2509+ return ret_value; 2510+} 2511+ 2512+int64_t MindIR_UniformReal_GetSeed(ConstPrimitivePtr primitive) { 2513+ if (primitive != nullptr) { 2514+ auto prim = static_cast<const schema::Primitive *>(primitive); 2515+ auto value = prim->value_as_UniformReal(); 2516+ if (prim != nullptr && value != nullptr) { 2517+ return value->seed(); 2518+ } else { 2519+ return 0; 2520+ } 2521+ } else { 2522+ return 0; 2523+ } 2524+} 2525+ 2526+void MindIR_UniformReal_SetSeed(PrimitivePtr *primitive, int64_t seed) { 2527+ if (primitive != nullptr && *primitive != nullptr) { 2528+ auto prim = static_cast<schema::Primitive *>(*primitive); 2529+ auto value = prim->value_as_UniformReal(); 2530+ if (prim != nullptr && value != nullptr) { 2531+ flatbuffers::FlatBufferBuilder fbb; 2532+ auto ops_offset = schema::CreateUniformReal(fbb, seed, value->seed2()); 2533+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_UNIFORM_REAL), ops_offset.o); 2534+ fbb.Finish(prim_offset); 2535+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 2536+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 2537+ free(*primitive); 2538+ *primitive = ret_value; 2539+ } 2540+ } 2541+} 2542+ 2543+int64_t MindIR_UniformReal_GetSeed2(ConstPrimitivePtr primitive) { 2544+ if (primitive != nullptr) { 2545+ auto prim = static_cast<const schema::Primitive *>(primitive); 2546+ auto value = prim->value_as_UniformReal(); 2547+ if (prim != nullptr && value != nullptr) { 2548+ return value->seed2(); 2549+ } else { 2550+ return 0; 2551+ } 2552+ } else { 2553+ return 0; 2554+ } 2555+} 2556+ 2557+void MindIR_UniformReal_SetSeed2(PrimitivePtr *primitive, int64_t seed2) { 2558+ if (primitive != nullptr && *primitive != nullptr) { 2559+ auto prim = static_cast<schema::Primitive *>(*primitive); 2560+ auto value = prim->value_as_UniformReal(); 2561+ if (prim != nullptr && value != nullptr) { 2562+ flatbuffers::FlatBufferBuilder fbb; 2563+ auto ops_offset = schema::CreateUniformReal(fbb, value->seed(), seed2); 2564+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_UNIFORM_REAL), ops_offset.o); 2565+ fbb.Finish(prim_offset); 2566+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 2567+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 2568+ free(*primitive); 2569+ *primitive = ret_value; 2570+ } 2571+ } 2572+} 2573+ 2574+// ********** Splice ********** 2575+PrimitivePtr MindIR_Splice_CreatePrimitive(const std::vector<int64_t> &context, const std::vector<int64_t> &forward_indexes, int64_t output_dim) { 2576+ flatbuffers::FlatBufferBuilder fbb; 2577+ auto ops_offset = schema::CreateSplice(fbb, fbb.CreateVector(context.data(), context.size()), fbb.CreateVector(forward_indexes.data(), forward_indexes.size()), output_dim); 2578+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_SPLICE), ops_offset.o); 2579+ fbb.Finish(prim_offset); 2580+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 2581+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 2582+ return ret_value; 2583+} 2584+ 2585+std::vector<int64_t> MindIR_Splice_GetContext(ConstPrimitivePtr primitive) { 2586+ if (primitive != nullptr) { 2587+ auto prim = static_cast<const schema::Primitive *>(primitive); 2588+ auto value = prim->value_as_Splice(); 2589+ if (prim != nullptr && value != nullptr) { 2590+ std::vector<int64_t> result; 2591+ auto src = value->context(); 2592+ if (src == nullptr) { 2593+ return {}; 2594+ } 2595+ result.resize(src->size()); 2596+ std::transform(src->begin(), src->end(), result.begin(), [](int64_t item) { return item; }); 2597+ return result; 2598+ } else { 2599+ return {}; 2600+ } 2601+ } else { 2602+ return {}; 2603+ } 2604+} 2605+ 2606+void MindIR_Splice_SetContext(PrimitivePtr *primitive, const std::vector<int64_t> &context) { 2607+ if (primitive != nullptr && *primitive != nullptr) { 2608+ auto prim = static_cast<schema::Primitive *>(*primitive); 2609+ auto value = prim->value_as_Splice(); 2610+ if (prim != nullptr && value != nullptr) { 2611+ flatbuffers::FlatBufferBuilder fbb; 2612+ auto ops_offset = schema::CreateSplice(fbb, fbb.CreateVector(context.data(), context.size()), fbb.CreateVector(value->forward_indexes()->data(), value->forward_indexes()->size()), value->output_dim()); 2613+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_SPLICE), ops_offset.o); 2614+ fbb.Finish(prim_offset); 2615+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 2616+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 2617+ free(*primitive); 2618+ *primitive = ret_value; 2619+ } 2620+ } 2621+} 2622+ 2623+std::vector<int64_t> MindIR_Splice_GetForwardIndexes(ConstPrimitivePtr primitive) { 2624+ if (primitive != nullptr) { 2625+ auto prim = static_cast<const schema::Primitive *>(primitive); 2626+ auto value = prim->value_as_Splice(); 2627+ if (prim != nullptr && value != nullptr) { 2628+ std::vector<int64_t> result; 2629+ auto src = value->forward_indexes(); 2630+ if (src == nullptr) { 2631+ return {}; 2632+ } 2633+ result.resize(src->size()); 2634+ std::transform(src->begin(), src->end(), result.begin(), [](int64_t item) { return item; }); 2635+ return result; 2636+ } else { 2637+ return {}; 2638+ } 2639+ } else { 2640+ return {}; 2641+ } 2642+} 2643+ 2644+void MindIR_Splice_SetForwardIndexes(PrimitivePtr *primitive, const std::vector<int64_t> &forward_indexes) { 2645+ if (primitive != nullptr && *primitive != nullptr) { 2646+ auto prim = static_cast<schema::Primitive *>(*primitive); 2647+ auto value = prim->value_as_Splice(); 2648+ if (prim != nullptr && value != nullptr) { 2649+ flatbuffers::FlatBufferBuilder fbb; 2650+ auto ops_offset = schema::CreateSplice(fbb, fbb.CreateVector(value->context()->data(), value->context()->size()), fbb.CreateVector(forward_indexes.data(), forward_indexes.size()), value->output_dim()); 2651+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_SPLICE), ops_offset.o); 2652+ fbb.Finish(prim_offset); 2653+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 2654+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 2655+ free(*primitive); 2656+ *primitive = ret_value; 2657+ } 2658+ } 2659+} 2660+ 2661+int64_t MindIR_Splice_GetOutputDim(ConstPrimitivePtr primitive) { 2662+ if (primitive != nullptr) { 2663+ auto prim = static_cast<const schema::Primitive *>(primitive); 2664+ auto value = prim->value_as_Splice(); 2665+ if (prim != nullptr && value != nullptr) { 2666+ return value->output_dim(); 2667+ } else { 2668+ return 0; 2669+ } 2670+ } else { 2671+ return 0; 2672+ } 2673+} 2674+ 2675+void MindIR_Splice_SetOutputDim(PrimitivePtr *primitive, int64_t output_dim) { 2676+ if (primitive != nullptr && *primitive != nullptr) { 2677+ auto prim = static_cast<schema::Primitive *>(*primitive); 2678+ auto value = prim->value_as_Splice(); 2679+ if (prim != nullptr && value != nullptr) { 2680+ flatbuffers::FlatBufferBuilder fbb; 2681+ auto ops_offset = schema::CreateSplice(fbb, fbb.CreateVector(value->context()->data(), value->context()->size()), fbb.CreateVector(value->forward_indexes()->data(), value->forward_indexes()->size()), output_dim); 2682+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_SPLICE), ops_offset.o); 2683+ fbb.Finish(prim_offset); 2684+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 2685+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 2686+ free(*primitive); 2687+ *primitive = ret_value; 2688+ } 2689+ } 2690+} 2691+ 2692+// ********** Call ********** 2693+PrimitivePtr MindIR_Call_CreatePrimitive(bool is_tail_call) { 2694+ flatbuffers::FlatBufferBuilder fbb; 2695+ auto ops_offset = schema::CreateCall(fbb, is_tail_call); 2696+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_CALL), ops_offset.o); 2697+ fbb.Finish(prim_offset); 2698+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 2699+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 2700+ return ret_value; 2701+} 2702+ 2703+bool MindIR_Call_GetIsTailCall(ConstPrimitivePtr primitive) { 2704+ if (primitive != nullptr) { 2705+ auto prim = static_cast<const schema::Primitive *>(primitive); 2706+ auto value = prim->value_as_Call(); 2707+ if (prim != nullptr && value != nullptr) { 2708+ return value->is_tail_call(); 2709+ } else { 2710+ return false; 2711+ } 2712+ } else { 2713+ return false; 2714+ } 2715+} 2716+ 2717+void MindIR_Call_SetIsTailCall(PrimitivePtr *primitive, bool is_tail_call) { 2718+ if (primitive != nullptr && *primitive != nullptr) { 2719+ auto prim = static_cast<schema::Primitive *>(*primitive); 2720+ auto value = prim->value_as_Call(); 2721+ if (prim != nullptr && value != nullptr) { 2722+ flatbuffers::FlatBufferBuilder fbb; 2723+ auto ops_offset = schema::CreateCall(fbb, is_tail_call); 2724+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_CALL), ops_offset.o); 2725+ fbb.Finish(prim_offset); 2726+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 2727+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 2728+ free(*primitive); 2729+ *primitive = ret_value; 2730+ } 2731+ } 2732+} 2733+ 2734+// ********** CumSum ********** 2735+PrimitivePtr MindIR_CumSum_CreatePrimitive(bool exclusive, bool reverse) { 2736+ flatbuffers::FlatBufferBuilder fbb; 2737+ auto ops_offset = schema::CreateCumSum(fbb, exclusive, reverse); 2738+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_CUM_SUM), ops_offset.o); 2739+ fbb.Finish(prim_offset); 2740+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 2741+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 2742+ return ret_value; 2743+} 2744+ 2745+bool MindIR_CumSum_GetExclusive(ConstPrimitivePtr primitive) { 2746+ if (primitive != nullptr) { 2747+ auto prim = static_cast<const schema::Primitive *>(primitive); 2748+ auto value = prim->value_as_CumSum(); 2749+ if (prim != nullptr && value != nullptr) { 2750+ return value->exclusive(); 2751+ } else { 2752+ return false; 2753+ } 2754+ } else { 2755+ return false; 2756+ } 2757+} 2758+ 2759+void MindIR_CumSum_SetExclusive(PrimitivePtr *primitive, bool exclusive) { 2760+ if (primitive != nullptr && *primitive != nullptr) { 2761+ auto prim = static_cast<schema::Primitive *>(*primitive); 2762+ auto value = prim->value_as_CumSum(); 2763+ if (prim != nullptr && value != nullptr) { 2764+ flatbuffers::FlatBufferBuilder fbb; 2765+ auto ops_offset = schema::CreateCumSum(fbb, exclusive, value->reverse()); 2766+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_CUM_SUM), ops_offset.o); 2767+ fbb.Finish(prim_offset); 2768+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 2769+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 2770+ free(*primitive); 2771+ *primitive = ret_value; 2772+ } 2773+ } 2774+} 2775+ 2776+bool MindIR_CumSum_GetReverse(ConstPrimitivePtr primitive) { 2777+ if (primitive != nullptr) { 2778+ auto prim = static_cast<const schema::Primitive *>(primitive); 2779+ auto value = prim->value_as_CumSum(); 2780+ if (prim != nullptr && value != nullptr) { 2781+ return value->reverse(); 2782+ } else { 2783+ return false; 2784+ } 2785+ } else { 2786+ return false; 2787+ } 2788+} 2789+ 2790+void MindIR_CumSum_SetReverse(PrimitivePtr *primitive, bool reverse) { 2791+ if (primitive != nullptr && *primitive != nullptr) { 2792+ auto prim = static_cast<schema::Primitive *>(*primitive); 2793+ auto value = prim->value_as_CumSum(); 2794+ if (prim != nullptr && value != nullptr) { 2795+ flatbuffers::FlatBufferBuilder fbb; 2796+ auto ops_offset = schema::CreateCumSum(fbb, value->exclusive(), reverse); 2797+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_CUM_SUM), ops_offset.o); 2798+ fbb.Finish(prim_offset); 2799+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 2800+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 2801+ free(*primitive); 2802+ *primitive = ret_value; 2803+ } 2804+ } 2805+} 2806+} // namespace lite 2807+} // namespace mindspore 2808diff --git a/mindspore/lite/mindir/src/mindir_2.cc b/mindspore/lite/mindir/src/mindir_2.cc 2809new file mode 100644 2810index 00000000..5c91b7bf 2811--- /dev/null 2812+++ b/mindspore/lite/mindir/src/mindir_2.cc 2813@@ -0,0 +1,2152 @@ 2814+/** 2815+ * Copyright 2024 Huawei Technologies Co., Ltd 2816+ * 2817+ * Licensed under the Apache License, Version 2.0 (the "License"); 2818+ * you may not use this file except in compliance with the License. 2819+ * You may obtain a copy of the License at 2820+ * 2821+ * http://www.apache.org/licenses/LICENSE-2.0 2822+ * 2823+ * Unless required by applicable law or agreed to in writing, software 2824+ * distributed under the License is distributed on an "AS IS" BASIS, 2825+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 2826+ * See the License for the specific language governing permissions and 2827+ * limitations under the License. 2828+ */ 2829+ 2830+#include "mindir.h" 2831+#include "utils.h" 2832+#include "schema/model_generated.h" 2833+#include "mindir_memory_manager.h" 2834+ 2835+namespace mindspore { 2836+namespace lite { 2837+// ********** SplitWithOverlap ********** 2838+PrimitivePtr MindIR_SplitWithOverlap_CreatePrimitive(int64_t split_dim, int64_t number_split, const std::vector<int64_t> &ratio, const std::vector<int64_t> &extend_top, const std::vector<int64_t> &extend_bottom) { 2839+ flatbuffers::FlatBufferBuilder fbb; 2840+ auto ops_offset = schema::CreateSplitWithOverlap(fbb, split_dim, number_split, fbb.CreateVector(ratio.data(), ratio.size()), fbb.CreateVector(extend_top.data(), extend_top.size()), fbb.CreateVector(extend_bottom.data(), extend_bottom.size())); 2841+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_SPLIT_WITH_OVERLAP), ops_offset.o); 2842+ fbb.Finish(prim_offset); 2843+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 2844+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 2845+ return ret_value; 2846+} 2847+ 2848+int64_t MindIR_SplitWithOverlap_GetSplitDim(ConstPrimitivePtr primitive) { 2849+ if (primitive != nullptr) { 2850+ auto prim = static_cast<const schema::Primitive *>(primitive); 2851+ auto value = prim->value_as_SplitWithOverlap(); 2852+ if (prim != nullptr && value != nullptr) { 2853+ return value->split_dim(); 2854+ } else { 2855+ return 0; 2856+ } 2857+ } else { 2858+ return 0; 2859+ } 2860+} 2861+ 2862+void MindIR_SplitWithOverlap_SetSplitDim(PrimitivePtr *primitive, int64_t split_dim) { 2863+ if (primitive != nullptr && *primitive != nullptr) { 2864+ auto prim = static_cast<schema::Primitive *>(*primitive); 2865+ auto value = prim->value_as_SplitWithOverlap(); 2866+ if (prim != nullptr && value != nullptr) { 2867+ flatbuffers::FlatBufferBuilder fbb; 2868+ auto ops_offset = schema::CreateSplitWithOverlap(fbb, split_dim, value->number_split(), fbb.CreateVector(value->ratio()->data(), value->ratio()->size()), fbb.CreateVector(value->extend_top()->data(), value->extend_top()->size()), fbb.CreateVector(value->extend_bottom()->data(), value->extend_bottom()->size())); 2869+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_SPLIT_WITH_OVERLAP), ops_offset.o); 2870+ fbb.Finish(prim_offset); 2871+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 2872+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 2873+ free(*primitive); 2874+ *primitive = ret_value; 2875+ } 2876+ } 2877+} 2878+ 2879+int64_t MindIR_SplitWithOverlap_GetNumberSplit(ConstPrimitivePtr primitive) { 2880+ if (primitive != nullptr) { 2881+ auto prim = static_cast<const schema::Primitive *>(primitive); 2882+ auto value = prim->value_as_SplitWithOverlap(); 2883+ if (prim != nullptr && value != nullptr) { 2884+ return value->number_split(); 2885+ } else { 2886+ return 0; 2887+ } 2888+ } else { 2889+ return 0; 2890+ } 2891+} 2892+ 2893+void MindIR_SplitWithOverlap_SetNumberSplit(PrimitivePtr *primitive, int64_t number_split) { 2894+ if (primitive != nullptr && *primitive != nullptr) { 2895+ auto prim = static_cast<schema::Primitive *>(*primitive); 2896+ auto value = prim->value_as_SplitWithOverlap(); 2897+ if (prim != nullptr && value != nullptr) { 2898+ flatbuffers::FlatBufferBuilder fbb; 2899+ auto ops_offset = schema::CreateSplitWithOverlap(fbb, value->split_dim(), number_split, fbb.CreateVector(value->ratio()->data(), value->ratio()->size()), fbb.CreateVector(value->extend_top()->data(), value->extend_top()->size()), fbb.CreateVector(value->extend_bottom()->data(), value->extend_bottom()->size())); 2900+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_SPLIT_WITH_OVERLAP), ops_offset.o); 2901+ fbb.Finish(prim_offset); 2902+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 2903+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 2904+ free(*primitive); 2905+ *primitive = ret_value; 2906+ } 2907+ } 2908+} 2909+ 2910+std::vector<int64_t> MindIR_SplitWithOverlap_GetRatio(ConstPrimitivePtr primitive) { 2911+ if (primitive != nullptr) { 2912+ auto prim = static_cast<const schema::Primitive *>(primitive); 2913+ auto value = prim->value_as_SplitWithOverlap(); 2914+ if (prim != nullptr && value != nullptr) { 2915+ std::vector<int64_t> result; 2916+ auto src = value->ratio(); 2917+ if (src == nullptr) { 2918+ return {}; 2919+ } 2920+ result.resize(src->size()); 2921+ std::transform(src->begin(), src->end(), result.begin(), [](int64_t item) { return item; }); 2922+ return result; 2923+ } else { 2924+ return {}; 2925+ } 2926+ } else { 2927+ return {}; 2928+ } 2929+} 2930+ 2931+void MindIR_SplitWithOverlap_SetRatio(PrimitivePtr *primitive, const std::vector<int64_t> &ratio) { 2932+ if (primitive != nullptr && *primitive != nullptr) { 2933+ auto prim = static_cast<schema::Primitive *>(*primitive); 2934+ auto value = prim->value_as_SplitWithOverlap(); 2935+ if (prim != nullptr && value != nullptr) { 2936+ flatbuffers::FlatBufferBuilder fbb; 2937+ auto ops_offset = schema::CreateSplitWithOverlap(fbb, value->split_dim(), value->number_split(), fbb.CreateVector(ratio.data(), ratio.size()), fbb.CreateVector(value->extend_top()->data(), value->extend_top()->size()), fbb.CreateVector(value->extend_bottom()->data(), value->extend_bottom()->size())); 2938+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_SPLIT_WITH_OVERLAP), ops_offset.o); 2939+ fbb.Finish(prim_offset); 2940+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 2941+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 2942+ free(*primitive); 2943+ *primitive = ret_value; 2944+ } 2945+ } 2946+} 2947+ 2948+std::vector<int64_t> MindIR_SplitWithOverlap_GetExtendTop(ConstPrimitivePtr primitive) { 2949+ if (primitive != nullptr) { 2950+ auto prim = static_cast<const schema::Primitive *>(primitive); 2951+ auto value = prim->value_as_SplitWithOverlap(); 2952+ if (prim != nullptr && value != nullptr) { 2953+ std::vector<int64_t> result; 2954+ auto src = value->extend_top(); 2955+ if (src == nullptr) { 2956+ return {}; 2957+ } 2958+ result.resize(src->size()); 2959+ std::transform(src->begin(), src->end(), result.begin(), [](int64_t item) { return item; }); 2960+ return result; 2961+ } else { 2962+ return {}; 2963+ } 2964+ } else { 2965+ return {}; 2966+ } 2967+} 2968+ 2969+void MindIR_SplitWithOverlap_SetExtendTop(PrimitivePtr *primitive, const std::vector<int64_t> &extend_top) { 2970+ if (primitive != nullptr && *primitive != nullptr) { 2971+ auto prim = static_cast<schema::Primitive *>(*primitive); 2972+ auto value = prim->value_as_SplitWithOverlap(); 2973+ if (prim != nullptr && value != nullptr) { 2974+ flatbuffers::FlatBufferBuilder fbb; 2975+ auto ops_offset = schema::CreateSplitWithOverlap(fbb, value->split_dim(), value->number_split(), fbb.CreateVector(value->ratio()->data(), value->ratio()->size()), fbb.CreateVector(extend_top.data(), extend_top.size()), fbb.CreateVector(value->extend_bottom()->data(), value->extend_bottom()->size())); 2976+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_SPLIT_WITH_OVERLAP), ops_offset.o); 2977+ fbb.Finish(prim_offset); 2978+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 2979+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 2980+ free(*primitive); 2981+ *primitive = ret_value; 2982+ } 2983+ } 2984+} 2985+ 2986+std::vector<int64_t> MindIR_SplitWithOverlap_GetExtendBottom(ConstPrimitivePtr primitive) { 2987+ if (primitive != nullptr) { 2988+ auto prim = static_cast<const schema::Primitive *>(primitive); 2989+ auto value = prim->value_as_SplitWithOverlap(); 2990+ if (prim != nullptr && value != nullptr) { 2991+ std::vector<int64_t> result; 2992+ auto src = value->extend_bottom(); 2993+ if (src == nullptr) { 2994+ return {}; 2995+ } 2996+ result.resize(src->size()); 2997+ std::transform(src->begin(), src->end(), result.begin(), [](int64_t item) { return item; }); 2998+ return result; 2999+ } else { 3000+ return {}; 3001+ } 3002+ } else { 3003+ return {}; 3004+ } 3005+} 3006+ 3007+void MindIR_SplitWithOverlap_SetExtendBottom(PrimitivePtr *primitive, const std::vector<int64_t> &extend_bottom) { 3008+ if (primitive != nullptr && *primitive != nullptr) { 3009+ auto prim = static_cast<schema::Primitive *>(*primitive); 3010+ auto value = prim->value_as_SplitWithOverlap(); 3011+ if (prim != nullptr && value != nullptr) { 3012+ flatbuffers::FlatBufferBuilder fbb; 3013+ auto ops_offset = schema::CreateSplitWithOverlap(fbb, value->split_dim(), value->number_split(), fbb.CreateVector(value->ratio()->data(), value->ratio()->size()), fbb.CreateVector(value->extend_top()->data(), value->extend_top()->size()), fbb.CreateVector(extend_bottom.data(), extend_bottom.size())); 3014+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_SPLIT_WITH_OVERLAP), ops_offset.o); 3015+ fbb.Finish(prim_offset); 3016+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 3017+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 3018+ free(*primitive); 3019+ *primitive = ret_value; 3020+ } 3021+ } 3022+} 3023+ 3024+// ********** GenOP ********** 3025+PrimitivePtr MindIR_GenOP_CreatePrimitive(ActivationType activation_type, float alpha, float min_val, float max_val, bool is_training, Format format, const std::vector<int64_t> &kernel_size, const std::vector<int64_t> &stride, const std::vector<int64_t> &dilation, PadMode pad_mode, const std::vector<int64_t> &pad_list, int64_t mode, int64_t group, int64_t in_channel, int64_t out_channel, EltwiseMode eltwise_mode, bool has_bias, bool use_axis, int64_t axis, float epsilon, float momentum, bool transpose_a, bool transpose_b, const std::vector<int64_t> &pad, RoundMode round_mode, bool global, bool channel_shared, const std::vector<int64_t> &axes, bool keep_dims, ReduceMode reduce_mode, bool reduce_to_end, float coeff) { 3026+ flatbuffers::FlatBufferBuilder fbb; 3027+ auto ops_offset = schema::CreateGenOP(fbb, static_cast<schema::ActivationType>(activation_type), alpha, min_val, max_val, is_training, static_cast<schema::Format>(format), fbb.CreateVector(kernel_size.data(), kernel_size.size()), fbb.CreateVector(stride.data(), stride.size()), fbb.CreateVector(dilation.data(), dilation.size()), static_cast<schema::PadMode>(pad_mode), fbb.CreateVector(pad_list.data(), pad_list.size()), mode, group, in_channel, out_channel, static_cast<schema::EltwiseMode>(eltwise_mode), has_bias, use_axis, axis, epsilon, momentum, transpose_a, transpose_b, fbb.CreateVector(pad.data(), pad.size()), static_cast<schema::RoundMode>(round_mode), global, channel_shared, fbb.CreateVector(axes.data(), axes.size()), keep_dims, static_cast<schema::ReduceMode>(reduce_mode), reduce_to_end, coeff); 3028+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_GEN_O_P), ops_offset.o); 3029+ fbb.Finish(prim_offset); 3030+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 3031+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 3032+ return ret_value; 3033+} 3034+ 3035+ActivationType MindIR_GenOP_GetActivationType(ConstPrimitivePtr primitive) { 3036+ if (primitive != nullptr) { 3037+ auto prim = static_cast<const schema::Primitive *>(primitive); 3038+ auto value = prim->value_as_GenOP(); 3039+ if (prim != nullptr && value != nullptr) { 3040+ return static_cast<ActivationType>(value->activation_type()); 3041+ } else { 3042+ ActivationType en = static_cast<ActivationType>(0); 3043+ return en; 3044+ } 3045+ } else { 3046+ ActivationType en = static_cast<ActivationType>(0); 3047+ return en; 3048+ } 3049+} 3050+ 3051+void MindIR_GenOP_SetActivationType(PrimitivePtr *primitive, ActivationType activation_type) { 3052+ if (primitive != nullptr && *primitive != nullptr) { 3053+ auto prim = static_cast<schema::Primitive *>(*primitive); 3054+ auto value = prim->value_as_GenOP(); 3055+ if (prim != nullptr && value != nullptr) { 3056+ flatbuffers::FlatBufferBuilder fbb; 3057+ auto ops_offset = schema::CreateGenOP(fbb, static_cast<schema::ActivationType>(activation_type), value->alpha(), value->min_val(), value->max_val(), value->is_training(), static_cast<schema::Format>(value->format()), fbb.CreateVector(value->kernel_size()->data(), value->kernel_size()->size()), fbb.CreateVector(value->stride()->data(), value->stride()->size()), fbb.CreateVector(value->dilation()->data(), value->dilation()->size()), static_cast<schema::PadMode>(value->pad_mode()), fbb.CreateVector(value->pad_list()->data(), value->pad_list()->size()), value->mode(), value->group(), value->in_channel(), value->out_channel(), static_cast<schema::EltwiseMode>(value->eltwise_mode()), value->has_bias(), value->use_axis(), value->axis(), value->epsilon(), value->momentum(), value->transpose_a(), value->transpose_b(), fbb.CreateVector(value->pad()->data(), value->pad()->size()), static_cast<schema::RoundMode>(value->round_mode()), value->global(), value->channel_shared(), fbb.CreateVector(value->axes()->data(), value->axes()->size()), value->keep_dims(), static_cast<schema::ReduceMode>(value->reduce_mode()), value->reduce_to_end(), value->coeff()); 3058+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_GEN_O_P), ops_offset.o); 3059+ fbb.Finish(prim_offset); 3060+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 3061+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 3062+ free(*primitive); 3063+ *primitive = ret_value; 3064+ } 3065+ } 3066+} 3067+ 3068+float MindIR_GenOP_GetAlpha(ConstPrimitivePtr primitive) { 3069+ if (primitive != nullptr) { 3070+ auto prim = static_cast<const schema::Primitive *>(primitive); 3071+ auto value = prim->value_as_GenOP(); 3072+ if (prim != nullptr && value != nullptr) { 3073+ return value->alpha(); 3074+ } else { 3075+ return .0; 3076+ } 3077+ } else { 3078+ return .0; 3079+ } 3080+} 3081+ 3082+void MindIR_GenOP_SetAlpha(PrimitivePtr *primitive, float alpha) { 3083+ if (primitive != nullptr && *primitive != nullptr) { 3084+ auto prim = static_cast<schema::Primitive *>(*primitive); 3085+ auto value = prim->value_as_GenOP(); 3086+ if (prim != nullptr && value != nullptr) { 3087+ flatbuffers::FlatBufferBuilder fbb; 3088+ auto ops_offset = schema::CreateGenOP(fbb, static_cast<schema::ActivationType>(value->activation_type()), alpha, value->min_val(), value->max_val(), value->is_training(), static_cast<schema::Format>(value->format()), fbb.CreateVector(value->kernel_size()->data(), value->kernel_size()->size()), fbb.CreateVector(value->stride()->data(), value->stride()->size()), fbb.CreateVector(value->dilation()->data(), value->dilation()->size()), static_cast<schema::PadMode>(value->pad_mode()), fbb.CreateVector(value->pad_list()->data(), value->pad_list()->size()), value->mode(), value->group(), value->in_channel(), value->out_channel(), static_cast<schema::EltwiseMode>(value->eltwise_mode()), value->has_bias(), value->use_axis(), value->axis(), value->epsilon(), value->momentum(), value->transpose_a(), value->transpose_b(), fbb.CreateVector(value->pad()->data(), value->pad()->size()), static_cast<schema::RoundMode>(value->round_mode()), value->global(), value->channel_shared(), fbb.CreateVector(value->axes()->data(), value->axes()->size()), value->keep_dims(), static_cast<schema::ReduceMode>(value->reduce_mode()), value->reduce_to_end(), value->coeff()); 3089+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_GEN_O_P), ops_offset.o); 3090+ fbb.Finish(prim_offset); 3091+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 3092+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 3093+ free(*primitive); 3094+ *primitive = ret_value; 3095+ } 3096+ } 3097+} 3098+ 3099+float MindIR_GenOP_GetMinVal(ConstPrimitivePtr primitive) { 3100+ if (primitive != nullptr) { 3101+ auto prim = static_cast<const schema::Primitive *>(primitive); 3102+ auto value = prim->value_as_GenOP(); 3103+ if (prim != nullptr && value != nullptr) { 3104+ return value->min_val(); 3105+ } else { 3106+ return .0; 3107+ } 3108+ } else { 3109+ return .0; 3110+ } 3111+} 3112+ 3113+void MindIR_GenOP_SetMinVal(PrimitivePtr *primitive, float min_val) { 3114+ if (primitive != nullptr && *primitive != nullptr) { 3115+ auto prim = static_cast<schema::Primitive *>(*primitive); 3116+ auto value = prim->value_as_GenOP(); 3117+ if (prim != nullptr && value != nullptr) { 3118+ flatbuffers::FlatBufferBuilder fbb; 3119+ auto ops_offset = schema::CreateGenOP(fbb, static_cast<schema::ActivationType>(value->activation_type()), value->alpha(), min_val, value->max_val(), value->is_training(), static_cast<schema::Format>(value->format()), fbb.CreateVector(value->kernel_size()->data(), value->kernel_size()->size()), fbb.CreateVector(value->stride()->data(), value->stride()->size()), fbb.CreateVector(value->dilation()->data(), value->dilation()->size()), static_cast<schema::PadMode>(value->pad_mode()), fbb.CreateVector(value->pad_list()->data(), value->pad_list()->size()), value->mode(), value->group(), value->in_channel(), value->out_channel(), static_cast<schema::EltwiseMode>(value->eltwise_mode()), value->has_bias(), value->use_axis(), value->axis(), value->epsilon(), value->momentum(), value->transpose_a(), value->transpose_b(), fbb.CreateVector(value->pad()->data(), value->pad()->size()), static_cast<schema::RoundMode>(value->round_mode()), value->global(), value->channel_shared(), fbb.CreateVector(value->axes()->data(), value->axes()->size()), value->keep_dims(), static_cast<schema::ReduceMode>(value->reduce_mode()), value->reduce_to_end(), value->coeff()); 3120+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_GEN_O_P), ops_offset.o); 3121+ fbb.Finish(prim_offset); 3122+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 3123+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 3124+ free(*primitive); 3125+ *primitive = ret_value; 3126+ } 3127+ } 3128+} 3129+ 3130+float MindIR_GenOP_GetMaxVal(ConstPrimitivePtr primitive) { 3131+ if (primitive != nullptr) { 3132+ auto prim = static_cast<const schema::Primitive *>(primitive); 3133+ auto value = prim->value_as_GenOP(); 3134+ if (prim != nullptr && value != nullptr) { 3135+ return value->max_val(); 3136+ } else { 3137+ return .0; 3138+ } 3139+ } else { 3140+ return .0; 3141+ } 3142+} 3143+ 3144+void MindIR_GenOP_SetMaxVal(PrimitivePtr *primitive, float max_val) { 3145+ if (primitive != nullptr && *primitive != nullptr) { 3146+ auto prim = static_cast<schema::Primitive *>(*primitive); 3147+ auto value = prim->value_as_GenOP(); 3148+ if (prim != nullptr && value != nullptr) { 3149+ flatbuffers::FlatBufferBuilder fbb; 3150+ auto ops_offset = schema::CreateGenOP(fbb, static_cast<schema::ActivationType>(value->activation_type()), value->alpha(), value->min_val(), max_val, value->is_training(), static_cast<schema::Format>(value->format()), fbb.CreateVector(value->kernel_size()->data(), value->kernel_size()->size()), fbb.CreateVector(value->stride()->data(), value->stride()->size()), fbb.CreateVector(value->dilation()->data(), value->dilation()->size()), static_cast<schema::PadMode>(value->pad_mode()), fbb.CreateVector(value->pad_list()->data(), value->pad_list()->size()), value->mode(), value->group(), value->in_channel(), value->out_channel(), static_cast<schema::EltwiseMode>(value->eltwise_mode()), value->has_bias(), value->use_axis(), value->axis(), value->epsilon(), value->momentum(), value->transpose_a(), value->transpose_b(), fbb.CreateVector(value->pad()->data(), value->pad()->size()), static_cast<schema::RoundMode>(value->round_mode()), value->global(), value->channel_shared(), fbb.CreateVector(value->axes()->data(), value->axes()->size()), value->keep_dims(), static_cast<schema::ReduceMode>(value->reduce_mode()), value->reduce_to_end(), value->coeff()); 3151+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_GEN_O_P), ops_offset.o); 3152+ fbb.Finish(prim_offset); 3153+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 3154+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 3155+ free(*primitive); 3156+ *primitive = ret_value; 3157+ } 3158+ } 3159+} 3160+ 3161+bool MindIR_GenOP_GetIsTraining(ConstPrimitivePtr primitive) { 3162+ if (primitive != nullptr) { 3163+ auto prim = static_cast<const schema::Primitive *>(primitive); 3164+ auto value = prim->value_as_GenOP(); 3165+ if (prim != nullptr && value != nullptr) { 3166+ return value->is_training(); 3167+ } else { 3168+ return false; 3169+ } 3170+ } else { 3171+ return false; 3172+ } 3173+} 3174+ 3175+void MindIR_GenOP_SetIsTraining(PrimitivePtr *primitive, bool is_training) { 3176+ if (primitive != nullptr && *primitive != nullptr) { 3177+ auto prim = static_cast<schema::Primitive *>(*primitive); 3178+ auto value = prim->value_as_GenOP(); 3179+ if (prim != nullptr && value != nullptr) { 3180+ flatbuffers::FlatBufferBuilder fbb; 3181+ auto ops_offset = schema::CreateGenOP(fbb, static_cast<schema::ActivationType>(value->activation_type()), value->alpha(), value->min_val(), value->max_val(), is_training, static_cast<schema::Format>(value->format()), fbb.CreateVector(value->kernel_size()->data(), value->kernel_size()->size()), fbb.CreateVector(value->stride()->data(), value->stride()->size()), fbb.CreateVector(value->dilation()->data(), value->dilation()->size()), static_cast<schema::PadMode>(value->pad_mode()), fbb.CreateVector(value->pad_list()->data(), value->pad_list()->size()), value->mode(), value->group(), value->in_channel(), value->out_channel(), static_cast<schema::EltwiseMode>(value->eltwise_mode()), value->has_bias(), value->use_axis(), value->axis(), value->epsilon(), value->momentum(), value->transpose_a(), value->transpose_b(), fbb.CreateVector(value->pad()->data(), value->pad()->size()), static_cast<schema::RoundMode>(value->round_mode()), value->global(), value->channel_shared(), fbb.CreateVector(value->axes()->data(), value->axes()->size()), value->keep_dims(), static_cast<schema::ReduceMode>(value->reduce_mode()), value->reduce_to_end(), value->coeff()); 3182+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_GEN_O_P), ops_offset.o); 3183+ fbb.Finish(prim_offset); 3184+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 3185+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 3186+ free(*primitive); 3187+ *primitive = ret_value; 3188+ } 3189+ } 3190+} 3191+ 3192+Format MindIR_GenOP_GetFormat(ConstPrimitivePtr primitive) { 3193+ if (primitive != nullptr) { 3194+ auto prim = static_cast<const schema::Primitive *>(primitive); 3195+ auto value = prim->value_as_GenOP(); 3196+ if (prim != nullptr && value != nullptr) { 3197+ return static_cast<Format>(value->format()); 3198+ } else { 3199+ Format en = static_cast<Format>(0); 3200+ return en; 3201+ } 3202+ } else { 3203+ Format en = static_cast<Format>(0); 3204+ return en; 3205+ } 3206+} 3207+ 3208+void MindIR_GenOP_SetFormat(PrimitivePtr *primitive, Format format) { 3209+ if (primitive != nullptr && *primitive != nullptr) { 3210+ auto prim = static_cast<schema::Primitive *>(*primitive); 3211+ auto value = prim->value_as_GenOP(); 3212+ if (prim != nullptr && value != nullptr) { 3213+ flatbuffers::FlatBufferBuilder fbb; 3214+ auto ops_offset = schema::CreateGenOP(fbb, static_cast<schema::ActivationType>(value->activation_type()), value->alpha(), value->min_val(), value->max_val(), value->is_training(), static_cast<schema::Format>(format), fbb.CreateVector(value->kernel_size()->data(), value->kernel_size()->size()), fbb.CreateVector(value->stride()->data(), value->stride()->size()), fbb.CreateVector(value->dilation()->data(), value->dilation()->size()), static_cast<schema::PadMode>(value->pad_mode()), fbb.CreateVector(value->pad_list()->data(), value->pad_list()->size()), value->mode(), value->group(), value->in_channel(), value->out_channel(), static_cast<schema::EltwiseMode>(value->eltwise_mode()), value->has_bias(), value->use_axis(), value->axis(), value->epsilon(), value->momentum(), value->transpose_a(), value->transpose_b(), fbb.CreateVector(value->pad()->data(), value->pad()->size()), static_cast<schema::RoundMode>(value->round_mode()), value->global(), value->channel_shared(), fbb.CreateVector(value->axes()->data(), value->axes()->size()), value->keep_dims(), static_cast<schema::ReduceMode>(value->reduce_mode()), value->reduce_to_end(), value->coeff()); 3215+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_GEN_O_P), ops_offset.o); 3216+ fbb.Finish(prim_offset); 3217+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 3218+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 3219+ free(*primitive); 3220+ *primitive = ret_value; 3221+ } 3222+ } 3223+} 3224+ 3225+std::vector<int64_t> MindIR_GenOP_GetKernelSize(ConstPrimitivePtr primitive) { 3226+ if (primitive != nullptr) { 3227+ auto prim = static_cast<const schema::Primitive *>(primitive); 3228+ auto value = prim->value_as_GenOP(); 3229+ if (prim != nullptr && value != nullptr) { 3230+ std::vector<int64_t> result; 3231+ auto src = value->kernel_size(); 3232+ if (src == nullptr) { 3233+ return {}; 3234+ } 3235+ result.resize(src->size()); 3236+ std::transform(src->begin(), src->end(), result.begin(), [](int64_t item) { return item; }); 3237+ return result; 3238+ } else { 3239+ return {}; 3240+ } 3241+ } else { 3242+ return {}; 3243+ } 3244+} 3245+ 3246+void MindIR_GenOP_SetKernelSize(PrimitivePtr *primitive, const std::vector<int64_t> &kernel_size) { 3247+ if (primitive != nullptr && *primitive != nullptr) { 3248+ auto prim = static_cast<schema::Primitive *>(*primitive); 3249+ auto value = prim->value_as_GenOP(); 3250+ if (prim != nullptr && value != nullptr) { 3251+ flatbuffers::FlatBufferBuilder fbb; 3252+ auto ops_offset = schema::CreateGenOP(fbb, static_cast<schema::ActivationType>(value->activation_type()), value->alpha(), value->min_val(), value->max_val(), value->is_training(), static_cast<schema::Format>(value->format()), fbb.CreateVector(kernel_size.data(), kernel_size.size()), fbb.CreateVector(value->stride()->data(), value->stride()->size()), fbb.CreateVector(value->dilation()->data(), value->dilation()->size()), static_cast<schema::PadMode>(value->pad_mode()), fbb.CreateVector(value->pad_list()->data(), value->pad_list()->size()), value->mode(), value->group(), value->in_channel(), value->out_channel(), static_cast<schema::EltwiseMode>(value->eltwise_mode()), value->has_bias(), value->use_axis(), value->axis(), value->epsilon(), value->momentum(), value->transpose_a(), value->transpose_b(), fbb.CreateVector(value->pad()->data(), value->pad()->size()), static_cast<schema::RoundMode>(value->round_mode()), value->global(), value->channel_shared(), fbb.CreateVector(value->axes()->data(), value->axes()->size()), value->keep_dims(), static_cast<schema::ReduceMode>(value->reduce_mode()), value->reduce_to_end(), value->coeff()); 3253+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_GEN_O_P), ops_offset.o); 3254+ fbb.Finish(prim_offset); 3255+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 3256+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 3257+ free(*primitive); 3258+ *primitive = ret_value; 3259+ } 3260+ } 3261+} 3262+ 3263+std::vector<int64_t> MindIR_GenOP_GetStride(ConstPrimitivePtr primitive) { 3264+ if (primitive != nullptr) { 3265+ auto prim = static_cast<const schema::Primitive *>(primitive); 3266+ auto value = prim->value_as_GenOP(); 3267+ if (prim != nullptr && value != nullptr) { 3268+ std::vector<int64_t> result; 3269+ auto src = value->stride(); 3270+ if (src == nullptr) { 3271+ return {}; 3272+ } 3273+ result.resize(src->size()); 3274+ std::transform(src->begin(), src->end(), result.begin(), [](int64_t item) { return item; }); 3275+ return result; 3276+ } else { 3277+ return {}; 3278+ } 3279+ } else { 3280+ return {}; 3281+ } 3282+} 3283+ 3284+void MindIR_GenOP_SetStride(PrimitivePtr *primitive, const std::vector<int64_t> &stride) { 3285+ if (primitive != nullptr && *primitive != nullptr) { 3286+ auto prim = static_cast<schema::Primitive *>(*primitive); 3287+ auto value = prim->value_as_GenOP(); 3288+ if (prim != nullptr && value != nullptr) { 3289+ flatbuffers::FlatBufferBuilder fbb; 3290+ auto ops_offset = schema::CreateGenOP(fbb, static_cast<schema::ActivationType>(value->activation_type()), value->alpha(), value->min_val(), value->max_val(), value->is_training(), static_cast<schema::Format>(value->format()), fbb.CreateVector(value->kernel_size()->data(), value->kernel_size()->size()), fbb.CreateVector(stride.data(), stride.size()), fbb.CreateVector(value->dilation()->data(), value->dilation()->size()), static_cast<schema::PadMode>(value->pad_mode()), fbb.CreateVector(value->pad_list()->data(), value->pad_list()->size()), value->mode(), value->group(), value->in_channel(), value->out_channel(), static_cast<schema::EltwiseMode>(value->eltwise_mode()), value->has_bias(), value->use_axis(), value->axis(), value->epsilon(), value->momentum(), value->transpose_a(), value->transpose_b(), fbb.CreateVector(value->pad()->data(), value->pad()->size()), static_cast<schema::RoundMode>(value->round_mode()), value->global(), value->channel_shared(), fbb.CreateVector(value->axes()->data(), value->axes()->size()), value->keep_dims(), static_cast<schema::ReduceMode>(value->reduce_mode()), value->reduce_to_end(), value->coeff()); 3291+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_GEN_O_P), ops_offset.o); 3292+ fbb.Finish(prim_offset); 3293+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 3294+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 3295+ free(*primitive); 3296+ *primitive = ret_value; 3297+ } 3298+ } 3299+} 3300+ 3301+std::vector<int64_t> MindIR_GenOP_GetDilation(ConstPrimitivePtr primitive) { 3302+ if (primitive != nullptr) { 3303+ auto prim = static_cast<const schema::Primitive *>(primitive); 3304+ auto value = prim->value_as_GenOP(); 3305+ if (prim != nullptr && value != nullptr) { 3306+ std::vector<int64_t> result; 3307+ auto src = value->dilation(); 3308+ if (src == nullptr) { 3309+ return {}; 3310+ } 3311+ result.resize(src->size()); 3312+ std::transform(src->begin(), src->end(), result.begin(), [](int64_t item) { return item; }); 3313+ return result; 3314+ } else { 3315+ return {}; 3316+ } 3317+ } else { 3318+ return {}; 3319+ } 3320+} 3321+ 3322+void MindIR_GenOP_SetDilation(PrimitivePtr *primitive, const std::vector<int64_t> &dilation) { 3323+ if (primitive != nullptr && *primitive != nullptr) { 3324+ auto prim = static_cast<schema::Primitive *>(*primitive); 3325+ auto value = prim->value_as_GenOP(); 3326+ if (prim != nullptr && value != nullptr) { 3327+ flatbuffers::FlatBufferBuilder fbb; 3328+ auto ops_offset = schema::CreateGenOP(fbb, static_cast<schema::ActivationType>(value->activation_type()), value->alpha(), value->min_val(), value->max_val(), value->is_training(), static_cast<schema::Format>(value->format()), fbb.CreateVector(value->kernel_size()->data(), value->kernel_size()->size()), fbb.CreateVector(value->stride()->data(), value->stride()->size()), fbb.CreateVector(dilation.data(), dilation.size()), static_cast<schema::PadMode>(value->pad_mode()), fbb.CreateVector(value->pad_list()->data(), value->pad_list()->size()), value->mode(), value->group(), value->in_channel(), value->out_channel(), static_cast<schema::EltwiseMode>(value->eltwise_mode()), value->has_bias(), value->use_axis(), value->axis(), value->epsilon(), value->momentum(), value->transpose_a(), value->transpose_b(), fbb.CreateVector(value->pad()->data(), value->pad()->size()), static_cast<schema::RoundMode>(value->round_mode()), value->global(), value->channel_shared(), fbb.CreateVector(value->axes()->data(), value->axes()->size()), value->keep_dims(), static_cast<schema::ReduceMode>(value->reduce_mode()), value->reduce_to_end(), value->coeff()); 3329+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_GEN_O_P), ops_offset.o); 3330+ fbb.Finish(prim_offset); 3331+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 3332+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 3333+ free(*primitive); 3334+ *primitive = ret_value; 3335+ } 3336+ } 3337+} 3338+ 3339+PadMode MindIR_GenOP_GetPadMode(ConstPrimitivePtr primitive) { 3340+ if (primitive != nullptr) { 3341+ auto prim = static_cast<const schema::Primitive *>(primitive); 3342+ auto value = prim->value_as_GenOP(); 3343+ if (prim != nullptr && value != nullptr) { 3344+ return static_cast<PadMode>(value->pad_mode()); 3345+ } else { 3346+ PadMode en = static_cast<PadMode>(0); 3347+ return en; 3348+ } 3349+ } else { 3350+ PadMode en = static_cast<PadMode>(0); 3351+ return en; 3352+ } 3353+} 3354+ 3355+void MindIR_GenOP_SetPadMode(PrimitivePtr *primitive, PadMode pad_mode) { 3356+ if (primitive != nullptr && *primitive != nullptr) { 3357+ auto prim = static_cast<schema::Primitive *>(*primitive); 3358+ auto value = prim->value_as_GenOP(); 3359+ if (prim != nullptr && value != nullptr) { 3360+ flatbuffers::FlatBufferBuilder fbb; 3361+ auto ops_offset = schema::CreateGenOP(fbb, static_cast<schema::ActivationType>(value->activation_type()), value->alpha(), value->min_val(), value->max_val(), value->is_training(), static_cast<schema::Format>(value->format()), fbb.CreateVector(value->kernel_size()->data(), value->kernel_size()->size()), fbb.CreateVector(value->stride()->data(), value->stride()->size()), fbb.CreateVector(value->dilation()->data(), value->dilation()->size()), static_cast<schema::PadMode>(pad_mode), fbb.CreateVector(value->pad_list()->data(), value->pad_list()->size()), value->mode(), value->group(), value->in_channel(), value->out_channel(), static_cast<schema::EltwiseMode>(value->eltwise_mode()), value->has_bias(), value->use_axis(), value->axis(), value->epsilon(), value->momentum(), value->transpose_a(), value->transpose_b(), fbb.CreateVector(value->pad()->data(), value->pad()->size()), static_cast<schema::RoundMode>(value->round_mode()), value->global(), value->channel_shared(), fbb.CreateVector(value->axes()->data(), value->axes()->size()), value->keep_dims(), static_cast<schema::ReduceMode>(value->reduce_mode()), value->reduce_to_end(), value->coeff()); 3362+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_GEN_O_P), ops_offset.o); 3363+ fbb.Finish(prim_offset); 3364+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 3365+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 3366+ free(*primitive); 3367+ *primitive = ret_value; 3368+ } 3369+ } 3370+} 3371+ 3372+std::vector<int64_t> MindIR_GenOP_GetPadList(ConstPrimitivePtr primitive) { 3373+ if (primitive != nullptr) { 3374+ auto prim = static_cast<const schema::Primitive *>(primitive); 3375+ auto value = prim->value_as_GenOP(); 3376+ if (prim != nullptr && value != nullptr) { 3377+ std::vector<int64_t> result; 3378+ auto src = value->pad_list(); 3379+ if (src == nullptr) { 3380+ return {}; 3381+ } 3382+ result.resize(src->size()); 3383+ std::transform(src->begin(), src->end(), result.begin(), [](int64_t item) { return item; }); 3384+ return result; 3385+ } else { 3386+ return {}; 3387+ } 3388+ } else { 3389+ return {}; 3390+ } 3391+} 3392+ 3393+void MindIR_GenOP_SetPadList(PrimitivePtr *primitive, const std::vector<int64_t> &pad_list) { 3394+ if (primitive != nullptr && *primitive != nullptr) { 3395+ auto prim = static_cast<schema::Primitive *>(*primitive); 3396+ auto value = prim->value_as_GenOP(); 3397+ if (prim != nullptr && value != nullptr) { 3398+ flatbuffers::FlatBufferBuilder fbb; 3399+ auto ops_offset = schema::CreateGenOP(fbb, static_cast<schema::ActivationType>(value->activation_type()), value->alpha(), value->min_val(), value->max_val(), value->is_training(), static_cast<schema::Format>(value->format()), fbb.CreateVector(value->kernel_size()->data(), value->kernel_size()->size()), fbb.CreateVector(value->stride()->data(), value->stride()->size()), fbb.CreateVector(value->dilation()->data(), value->dilation()->size()), static_cast<schema::PadMode>(value->pad_mode()), fbb.CreateVector(pad_list.data(), pad_list.size()), value->mode(), value->group(), value->in_channel(), value->out_channel(), static_cast<schema::EltwiseMode>(value->eltwise_mode()), value->has_bias(), value->use_axis(), value->axis(), value->epsilon(), value->momentum(), value->transpose_a(), value->transpose_b(), fbb.CreateVector(value->pad()->data(), value->pad()->size()), static_cast<schema::RoundMode>(value->round_mode()), value->global(), value->channel_shared(), fbb.CreateVector(value->axes()->data(), value->axes()->size()), value->keep_dims(), static_cast<schema::ReduceMode>(value->reduce_mode()), value->reduce_to_end(), value->coeff()); 3400+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_GEN_O_P), ops_offset.o); 3401+ fbb.Finish(prim_offset); 3402+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 3403+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 3404+ free(*primitive); 3405+ *primitive = ret_value; 3406+ } 3407+ } 3408+} 3409+ 3410+int64_t MindIR_GenOP_GetMode(ConstPrimitivePtr primitive) { 3411+ if (primitive != nullptr) { 3412+ auto prim = static_cast<const schema::Primitive *>(primitive); 3413+ auto value = prim->value_as_GenOP(); 3414+ if (prim != nullptr && value != nullptr) { 3415+ return value->mode(); 3416+ } else { 3417+ return 0; 3418+ } 3419+ } else { 3420+ return 0; 3421+ } 3422+} 3423+ 3424+void MindIR_GenOP_SetMode(PrimitivePtr *primitive, int64_t mode) { 3425+ if (primitive != nullptr && *primitive != nullptr) { 3426+ auto prim = static_cast<schema::Primitive *>(*primitive); 3427+ auto value = prim->value_as_GenOP(); 3428+ if (prim != nullptr && value != nullptr) { 3429+ flatbuffers::FlatBufferBuilder fbb; 3430+ auto ops_offset = schema::CreateGenOP(fbb, static_cast<schema::ActivationType>(value->activation_type()), value->alpha(), value->min_val(), value->max_val(), value->is_training(), static_cast<schema::Format>(value->format()), fbb.CreateVector(value->kernel_size()->data(), value->kernel_size()->size()), fbb.CreateVector(value->stride()->data(), value->stride()->size()), fbb.CreateVector(value->dilation()->data(), value->dilation()->size()), static_cast<schema::PadMode>(value->pad_mode()), fbb.CreateVector(value->pad_list()->data(), value->pad_list()->size()), mode, value->group(), value->in_channel(), value->out_channel(), static_cast<schema::EltwiseMode>(value->eltwise_mode()), value->has_bias(), value->use_axis(), value->axis(), value->epsilon(), value->momentum(), value->transpose_a(), value->transpose_b(), fbb.CreateVector(value->pad()->data(), value->pad()->size()), static_cast<schema::RoundMode>(value->round_mode()), value->global(), value->channel_shared(), fbb.CreateVector(value->axes()->data(), value->axes()->size()), value->keep_dims(), static_cast<schema::ReduceMode>(value->reduce_mode()), value->reduce_to_end(), value->coeff()); 3431+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_GEN_O_P), ops_offset.o); 3432+ fbb.Finish(prim_offset); 3433+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 3434+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 3435+ free(*primitive); 3436+ *primitive = ret_value; 3437+ } 3438+ } 3439+} 3440+ 3441+int64_t MindIR_GenOP_GetGroup(ConstPrimitivePtr primitive) { 3442+ if (primitive != nullptr) { 3443+ auto prim = static_cast<const schema::Primitive *>(primitive); 3444+ auto value = prim->value_as_GenOP(); 3445+ if (prim != nullptr && value != nullptr) { 3446+ return value->group(); 3447+ } else { 3448+ return 0; 3449+ } 3450+ } else { 3451+ return 0; 3452+ } 3453+} 3454+ 3455+void MindIR_GenOP_SetGroup(PrimitivePtr *primitive, int64_t group) { 3456+ if (primitive != nullptr && *primitive != nullptr) { 3457+ auto prim = static_cast<schema::Primitive *>(*primitive); 3458+ auto value = prim->value_as_GenOP(); 3459+ if (prim != nullptr && value != nullptr) { 3460+ flatbuffers::FlatBufferBuilder fbb; 3461+ auto ops_offset = schema::CreateGenOP(fbb, static_cast<schema::ActivationType>(value->activation_type()), value->alpha(), value->min_val(), value->max_val(), value->is_training(), static_cast<schema::Format>(value->format()), fbb.CreateVector(value->kernel_size()->data(), value->kernel_size()->size()), fbb.CreateVector(value->stride()->data(), value->stride()->size()), fbb.CreateVector(value->dilation()->data(), value->dilation()->size()), static_cast<schema::PadMode>(value->pad_mode()), fbb.CreateVector(value->pad_list()->data(), value->pad_list()->size()), value->mode(), group, value->in_channel(), value->out_channel(), static_cast<schema::EltwiseMode>(value->eltwise_mode()), value->has_bias(), value->use_axis(), value->axis(), value->epsilon(), value->momentum(), value->transpose_a(), value->transpose_b(), fbb.CreateVector(value->pad()->data(), value->pad()->size()), static_cast<schema::RoundMode>(value->round_mode()), value->global(), value->channel_shared(), fbb.CreateVector(value->axes()->data(), value->axes()->size()), value->keep_dims(), static_cast<schema::ReduceMode>(value->reduce_mode()), value->reduce_to_end(), value->coeff()); 3462+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_GEN_O_P), ops_offset.o); 3463+ fbb.Finish(prim_offset); 3464+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 3465+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 3466+ free(*primitive); 3467+ *primitive = ret_value; 3468+ } 3469+ } 3470+} 3471+ 3472+int64_t MindIR_GenOP_GetInChannel(ConstPrimitivePtr primitive) { 3473+ if (primitive != nullptr) { 3474+ auto prim = static_cast<const schema::Primitive *>(primitive); 3475+ auto value = prim->value_as_GenOP(); 3476+ if (prim != nullptr && value != nullptr) { 3477+ return value->in_channel(); 3478+ } else { 3479+ return 0; 3480+ } 3481+ } else { 3482+ return 0; 3483+ } 3484+} 3485+ 3486+void MindIR_GenOP_SetInChannel(PrimitivePtr *primitive, int64_t in_channel) { 3487+ if (primitive != nullptr && *primitive != nullptr) { 3488+ auto prim = static_cast<schema::Primitive *>(*primitive); 3489+ auto value = prim->value_as_GenOP(); 3490+ if (prim != nullptr && value != nullptr) { 3491+ flatbuffers::FlatBufferBuilder fbb; 3492+ auto ops_offset = schema::CreateGenOP(fbb, static_cast<schema::ActivationType>(value->activation_type()), value->alpha(), value->min_val(), value->max_val(), value->is_training(), static_cast<schema::Format>(value->format()), fbb.CreateVector(value->kernel_size()->data(), value->kernel_size()->size()), fbb.CreateVector(value->stride()->data(), value->stride()->size()), fbb.CreateVector(value->dilation()->data(), value->dilation()->size()), static_cast<schema::PadMode>(value->pad_mode()), fbb.CreateVector(value->pad_list()->data(), value->pad_list()->size()), value->mode(), value->group(), in_channel, value->out_channel(), static_cast<schema::EltwiseMode>(value->eltwise_mode()), value->has_bias(), value->use_axis(), value->axis(), value->epsilon(), value->momentum(), value->transpose_a(), value->transpose_b(), fbb.CreateVector(value->pad()->data(), value->pad()->size()), static_cast<schema::RoundMode>(value->round_mode()), value->global(), value->channel_shared(), fbb.CreateVector(value->axes()->data(), value->axes()->size()), value->keep_dims(), static_cast<schema::ReduceMode>(value->reduce_mode()), value->reduce_to_end(), value->coeff()); 3493+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_GEN_O_P), ops_offset.o); 3494+ fbb.Finish(prim_offset); 3495+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 3496+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 3497+ free(*primitive); 3498+ *primitive = ret_value; 3499+ } 3500+ } 3501+} 3502+ 3503+int64_t MindIR_GenOP_GetOutChannel(ConstPrimitivePtr primitive) { 3504+ if (primitive != nullptr) { 3505+ auto prim = static_cast<const schema::Primitive *>(primitive); 3506+ auto value = prim->value_as_GenOP(); 3507+ if (prim != nullptr && value != nullptr) { 3508+ return value->out_channel(); 3509+ } else { 3510+ return 0; 3511+ } 3512+ } else { 3513+ return 0; 3514+ } 3515+} 3516+ 3517+void MindIR_GenOP_SetOutChannel(PrimitivePtr *primitive, int64_t out_channel) { 3518+ if (primitive != nullptr && *primitive != nullptr) { 3519+ auto prim = static_cast<schema::Primitive *>(*primitive); 3520+ auto value = prim->value_as_GenOP(); 3521+ if (prim != nullptr && value != nullptr) { 3522+ flatbuffers::FlatBufferBuilder fbb; 3523+ auto ops_offset = schema::CreateGenOP(fbb, static_cast<schema::ActivationType>(value->activation_type()), value->alpha(), value->min_val(), value->max_val(), value->is_training(), static_cast<schema::Format>(value->format()), fbb.CreateVector(value->kernel_size()->data(), value->kernel_size()->size()), fbb.CreateVector(value->stride()->data(), value->stride()->size()), fbb.CreateVector(value->dilation()->data(), value->dilation()->size()), static_cast<schema::PadMode>(value->pad_mode()), fbb.CreateVector(value->pad_list()->data(), value->pad_list()->size()), value->mode(), value->group(), value->in_channel(), out_channel, static_cast<schema::EltwiseMode>(value->eltwise_mode()), value->has_bias(), value->use_axis(), value->axis(), value->epsilon(), value->momentum(), value->transpose_a(), value->transpose_b(), fbb.CreateVector(value->pad()->data(), value->pad()->size()), static_cast<schema::RoundMode>(value->round_mode()), value->global(), value->channel_shared(), fbb.CreateVector(value->axes()->data(), value->axes()->size()), value->keep_dims(), static_cast<schema::ReduceMode>(value->reduce_mode()), value->reduce_to_end(), value->coeff()); 3524+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_GEN_O_P), ops_offset.o); 3525+ fbb.Finish(prim_offset); 3526+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 3527+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 3528+ free(*primitive); 3529+ *primitive = ret_value; 3530+ } 3531+ } 3532+} 3533+ 3534+EltwiseMode MindIR_GenOP_GetEltwiseMode(ConstPrimitivePtr primitive) { 3535+ if (primitive != nullptr) { 3536+ auto prim = static_cast<const schema::Primitive *>(primitive); 3537+ auto value = prim->value_as_GenOP(); 3538+ if (prim != nullptr && value != nullptr) { 3539+ return static_cast<EltwiseMode>(value->eltwise_mode()); 3540+ } else { 3541+ EltwiseMode en = static_cast<EltwiseMode>(0); 3542+ return en; 3543+ } 3544+ } else { 3545+ EltwiseMode en = static_cast<EltwiseMode>(0); 3546+ return en; 3547+ } 3548+} 3549+ 3550+void MindIR_GenOP_SetEltwiseMode(PrimitivePtr *primitive, EltwiseMode eltwise_mode) { 3551+ if (primitive != nullptr && *primitive != nullptr) { 3552+ auto prim = static_cast<schema::Primitive *>(*primitive); 3553+ auto value = prim->value_as_GenOP(); 3554+ if (prim != nullptr && value != nullptr) { 3555+ flatbuffers::FlatBufferBuilder fbb; 3556+ auto ops_offset = schema::CreateGenOP(fbb, static_cast<schema::ActivationType>(value->activation_type()), value->alpha(), value->min_val(), value->max_val(), value->is_training(), static_cast<schema::Format>(value->format()), fbb.CreateVector(value->kernel_size()->data(), value->kernel_size()->size()), fbb.CreateVector(value->stride()->data(), value->stride()->size()), fbb.CreateVector(value->dilation()->data(), value->dilation()->size()), static_cast<schema::PadMode>(value->pad_mode()), fbb.CreateVector(value->pad_list()->data(), value->pad_list()->size()), value->mode(), value->group(), value->in_channel(), value->out_channel(), static_cast<schema::EltwiseMode>(eltwise_mode), value->has_bias(), value->use_axis(), value->axis(), value->epsilon(), value->momentum(), value->transpose_a(), value->transpose_b(), fbb.CreateVector(value->pad()->data(), value->pad()->size()), static_cast<schema::RoundMode>(value->round_mode()), value->global(), value->channel_shared(), fbb.CreateVector(value->axes()->data(), value->axes()->size()), value->keep_dims(), static_cast<schema::ReduceMode>(value->reduce_mode()), value->reduce_to_end(), value->coeff()); 3557+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_GEN_O_P), ops_offset.o); 3558+ fbb.Finish(prim_offset); 3559+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 3560+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 3561+ free(*primitive); 3562+ *primitive = ret_value; 3563+ } 3564+ } 3565+} 3566+ 3567+bool MindIR_GenOP_GetHasBias(ConstPrimitivePtr primitive) { 3568+ if (primitive != nullptr) { 3569+ auto prim = static_cast<const schema::Primitive *>(primitive); 3570+ auto value = prim->value_as_GenOP(); 3571+ if (prim != nullptr && value != nullptr) { 3572+ return value->has_bias(); 3573+ } else { 3574+ return false; 3575+ } 3576+ } else { 3577+ return false; 3578+ } 3579+} 3580+ 3581+void MindIR_GenOP_SetHasBias(PrimitivePtr *primitive, bool has_bias) { 3582+ if (primitive != nullptr && *primitive != nullptr) { 3583+ auto prim = static_cast<schema::Primitive *>(*primitive); 3584+ auto value = prim->value_as_GenOP(); 3585+ if (prim != nullptr && value != nullptr) { 3586+ flatbuffers::FlatBufferBuilder fbb; 3587+ auto ops_offset = schema::CreateGenOP(fbb, static_cast<schema::ActivationType>(value->activation_type()), value->alpha(), value->min_val(), value->max_val(), value->is_training(), static_cast<schema::Format>(value->format()), fbb.CreateVector(value->kernel_size()->data(), value->kernel_size()->size()), fbb.CreateVector(value->stride()->data(), value->stride()->size()), fbb.CreateVector(value->dilation()->data(), value->dilation()->size()), static_cast<schema::PadMode>(value->pad_mode()), fbb.CreateVector(value->pad_list()->data(), value->pad_list()->size()), value->mode(), value->group(), value->in_channel(), value->out_channel(), static_cast<schema::EltwiseMode>(value->eltwise_mode()), has_bias, value->use_axis(), value->axis(), value->epsilon(), value->momentum(), value->transpose_a(), value->transpose_b(), fbb.CreateVector(value->pad()->data(), value->pad()->size()), static_cast<schema::RoundMode>(value->round_mode()), value->global(), value->channel_shared(), fbb.CreateVector(value->axes()->data(), value->axes()->size()), value->keep_dims(), static_cast<schema::ReduceMode>(value->reduce_mode()), value->reduce_to_end(), value->coeff()); 3588+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_GEN_O_P), ops_offset.o); 3589+ fbb.Finish(prim_offset); 3590+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 3591+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 3592+ free(*primitive); 3593+ *primitive = ret_value; 3594+ } 3595+ } 3596+} 3597+ 3598+bool MindIR_GenOP_GetUseAxis(ConstPrimitivePtr primitive) { 3599+ if (primitive != nullptr) { 3600+ auto prim = static_cast<const schema::Primitive *>(primitive); 3601+ auto value = prim->value_as_GenOP(); 3602+ if (prim != nullptr && value != nullptr) { 3603+ return value->use_axis(); 3604+ } else { 3605+ return false; 3606+ } 3607+ } else { 3608+ return false; 3609+ } 3610+} 3611+ 3612+void MindIR_GenOP_SetUseAxis(PrimitivePtr *primitive, bool use_axis) { 3613+ if (primitive != nullptr && *primitive != nullptr) { 3614+ auto prim = static_cast<schema::Primitive *>(*primitive); 3615+ auto value = prim->value_as_GenOP(); 3616+ if (prim != nullptr && value != nullptr) { 3617+ flatbuffers::FlatBufferBuilder fbb; 3618+ auto ops_offset = schema::CreateGenOP(fbb, static_cast<schema::ActivationType>(value->activation_type()), value->alpha(), value->min_val(), value->max_val(), value->is_training(), static_cast<schema::Format>(value->format()), fbb.CreateVector(value->kernel_size()->data(), value->kernel_size()->size()), fbb.CreateVector(value->stride()->data(), value->stride()->size()), fbb.CreateVector(value->dilation()->data(), value->dilation()->size()), static_cast<schema::PadMode>(value->pad_mode()), fbb.CreateVector(value->pad_list()->data(), value->pad_list()->size()), value->mode(), value->group(), value->in_channel(), value->out_channel(), static_cast<schema::EltwiseMode>(value->eltwise_mode()), value->has_bias(), use_axis, value->axis(), value->epsilon(), value->momentum(), value->transpose_a(), value->transpose_b(), fbb.CreateVector(value->pad()->data(), value->pad()->size()), static_cast<schema::RoundMode>(value->round_mode()), value->global(), value->channel_shared(), fbb.CreateVector(value->axes()->data(), value->axes()->size()), value->keep_dims(), static_cast<schema::ReduceMode>(value->reduce_mode()), value->reduce_to_end(), value->coeff()); 3619+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_GEN_O_P), ops_offset.o); 3620+ fbb.Finish(prim_offset); 3621+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 3622+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 3623+ free(*primitive); 3624+ *primitive = ret_value; 3625+ } 3626+ } 3627+} 3628+ 3629+int64_t MindIR_GenOP_GetAxis(ConstPrimitivePtr primitive) { 3630+ if (primitive != nullptr) { 3631+ auto prim = static_cast<const schema::Primitive *>(primitive); 3632+ auto value = prim->value_as_GenOP(); 3633+ if (prim != nullptr && value != nullptr) { 3634+ return value->axis(); 3635+ } else { 3636+ return 0; 3637+ } 3638+ } else { 3639+ return 0; 3640+ } 3641+} 3642+ 3643+void MindIR_GenOP_SetAxis(PrimitivePtr *primitive, int64_t axis) { 3644+ if (primitive != nullptr && *primitive != nullptr) { 3645+ auto prim = static_cast<schema::Primitive *>(*primitive); 3646+ auto value = prim->value_as_GenOP(); 3647+ if (prim != nullptr && value != nullptr) { 3648+ flatbuffers::FlatBufferBuilder fbb; 3649+ auto ops_offset = schema::CreateGenOP(fbb, static_cast<schema::ActivationType>(value->activation_type()), value->alpha(), value->min_val(), value->max_val(), value->is_training(), static_cast<schema::Format>(value->format()), fbb.CreateVector(value->kernel_size()->data(), value->kernel_size()->size()), fbb.CreateVector(value->stride()->data(), value->stride()->size()), fbb.CreateVector(value->dilation()->data(), value->dilation()->size()), static_cast<schema::PadMode>(value->pad_mode()), fbb.CreateVector(value->pad_list()->data(), value->pad_list()->size()), value->mode(), value->group(), value->in_channel(), value->out_channel(), static_cast<schema::EltwiseMode>(value->eltwise_mode()), value->has_bias(), value->use_axis(), axis, value->epsilon(), value->momentum(), value->transpose_a(), value->transpose_b(), fbb.CreateVector(value->pad()->data(), value->pad()->size()), static_cast<schema::RoundMode>(value->round_mode()), value->global(), value->channel_shared(), fbb.CreateVector(value->axes()->data(), value->axes()->size()), value->keep_dims(), static_cast<schema::ReduceMode>(value->reduce_mode()), value->reduce_to_end(), value->coeff()); 3650+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_GEN_O_P), ops_offset.o); 3651+ fbb.Finish(prim_offset); 3652+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 3653+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 3654+ free(*primitive); 3655+ *primitive = ret_value; 3656+ } 3657+ } 3658+} 3659+ 3660+float MindIR_GenOP_GetEpsilon(ConstPrimitivePtr primitive) { 3661+ if (primitive != nullptr) { 3662+ auto prim = static_cast<const schema::Primitive *>(primitive); 3663+ auto value = prim->value_as_GenOP(); 3664+ if (prim != nullptr && value != nullptr) { 3665+ return value->epsilon(); 3666+ } else { 3667+ return .0; 3668+ } 3669+ } else { 3670+ return .0; 3671+ } 3672+} 3673+ 3674+void MindIR_GenOP_SetEpsilon(PrimitivePtr *primitive, float epsilon) { 3675+ if (primitive != nullptr && *primitive != nullptr) { 3676+ auto prim = static_cast<schema::Primitive *>(*primitive); 3677+ auto value = prim->value_as_GenOP(); 3678+ if (prim != nullptr && value != nullptr) { 3679+ flatbuffers::FlatBufferBuilder fbb; 3680+ auto ops_offset = schema::CreateGenOP(fbb, static_cast<schema::ActivationType>(value->activation_type()), value->alpha(), value->min_val(), value->max_val(), value->is_training(), static_cast<schema::Format>(value->format()), fbb.CreateVector(value->kernel_size()->data(), value->kernel_size()->size()), fbb.CreateVector(value->stride()->data(), value->stride()->size()), fbb.CreateVector(value->dilation()->data(), value->dilation()->size()), static_cast<schema::PadMode>(value->pad_mode()), fbb.CreateVector(value->pad_list()->data(), value->pad_list()->size()), value->mode(), value->group(), value->in_channel(), value->out_channel(), static_cast<schema::EltwiseMode>(value->eltwise_mode()), value->has_bias(), value->use_axis(), value->axis(), epsilon, value->momentum(), value->transpose_a(), value->transpose_b(), fbb.CreateVector(value->pad()->data(), value->pad()->size()), static_cast<schema::RoundMode>(value->round_mode()), value->global(), value->channel_shared(), fbb.CreateVector(value->axes()->data(), value->axes()->size()), value->keep_dims(), static_cast<schema::ReduceMode>(value->reduce_mode()), value->reduce_to_end(), value->coeff()); 3681+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_GEN_O_P), ops_offset.o); 3682+ fbb.Finish(prim_offset); 3683+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 3684+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 3685+ free(*primitive); 3686+ *primitive = ret_value; 3687+ } 3688+ } 3689+} 3690+ 3691+float MindIR_GenOP_GetMomentum(ConstPrimitivePtr primitive) { 3692+ if (primitive != nullptr) { 3693+ auto prim = static_cast<const schema::Primitive *>(primitive); 3694+ auto value = prim->value_as_GenOP(); 3695+ if (prim != nullptr && value != nullptr) { 3696+ return value->momentum(); 3697+ } else { 3698+ return .0; 3699+ } 3700+ } else { 3701+ return .0; 3702+ } 3703+} 3704+ 3705+void MindIR_GenOP_SetMomentum(PrimitivePtr *primitive, float momentum) { 3706+ if (primitive != nullptr && *primitive != nullptr) { 3707+ auto prim = static_cast<schema::Primitive *>(*primitive); 3708+ auto value = prim->value_as_GenOP(); 3709+ if (prim != nullptr && value != nullptr) { 3710+ flatbuffers::FlatBufferBuilder fbb; 3711+ auto ops_offset = schema::CreateGenOP(fbb, static_cast<schema::ActivationType>(value->activation_type()), value->alpha(), value->min_val(), value->max_val(), value->is_training(), static_cast<schema::Format>(value->format()), fbb.CreateVector(value->kernel_size()->data(), value->kernel_size()->size()), fbb.CreateVector(value->stride()->data(), value->stride()->size()), fbb.CreateVector(value->dilation()->data(), value->dilation()->size()), static_cast<schema::PadMode>(value->pad_mode()), fbb.CreateVector(value->pad_list()->data(), value->pad_list()->size()), value->mode(), value->group(), value->in_channel(), value->out_channel(), static_cast<schema::EltwiseMode>(value->eltwise_mode()), value->has_bias(), value->use_axis(), value->axis(), value->epsilon(), momentum, value->transpose_a(), value->transpose_b(), fbb.CreateVector(value->pad()->data(), value->pad()->size()), static_cast<schema::RoundMode>(value->round_mode()), value->global(), value->channel_shared(), fbb.CreateVector(value->axes()->data(), value->axes()->size()), value->keep_dims(), static_cast<schema::ReduceMode>(value->reduce_mode()), value->reduce_to_end(), value->coeff()); 3712+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_GEN_O_P), ops_offset.o); 3713+ fbb.Finish(prim_offset); 3714+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 3715+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 3716+ free(*primitive); 3717+ *primitive = ret_value; 3718+ } 3719+ } 3720+} 3721+ 3722+bool MindIR_GenOP_GetTransposeA(ConstPrimitivePtr primitive) { 3723+ if (primitive != nullptr) { 3724+ auto prim = static_cast<const schema::Primitive *>(primitive); 3725+ auto value = prim->value_as_GenOP(); 3726+ if (prim != nullptr && value != nullptr) { 3727+ return value->transpose_a(); 3728+ } else { 3729+ return false; 3730+ } 3731+ } else { 3732+ return false; 3733+ } 3734+} 3735+ 3736+void MindIR_GenOP_SetTransposeA(PrimitivePtr *primitive, bool transpose_a) { 3737+ if (primitive != nullptr && *primitive != nullptr) { 3738+ auto prim = static_cast<schema::Primitive *>(*primitive); 3739+ auto value = prim->value_as_GenOP(); 3740+ if (prim != nullptr && value != nullptr) { 3741+ flatbuffers::FlatBufferBuilder fbb; 3742+ auto ops_offset = schema::CreateGenOP(fbb, static_cast<schema::ActivationType>(value->activation_type()), value->alpha(), value->min_val(), value->max_val(), value->is_training(), static_cast<schema::Format>(value->format()), fbb.CreateVector(value->kernel_size()->data(), value->kernel_size()->size()), fbb.CreateVector(value->stride()->data(), value->stride()->size()), fbb.CreateVector(value->dilation()->data(), value->dilation()->size()), static_cast<schema::PadMode>(value->pad_mode()), fbb.CreateVector(value->pad_list()->data(), value->pad_list()->size()), value->mode(), value->group(), value->in_channel(), value->out_channel(), static_cast<schema::EltwiseMode>(value->eltwise_mode()), value->has_bias(), value->use_axis(), value->axis(), value->epsilon(), value->momentum(), transpose_a, value->transpose_b(), fbb.CreateVector(value->pad()->data(), value->pad()->size()), static_cast<schema::RoundMode>(value->round_mode()), value->global(), value->channel_shared(), fbb.CreateVector(value->axes()->data(), value->axes()->size()), value->keep_dims(), static_cast<schema::ReduceMode>(value->reduce_mode()), value->reduce_to_end(), value->coeff()); 3743+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_GEN_O_P), ops_offset.o); 3744+ fbb.Finish(prim_offset); 3745+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 3746+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 3747+ free(*primitive); 3748+ *primitive = ret_value; 3749+ } 3750+ } 3751+} 3752+ 3753+bool MindIR_GenOP_GetTransposeB(ConstPrimitivePtr primitive) { 3754+ if (primitive != nullptr) { 3755+ auto prim = static_cast<const schema::Primitive *>(primitive); 3756+ auto value = prim->value_as_GenOP(); 3757+ if (prim != nullptr && value != nullptr) { 3758+ return value->transpose_b(); 3759+ } else { 3760+ return false; 3761+ } 3762+ } else { 3763+ return false; 3764+ } 3765+} 3766+ 3767+void MindIR_GenOP_SetTransposeB(PrimitivePtr *primitive, bool transpose_b) { 3768+ if (primitive != nullptr && *primitive != nullptr) { 3769+ auto prim = static_cast<schema::Primitive *>(*primitive); 3770+ auto value = prim->value_as_GenOP(); 3771+ if (prim != nullptr && value != nullptr) { 3772+ flatbuffers::FlatBufferBuilder fbb; 3773+ auto ops_offset = schema::CreateGenOP(fbb, static_cast<schema::ActivationType>(value->activation_type()), value->alpha(), value->min_val(), value->max_val(), value->is_training(), static_cast<schema::Format>(value->format()), fbb.CreateVector(value->kernel_size()->data(), value->kernel_size()->size()), fbb.CreateVector(value->stride()->data(), value->stride()->size()), fbb.CreateVector(value->dilation()->data(), value->dilation()->size()), static_cast<schema::PadMode>(value->pad_mode()), fbb.CreateVector(value->pad_list()->data(), value->pad_list()->size()), value->mode(), value->group(), value->in_channel(), value->out_channel(), static_cast<schema::EltwiseMode>(value->eltwise_mode()), value->has_bias(), value->use_axis(), value->axis(), value->epsilon(), value->momentum(), value->transpose_a(), transpose_b, fbb.CreateVector(value->pad()->data(), value->pad()->size()), static_cast<schema::RoundMode>(value->round_mode()), value->global(), value->channel_shared(), fbb.CreateVector(value->axes()->data(), value->axes()->size()), value->keep_dims(), static_cast<schema::ReduceMode>(value->reduce_mode()), value->reduce_to_end(), value->coeff()); 3774+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_GEN_O_P), ops_offset.o); 3775+ fbb.Finish(prim_offset); 3776+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 3777+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 3778+ free(*primitive); 3779+ *primitive = ret_value; 3780+ } 3781+ } 3782+} 3783+ 3784+std::vector<int64_t> MindIR_GenOP_GetPad(ConstPrimitivePtr primitive) { 3785+ if (primitive != nullptr) { 3786+ auto prim = static_cast<const schema::Primitive *>(primitive); 3787+ auto value = prim->value_as_GenOP(); 3788+ if (prim != nullptr && value != nullptr) { 3789+ std::vector<int64_t> result; 3790+ auto src = value->pad(); 3791+ if (src == nullptr) { 3792+ return {}; 3793+ } 3794+ result.resize(src->size()); 3795+ std::transform(src->begin(), src->end(), result.begin(), [](int64_t item) { return item; }); 3796+ return result; 3797+ } else { 3798+ return {}; 3799+ } 3800+ } else { 3801+ return {}; 3802+ } 3803+} 3804+ 3805+void MindIR_GenOP_SetPad(PrimitivePtr *primitive, const std::vector<int64_t> &pad) { 3806+ if (primitive != nullptr && *primitive != nullptr) { 3807+ auto prim = static_cast<schema::Primitive *>(*primitive); 3808+ auto value = prim->value_as_GenOP(); 3809+ if (prim != nullptr && value != nullptr) { 3810+ flatbuffers::FlatBufferBuilder fbb; 3811+ auto ops_offset = schema::CreateGenOP(fbb, static_cast<schema::ActivationType>(value->activation_type()), value->alpha(), value->min_val(), value->max_val(), value->is_training(), static_cast<schema::Format>(value->format()), fbb.CreateVector(value->kernel_size()->data(), value->kernel_size()->size()), fbb.CreateVector(value->stride()->data(), value->stride()->size()), fbb.CreateVector(value->dilation()->data(), value->dilation()->size()), static_cast<schema::PadMode>(value->pad_mode()), fbb.CreateVector(value->pad_list()->data(), value->pad_list()->size()), value->mode(), value->group(), value->in_channel(), value->out_channel(), static_cast<schema::EltwiseMode>(value->eltwise_mode()), value->has_bias(), value->use_axis(), value->axis(), value->epsilon(), value->momentum(), value->transpose_a(), value->transpose_b(), fbb.CreateVector(pad.data(), pad.size()), static_cast<schema::RoundMode>(value->round_mode()), value->global(), value->channel_shared(), fbb.CreateVector(value->axes()->data(), value->axes()->size()), value->keep_dims(), static_cast<schema::ReduceMode>(value->reduce_mode()), value->reduce_to_end(), value->coeff()); 3812+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_GEN_O_P), ops_offset.o); 3813+ fbb.Finish(prim_offset); 3814+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 3815+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 3816+ free(*primitive); 3817+ *primitive = ret_value; 3818+ } 3819+ } 3820+} 3821+ 3822+RoundMode MindIR_GenOP_GetRoundMode(ConstPrimitivePtr primitive) { 3823+ if (primitive != nullptr) { 3824+ auto prim = static_cast<const schema::Primitive *>(primitive); 3825+ auto value = prim->value_as_GenOP(); 3826+ if (prim != nullptr && value != nullptr) { 3827+ return static_cast<RoundMode>(value->round_mode()); 3828+ } else { 3829+ RoundMode en = static_cast<RoundMode>(0); 3830+ return en; 3831+ } 3832+ } else { 3833+ RoundMode en = static_cast<RoundMode>(0); 3834+ return en; 3835+ } 3836+} 3837+ 3838+void MindIR_GenOP_SetRoundMode(PrimitivePtr *primitive, RoundMode round_mode) { 3839+ if (primitive != nullptr && *primitive != nullptr) { 3840+ auto prim = static_cast<schema::Primitive *>(*primitive); 3841+ auto value = prim->value_as_GenOP(); 3842+ if (prim != nullptr && value != nullptr) { 3843+ flatbuffers::FlatBufferBuilder fbb; 3844+ auto ops_offset = schema::CreateGenOP(fbb, static_cast<schema::ActivationType>(value->activation_type()), value->alpha(), value->min_val(), value->max_val(), value->is_training(), static_cast<schema::Format>(value->format()), fbb.CreateVector(value->kernel_size()->data(), value->kernel_size()->size()), fbb.CreateVector(value->stride()->data(), value->stride()->size()), fbb.CreateVector(value->dilation()->data(), value->dilation()->size()), static_cast<schema::PadMode>(value->pad_mode()), fbb.CreateVector(value->pad_list()->data(), value->pad_list()->size()), value->mode(), value->group(), value->in_channel(), value->out_channel(), static_cast<schema::EltwiseMode>(value->eltwise_mode()), value->has_bias(), value->use_axis(), value->axis(), value->epsilon(), value->momentum(), value->transpose_a(), value->transpose_b(), fbb.CreateVector(value->pad()->data(), value->pad()->size()), static_cast<schema::RoundMode>(round_mode), value->global(), value->channel_shared(), fbb.CreateVector(value->axes()->data(), value->axes()->size()), value->keep_dims(), static_cast<schema::ReduceMode>(value->reduce_mode()), value->reduce_to_end(), value->coeff()); 3845+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_GEN_O_P), ops_offset.o); 3846+ fbb.Finish(prim_offset); 3847+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 3848+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 3849+ free(*primitive); 3850+ *primitive = ret_value; 3851+ } 3852+ } 3853+} 3854+ 3855+bool MindIR_GenOP_GetGlobal(ConstPrimitivePtr primitive) { 3856+ if (primitive != nullptr) { 3857+ auto prim = static_cast<const schema::Primitive *>(primitive); 3858+ auto value = prim->value_as_GenOP(); 3859+ if (prim != nullptr && value != nullptr) { 3860+ return value->global(); 3861+ } else { 3862+ return false; 3863+ } 3864+ } else { 3865+ return false; 3866+ } 3867+} 3868+ 3869+void MindIR_GenOP_SetGlobal(PrimitivePtr *primitive, bool global) { 3870+ if (primitive != nullptr && *primitive != nullptr) { 3871+ auto prim = static_cast<schema::Primitive *>(*primitive); 3872+ auto value = prim->value_as_GenOP(); 3873+ if (prim != nullptr && value != nullptr) { 3874+ flatbuffers::FlatBufferBuilder fbb; 3875+ auto ops_offset = schema::CreateGenOP(fbb, static_cast<schema::ActivationType>(value->activation_type()), value->alpha(), value->min_val(), value->max_val(), value->is_training(), static_cast<schema::Format>(value->format()), fbb.CreateVector(value->kernel_size()->data(), value->kernel_size()->size()), fbb.CreateVector(value->stride()->data(), value->stride()->size()), fbb.CreateVector(value->dilation()->data(), value->dilation()->size()), static_cast<schema::PadMode>(value->pad_mode()), fbb.CreateVector(value->pad_list()->data(), value->pad_list()->size()), value->mode(), value->group(), value->in_channel(), value->out_channel(), static_cast<schema::EltwiseMode>(value->eltwise_mode()), value->has_bias(), value->use_axis(), value->axis(), value->epsilon(), value->momentum(), value->transpose_a(), value->transpose_b(), fbb.CreateVector(value->pad()->data(), value->pad()->size()), static_cast<schema::RoundMode>(value->round_mode()), global, value->channel_shared(), fbb.CreateVector(value->axes()->data(), value->axes()->size()), value->keep_dims(), static_cast<schema::ReduceMode>(value->reduce_mode()), value->reduce_to_end(), value->coeff()); 3876+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_GEN_O_P), ops_offset.o); 3877+ fbb.Finish(prim_offset); 3878+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 3879+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 3880+ free(*primitive); 3881+ *primitive = ret_value; 3882+ } 3883+ } 3884+} 3885+ 3886+bool MindIR_GenOP_GetChannelShared(ConstPrimitivePtr primitive) { 3887+ if (primitive != nullptr) { 3888+ auto prim = static_cast<const schema::Primitive *>(primitive); 3889+ auto value = prim->value_as_GenOP(); 3890+ if (prim != nullptr && value != nullptr) { 3891+ return value->channel_shared(); 3892+ } else { 3893+ return false; 3894+ } 3895+ } else { 3896+ return false; 3897+ } 3898+} 3899+ 3900+void MindIR_GenOP_SetChannelShared(PrimitivePtr *primitive, bool channel_shared) { 3901+ if (primitive != nullptr && *primitive != nullptr) { 3902+ auto prim = static_cast<schema::Primitive *>(*primitive); 3903+ auto value = prim->value_as_GenOP(); 3904+ if (prim != nullptr && value != nullptr) { 3905+ flatbuffers::FlatBufferBuilder fbb; 3906+ auto ops_offset = schema::CreateGenOP(fbb, static_cast<schema::ActivationType>(value->activation_type()), value->alpha(), value->min_val(), value->max_val(), value->is_training(), static_cast<schema::Format>(value->format()), fbb.CreateVector(value->kernel_size()->data(), value->kernel_size()->size()), fbb.CreateVector(value->stride()->data(), value->stride()->size()), fbb.CreateVector(value->dilation()->data(), value->dilation()->size()), static_cast<schema::PadMode>(value->pad_mode()), fbb.CreateVector(value->pad_list()->data(), value->pad_list()->size()), value->mode(), value->group(), value->in_channel(), value->out_channel(), static_cast<schema::EltwiseMode>(value->eltwise_mode()), value->has_bias(), value->use_axis(), value->axis(), value->epsilon(), value->momentum(), value->transpose_a(), value->transpose_b(), fbb.CreateVector(value->pad()->data(), value->pad()->size()), static_cast<schema::RoundMode>(value->round_mode()), value->global(), channel_shared, fbb.CreateVector(value->axes()->data(), value->axes()->size()), value->keep_dims(), static_cast<schema::ReduceMode>(value->reduce_mode()), value->reduce_to_end(), value->coeff()); 3907+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_GEN_O_P), ops_offset.o); 3908+ fbb.Finish(prim_offset); 3909+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 3910+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 3911+ free(*primitive); 3912+ *primitive = ret_value; 3913+ } 3914+ } 3915+} 3916+ 3917+std::vector<int64_t> MindIR_GenOP_GetAxes(ConstPrimitivePtr primitive) { 3918+ if (primitive != nullptr) { 3919+ auto prim = static_cast<const schema::Primitive *>(primitive); 3920+ auto value = prim->value_as_GenOP(); 3921+ if (prim != nullptr && value != nullptr) { 3922+ std::vector<int64_t> result; 3923+ auto src = value->axes(); 3924+ if (src == nullptr) { 3925+ return {}; 3926+ } 3927+ result.resize(src->size()); 3928+ std::transform(src->begin(), src->end(), result.begin(), [](int64_t item) { return item; }); 3929+ return result; 3930+ } else { 3931+ return {}; 3932+ } 3933+ } else { 3934+ return {}; 3935+ } 3936+} 3937+ 3938+void MindIR_GenOP_SetAxes(PrimitivePtr *primitive, const std::vector<int64_t> &axes) { 3939+ if (primitive != nullptr && *primitive != nullptr) { 3940+ auto prim = static_cast<schema::Primitive *>(*primitive); 3941+ auto value = prim->value_as_GenOP(); 3942+ if (prim != nullptr && value != nullptr) { 3943+ flatbuffers::FlatBufferBuilder fbb; 3944+ auto ops_offset = schema::CreateGenOP(fbb, static_cast<schema::ActivationType>(value->activation_type()), value->alpha(), value->min_val(), value->max_val(), value->is_training(), static_cast<schema::Format>(value->format()), fbb.CreateVector(value->kernel_size()->data(), value->kernel_size()->size()), fbb.CreateVector(value->stride()->data(), value->stride()->size()), fbb.CreateVector(value->dilation()->data(), value->dilation()->size()), static_cast<schema::PadMode>(value->pad_mode()), fbb.CreateVector(value->pad_list()->data(), value->pad_list()->size()), value->mode(), value->group(), value->in_channel(), value->out_channel(), static_cast<schema::EltwiseMode>(value->eltwise_mode()), value->has_bias(), value->use_axis(), value->axis(), value->epsilon(), value->momentum(), value->transpose_a(), value->transpose_b(), fbb.CreateVector(value->pad()->data(), value->pad()->size()), static_cast<schema::RoundMode>(value->round_mode()), value->global(), value->channel_shared(), fbb.CreateVector(axes.data(), axes.size()), value->keep_dims(), static_cast<schema::ReduceMode>(value->reduce_mode()), value->reduce_to_end(), value->coeff()); 3945+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_GEN_O_P), ops_offset.o); 3946+ fbb.Finish(prim_offset); 3947+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 3948+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 3949+ free(*primitive); 3950+ *primitive = ret_value; 3951+ } 3952+ } 3953+} 3954+ 3955+bool MindIR_GenOP_GetKeepDims(ConstPrimitivePtr primitive) { 3956+ if (primitive != nullptr) { 3957+ auto prim = static_cast<const schema::Primitive *>(primitive); 3958+ auto value = prim->value_as_GenOP(); 3959+ if (prim != nullptr && value != nullptr) { 3960+ return value->keep_dims(); 3961+ } else { 3962+ return false; 3963+ } 3964+ } else { 3965+ return false; 3966+ } 3967+} 3968+ 3969+void MindIR_GenOP_SetKeepDims(PrimitivePtr *primitive, bool keep_dims) { 3970+ if (primitive != nullptr && *primitive != nullptr) { 3971+ auto prim = static_cast<schema::Primitive *>(*primitive); 3972+ auto value = prim->value_as_GenOP(); 3973+ if (prim != nullptr && value != nullptr) { 3974+ flatbuffers::FlatBufferBuilder fbb; 3975+ auto ops_offset = schema::CreateGenOP(fbb, static_cast<schema::ActivationType>(value->activation_type()), value->alpha(), value->min_val(), value->max_val(), value->is_training(), static_cast<schema::Format>(value->format()), fbb.CreateVector(value->kernel_size()->data(), value->kernel_size()->size()), fbb.CreateVector(value->stride()->data(), value->stride()->size()), fbb.CreateVector(value->dilation()->data(), value->dilation()->size()), static_cast<schema::PadMode>(value->pad_mode()), fbb.CreateVector(value->pad_list()->data(), value->pad_list()->size()), value->mode(), value->group(), value->in_channel(), value->out_channel(), static_cast<schema::EltwiseMode>(value->eltwise_mode()), value->has_bias(), value->use_axis(), value->axis(), value->epsilon(), value->momentum(), value->transpose_a(), value->transpose_b(), fbb.CreateVector(value->pad()->data(), value->pad()->size()), static_cast<schema::RoundMode>(value->round_mode()), value->global(), value->channel_shared(), fbb.CreateVector(value->axes()->data(), value->axes()->size()), keep_dims, static_cast<schema::ReduceMode>(value->reduce_mode()), value->reduce_to_end(), value->coeff()); 3976+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_GEN_O_P), ops_offset.o); 3977+ fbb.Finish(prim_offset); 3978+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 3979+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 3980+ free(*primitive); 3981+ *primitive = ret_value; 3982+ } 3983+ } 3984+} 3985+ 3986+ReduceMode MindIR_GenOP_GetReduceMode(ConstPrimitivePtr primitive) { 3987+ if (primitive != nullptr) { 3988+ auto prim = static_cast<const schema::Primitive *>(primitive); 3989+ auto value = prim->value_as_GenOP(); 3990+ if (prim != nullptr && value != nullptr) { 3991+ return static_cast<ReduceMode>(value->reduce_mode()); 3992+ } else { 3993+ ReduceMode en = static_cast<ReduceMode>(0); 3994+ return en; 3995+ } 3996+ } else { 3997+ ReduceMode en = static_cast<ReduceMode>(0); 3998+ return en; 3999+ } 4000+} 4001+ 4002+void MindIR_GenOP_SetReduceMode(PrimitivePtr *primitive, ReduceMode reduce_mode) { 4003+ if (primitive != nullptr && *primitive != nullptr) { 4004+ auto prim = static_cast<schema::Primitive *>(*primitive); 4005+ auto value = prim->value_as_GenOP(); 4006+ if (prim != nullptr && value != nullptr) { 4007+ flatbuffers::FlatBufferBuilder fbb; 4008+ auto ops_offset = schema::CreateGenOP(fbb, static_cast<schema::ActivationType>(value->activation_type()), value->alpha(), value->min_val(), value->max_val(), value->is_training(), static_cast<schema::Format>(value->format()), fbb.CreateVector(value->kernel_size()->data(), value->kernel_size()->size()), fbb.CreateVector(value->stride()->data(), value->stride()->size()), fbb.CreateVector(value->dilation()->data(), value->dilation()->size()), static_cast<schema::PadMode>(value->pad_mode()), fbb.CreateVector(value->pad_list()->data(), value->pad_list()->size()), value->mode(), value->group(), value->in_channel(), value->out_channel(), static_cast<schema::EltwiseMode>(value->eltwise_mode()), value->has_bias(), value->use_axis(), value->axis(), value->epsilon(), value->momentum(), value->transpose_a(), value->transpose_b(), fbb.CreateVector(value->pad()->data(), value->pad()->size()), static_cast<schema::RoundMode>(value->round_mode()), value->global(), value->channel_shared(), fbb.CreateVector(value->axes()->data(), value->axes()->size()), value->keep_dims(), static_cast<schema::ReduceMode>(reduce_mode), value->reduce_to_end(), value->coeff()); 4009+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_GEN_O_P), ops_offset.o); 4010+ fbb.Finish(prim_offset); 4011+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 4012+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 4013+ free(*primitive); 4014+ *primitive = ret_value; 4015+ } 4016+ } 4017+} 4018+ 4019+bool MindIR_GenOP_GetReduceToEnd(ConstPrimitivePtr primitive) { 4020+ if (primitive != nullptr) { 4021+ auto prim = static_cast<const schema::Primitive *>(primitive); 4022+ auto value = prim->value_as_GenOP(); 4023+ if (prim != nullptr && value != nullptr) { 4024+ return value->reduce_to_end(); 4025+ } else { 4026+ return false; 4027+ } 4028+ } else { 4029+ return false; 4030+ } 4031+} 4032+ 4033+void MindIR_GenOP_SetReduceToEnd(PrimitivePtr *primitive, bool reduce_to_end) { 4034+ if (primitive != nullptr && *primitive != nullptr) { 4035+ auto prim = static_cast<schema::Primitive *>(*primitive); 4036+ auto value = prim->value_as_GenOP(); 4037+ if (prim != nullptr && value != nullptr) { 4038+ flatbuffers::FlatBufferBuilder fbb; 4039+ auto ops_offset = schema::CreateGenOP(fbb, static_cast<schema::ActivationType>(value->activation_type()), value->alpha(), value->min_val(), value->max_val(), value->is_training(), static_cast<schema::Format>(value->format()), fbb.CreateVector(value->kernel_size()->data(), value->kernel_size()->size()), fbb.CreateVector(value->stride()->data(), value->stride()->size()), fbb.CreateVector(value->dilation()->data(), value->dilation()->size()), static_cast<schema::PadMode>(value->pad_mode()), fbb.CreateVector(value->pad_list()->data(), value->pad_list()->size()), value->mode(), value->group(), value->in_channel(), value->out_channel(), static_cast<schema::EltwiseMode>(value->eltwise_mode()), value->has_bias(), value->use_axis(), value->axis(), value->epsilon(), value->momentum(), value->transpose_a(), value->transpose_b(), fbb.CreateVector(value->pad()->data(), value->pad()->size()), static_cast<schema::RoundMode>(value->round_mode()), value->global(), value->channel_shared(), fbb.CreateVector(value->axes()->data(), value->axes()->size()), value->keep_dims(), static_cast<schema::ReduceMode>(value->reduce_mode()), reduce_to_end, value->coeff()); 4040+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_GEN_O_P), ops_offset.o); 4041+ fbb.Finish(prim_offset); 4042+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 4043+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 4044+ free(*primitive); 4045+ *primitive = ret_value; 4046+ } 4047+ } 4048+} 4049+ 4050+float MindIR_GenOP_GetCoeff(ConstPrimitivePtr primitive) { 4051+ if (primitive != nullptr) { 4052+ auto prim = static_cast<const schema::Primitive *>(primitive); 4053+ auto value = prim->value_as_GenOP(); 4054+ if (prim != nullptr && value != nullptr) { 4055+ return value->coeff(); 4056+ } else { 4057+ return .0; 4058+ } 4059+ } else { 4060+ return .0; 4061+ } 4062+} 4063+ 4064+void MindIR_GenOP_SetCoeff(PrimitivePtr *primitive, float coeff) { 4065+ if (primitive != nullptr && *primitive != nullptr) { 4066+ auto prim = static_cast<schema::Primitive *>(*primitive); 4067+ auto value = prim->value_as_GenOP(); 4068+ if (prim != nullptr && value != nullptr) { 4069+ flatbuffers::FlatBufferBuilder fbb; 4070+ auto ops_offset = schema::CreateGenOP(fbb, static_cast<schema::ActivationType>(value->activation_type()), value->alpha(), value->min_val(), value->max_val(), value->is_training(), static_cast<schema::Format>(value->format()), fbb.CreateVector(value->kernel_size()->data(), value->kernel_size()->size()), fbb.CreateVector(value->stride()->data(), value->stride()->size()), fbb.CreateVector(value->dilation()->data(), value->dilation()->size()), static_cast<schema::PadMode>(value->pad_mode()), fbb.CreateVector(value->pad_list()->data(), value->pad_list()->size()), value->mode(), value->group(), value->in_channel(), value->out_channel(), static_cast<schema::EltwiseMode>(value->eltwise_mode()), value->has_bias(), value->use_axis(), value->axis(), value->epsilon(), value->momentum(), value->transpose_a(), value->transpose_b(), fbb.CreateVector(value->pad()->data(), value->pad()->size()), static_cast<schema::RoundMode>(value->round_mode()), value->global(), value->channel_shared(), fbb.CreateVector(value->axes()->data(), value->axes()->size()), value->keep_dims(), static_cast<schema::ReduceMode>(value->reduce_mode()), value->reduce_to_end(), coeff); 4071+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_GEN_O_P), ops_offset.o); 4072+ fbb.Finish(prim_offset); 4073+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 4074+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 4075+ free(*primitive); 4076+ *primitive = ret_value; 4077+ } 4078+ } 4079+} 4080+ 4081+// ********** RaggedRange ********** 4082+PrimitivePtr MindIR_RaggedRange_CreatePrimitive() { 4083+ flatbuffers::FlatBufferBuilder fbb; 4084+ auto ops_offset = schema::CreateRaggedRange(fbb); 4085+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_RAGGED_RANGE), ops_offset.o); 4086+ fbb.Finish(prim_offset); 4087+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 4088+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 4089+ return ret_value; 4090+} 4091+ 4092+// ********** GLU ********** 4093+PrimitivePtr MindIR_GLU_CreatePrimitive(int64_t axis) { 4094+ flatbuffers::FlatBufferBuilder fbb; 4095+ auto ops_offset = schema::CreateGLU(fbb, axis); 4096+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_G_L_U), ops_offset.o); 4097+ fbb.Finish(prim_offset); 4098+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 4099+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 4100+ return ret_value; 4101+} 4102+ 4103+int64_t MindIR_GLU_GetAxis(ConstPrimitivePtr primitive) { 4104+ if (primitive != nullptr) { 4105+ auto prim = static_cast<const schema::Primitive *>(primitive); 4106+ auto value = prim->value_as_GLU(); 4107+ if (prim != nullptr && value != nullptr) { 4108+ return value->axis(); 4109+ } else { 4110+ return 0; 4111+ } 4112+ } else { 4113+ return 0; 4114+ } 4115+} 4116+ 4117+void MindIR_GLU_SetAxis(PrimitivePtr *primitive, int64_t axis) { 4118+ if (primitive != nullptr && *primitive != nullptr) { 4119+ auto prim = static_cast<schema::Primitive *>(*primitive); 4120+ auto value = prim->value_as_GLU(); 4121+ if (prim != nullptr && value != nullptr) { 4122+ flatbuffers::FlatBufferBuilder fbb; 4123+ auto ops_offset = schema::CreateGLU(fbb, axis); 4124+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_G_L_U), ops_offset.o); 4125+ fbb.Finish(prim_offset); 4126+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 4127+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 4128+ free(*primitive); 4129+ *primitive = ret_value; 4130+ } 4131+ } 4132+} 4133+ 4134+// ********** Affine ********** 4135+PrimitivePtr MindIR_Affine_CreatePrimitive(const std::vector<int64_t> &context, int64_t output_dim, ActivationType activation_type, bool transpose_a, bool transpose_b) { 4136+ flatbuffers::FlatBufferBuilder fbb; 4137+ auto ops_offset = schema::CreateAffine(fbb, fbb.CreateVector(context.data(), context.size()), output_dim, static_cast<schema::ActivationType>(activation_type), transpose_a, transpose_b); 4138+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_AFFINE), ops_offset.o); 4139+ fbb.Finish(prim_offset); 4140+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 4141+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 4142+ return ret_value; 4143+} 4144+ 4145+std::vector<int64_t> MindIR_Affine_GetContext(ConstPrimitivePtr primitive) { 4146+ if (primitive != nullptr) { 4147+ auto prim = static_cast<const schema::Primitive *>(primitive); 4148+ auto value = prim->value_as_Affine(); 4149+ if (prim != nullptr && value != nullptr) { 4150+ std::vector<int64_t> result; 4151+ auto src = value->context(); 4152+ if (src == nullptr) { 4153+ return {}; 4154+ } 4155+ result.resize(src->size()); 4156+ std::transform(src->begin(), src->end(), result.begin(), [](int64_t item) { return item; }); 4157+ return result; 4158+ } else { 4159+ return {}; 4160+ } 4161+ } else { 4162+ return {}; 4163+ } 4164+} 4165+ 4166+void MindIR_Affine_SetContext(PrimitivePtr *primitive, const std::vector<int64_t> &context) { 4167+ if (primitive != nullptr && *primitive != nullptr) { 4168+ auto prim = static_cast<schema::Primitive *>(*primitive); 4169+ auto value = prim->value_as_Affine(); 4170+ if (prim != nullptr && value != nullptr) { 4171+ flatbuffers::FlatBufferBuilder fbb; 4172+ auto ops_offset = schema::CreateAffine(fbb, fbb.CreateVector(context.data(), context.size()), value->output_dim(), static_cast<schema::ActivationType>(value->activation_type()), value->transpose_a(), value->transpose_b()); 4173+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_AFFINE), ops_offset.o); 4174+ fbb.Finish(prim_offset); 4175+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 4176+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 4177+ free(*primitive); 4178+ *primitive = ret_value; 4179+ } 4180+ } 4181+} 4182+ 4183+int64_t MindIR_Affine_GetOutputDim(ConstPrimitivePtr primitive) { 4184+ if (primitive != nullptr) { 4185+ auto prim = static_cast<const schema::Primitive *>(primitive); 4186+ auto value = prim->value_as_Affine(); 4187+ if (prim != nullptr && value != nullptr) { 4188+ return value->output_dim(); 4189+ } else { 4190+ return 0; 4191+ } 4192+ } else { 4193+ return 0; 4194+ } 4195+} 4196+ 4197+void MindIR_Affine_SetOutputDim(PrimitivePtr *primitive, int64_t output_dim) { 4198+ if (primitive != nullptr && *primitive != nullptr) { 4199+ auto prim = static_cast<schema::Primitive *>(*primitive); 4200+ auto value = prim->value_as_Affine(); 4201+ if (prim != nullptr && value != nullptr) { 4202+ flatbuffers::FlatBufferBuilder fbb; 4203+ auto ops_offset = schema::CreateAffine(fbb, fbb.CreateVector(value->context()->data(), value->context()->size()), output_dim, static_cast<schema::ActivationType>(value->activation_type()), value->transpose_a(), value->transpose_b()); 4204+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_AFFINE), ops_offset.o); 4205+ fbb.Finish(prim_offset); 4206+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 4207+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 4208+ free(*primitive); 4209+ *primitive = ret_value; 4210+ } 4211+ } 4212+} 4213+ 4214+ActivationType MindIR_Affine_GetActivationType(ConstPrimitivePtr primitive) { 4215+ if (primitive != nullptr) { 4216+ auto prim = static_cast<const schema::Primitive *>(primitive); 4217+ auto value = prim->value_as_Affine(); 4218+ if (prim != nullptr && value != nullptr) { 4219+ return static_cast<ActivationType>(value->activation_type()); 4220+ } else { 4221+ ActivationType en = static_cast<ActivationType>(0); 4222+ return en; 4223+ } 4224+ } else { 4225+ ActivationType en = static_cast<ActivationType>(0); 4226+ return en; 4227+ } 4228+} 4229+ 4230+void MindIR_Affine_SetActivationType(PrimitivePtr *primitive, ActivationType activation_type) { 4231+ if (primitive != nullptr && *primitive != nullptr) { 4232+ auto prim = static_cast<schema::Primitive *>(*primitive); 4233+ auto value = prim->value_as_Affine(); 4234+ if (prim != nullptr && value != nullptr) { 4235+ flatbuffers::FlatBufferBuilder fbb; 4236+ auto ops_offset = schema::CreateAffine(fbb, fbb.CreateVector(value->context()->data(), value->context()->size()), value->output_dim(), static_cast<schema::ActivationType>(activation_type), value->transpose_a(), value->transpose_b()); 4237+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_AFFINE), ops_offset.o); 4238+ fbb.Finish(prim_offset); 4239+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 4240+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 4241+ free(*primitive); 4242+ *primitive = ret_value; 4243+ } 4244+ } 4245+} 4246+ 4247+bool MindIR_Affine_GetTransposeA(ConstPrimitivePtr primitive) { 4248+ if (primitive != nullptr) { 4249+ auto prim = static_cast<const schema::Primitive *>(primitive); 4250+ auto value = prim->value_as_Affine(); 4251+ if (prim != nullptr && value != nullptr) { 4252+ return value->transpose_a(); 4253+ } else { 4254+ return false; 4255+ } 4256+ } else { 4257+ return false; 4258+ } 4259+} 4260+ 4261+void MindIR_Affine_SetTransposeA(PrimitivePtr *primitive, bool transpose_a) { 4262+ if (primitive != nullptr && *primitive != nullptr) { 4263+ auto prim = static_cast<schema::Primitive *>(*primitive); 4264+ auto value = prim->value_as_Affine(); 4265+ if (prim != nullptr && value != nullptr) { 4266+ flatbuffers::FlatBufferBuilder fbb; 4267+ auto ops_offset = schema::CreateAffine(fbb, fbb.CreateVector(value->context()->data(), value->context()->size()), value->output_dim(), static_cast<schema::ActivationType>(value->activation_type()), transpose_a, value->transpose_b()); 4268+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_AFFINE), ops_offset.o); 4269+ fbb.Finish(prim_offset); 4270+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 4271+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 4272+ free(*primitive); 4273+ *primitive = ret_value; 4274+ } 4275+ } 4276+} 4277+ 4278+bool MindIR_Affine_GetTransposeB(ConstPrimitivePtr primitive) { 4279+ if (primitive != nullptr) { 4280+ auto prim = static_cast<const schema::Primitive *>(primitive); 4281+ auto value = prim->value_as_Affine(); 4282+ if (prim != nullptr && value != nullptr) { 4283+ return value->transpose_b(); 4284+ } else { 4285+ return false; 4286+ } 4287+ } else { 4288+ return false; 4289+ } 4290+} 4291+ 4292+void MindIR_Affine_SetTransposeB(PrimitivePtr *primitive, bool transpose_b) { 4293+ if (primitive != nullptr && *primitive != nullptr) { 4294+ auto prim = static_cast<schema::Primitive *>(*primitive); 4295+ auto value = prim->value_as_Affine(); 4296+ if (prim != nullptr && value != nullptr) { 4297+ flatbuffers::FlatBufferBuilder fbb; 4298+ auto ops_offset = schema::CreateAffine(fbb, fbb.CreateVector(value->context()->data(), value->context()->size()), value->output_dim(), static_cast<schema::ActivationType>(value->activation_type()), value->transpose_a(), transpose_b); 4299+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_AFFINE), ops_offset.o); 4300+ fbb.Finish(prim_offset); 4301+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 4302+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 4303+ free(*primitive); 4304+ *primitive = ret_value; 4305+ } 4306+ } 4307+} 4308+ 4309+// ********** AllGather ********** 4310+PrimitivePtr MindIR_AllGather_CreatePrimitive(const std::string &group, int32_t rank_size) { 4311+ flatbuffers::FlatBufferBuilder fbb; 4312+ auto ops_offset = schema::CreateAllGather(fbb, fbb.CreateString(group), rank_size); 4313+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_ALL_GATHER), ops_offset.o); 4314+ fbb.Finish(prim_offset); 4315+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 4316+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 4317+ return ret_value; 4318+} 4319+ 4320+std::string MindIR_AllGather_GetGroup(ConstPrimitivePtr primitive) { 4321+ if (primitive != nullptr) { 4322+ auto prim = static_cast<const schema::Primitive *>(primitive); 4323+ auto value = prim->value_as_AllGather(); 4324+ if (prim != nullptr && value != nullptr) { 4325+ return std::string(value->group()->c_str(),value->group()->size()); 4326+ } else { 4327+ return ""; 4328+ } 4329+ } else { 4330+ return ""; 4331+ } 4332+} 4333+ 4334+void MindIR_AllGather_SetGroup(PrimitivePtr *primitive, const std::string &group) { 4335+ if (primitive != nullptr && *primitive != nullptr) { 4336+ auto prim = static_cast<schema::Primitive *>(*primitive); 4337+ auto value = prim->value_as_AllGather(); 4338+ if (prim != nullptr && value != nullptr) { 4339+ flatbuffers::FlatBufferBuilder fbb; 4340+ auto ops_offset = schema::CreateAllGather(fbb, fbb.CreateString(group), value->rank_size()); 4341+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_ALL_GATHER), ops_offset.o); 4342+ fbb.Finish(prim_offset); 4343+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 4344+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 4345+ free(*primitive); 4346+ *primitive = ret_value; 4347+ } 4348+ } 4349+} 4350+ 4351+int32_t MindIR_AllGather_GetRankSize(ConstPrimitivePtr primitive) { 4352+ if (primitive != nullptr) { 4353+ auto prim = static_cast<const schema::Primitive *>(primitive); 4354+ auto value = prim->value_as_AllGather(); 4355+ if (prim != nullptr && value != nullptr) { 4356+ return value->rank_size(); 4357+ } else { 4358+ return 0; 4359+ } 4360+ } else { 4361+ return 0; 4362+ } 4363+} 4364+ 4365+void MindIR_AllGather_SetRankSize(PrimitivePtr *primitive, int32_t rank_size) { 4366+ if (primitive != nullptr && *primitive != nullptr) { 4367+ auto prim = static_cast<schema::Primitive *>(*primitive); 4368+ auto value = prim->value_as_AllGather(); 4369+ if (prim != nullptr && value != nullptr) { 4370+ flatbuffers::FlatBufferBuilder fbb; 4371+ auto ops_offset = schema::CreateAllGather(fbb, fbb.CreateString(std::string(value->group()->c_str(), value->group()->size())), rank_size); 4372+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_ALL_GATHER), ops_offset.o); 4373+ fbb.Finish(prim_offset); 4374+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 4375+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 4376+ free(*primitive); 4377+ *primitive = ret_value; 4378+ } 4379+ } 4380+} 4381+ 4382+// ********** ReduceScatter ********** 4383+PrimitivePtr MindIR_ReduceScatter_CreatePrimitive(const std::string &group, ReduceMode mode, int32_t rank_size) { 4384+ flatbuffers::FlatBufferBuilder fbb; 4385+ auto ops_offset = schema::CreateReduceScatter(fbb, fbb.CreateString(group), static_cast<schema::ReduceMode>(mode), rank_size); 4386+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_REDUCE_SCATTER), ops_offset.o); 4387+ fbb.Finish(prim_offset); 4388+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 4389+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 4390+ return ret_value; 4391+} 4392+ 4393+std::string MindIR_ReduceScatter_GetGroup(ConstPrimitivePtr primitive) { 4394+ if (primitive != nullptr) { 4395+ auto prim = static_cast<const schema::Primitive *>(primitive); 4396+ auto value = prim->value_as_ReduceScatter(); 4397+ if (prim != nullptr && value != nullptr) { 4398+ return std::string(value->group()->c_str(),value->group()->size()); 4399+ } else { 4400+ return ""; 4401+ } 4402+ } else { 4403+ return ""; 4404+ } 4405+} 4406+ 4407+void MindIR_ReduceScatter_SetGroup(PrimitivePtr *primitive, const std::string &group) { 4408+ if (primitive != nullptr && *primitive != nullptr) { 4409+ auto prim = static_cast<schema::Primitive *>(*primitive); 4410+ auto value = prim->value_as_ReduceScatter(); 4411+ if (prim != nullptr && value != nullptr) { 4412+ flatbuffers::FlatBufferBuilder fbb; 4413+ auto ops_offset = schema::CreateReduceScatter(fbb, fbb.CreateString(group), static_cast<schema::ReduceMode>(value->mode()), value->rank_size()); 4414+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_REDUCE_SCATTER), ops_offset.o); 4415+ fbb.Finish(prim_offset); 4416+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 4417+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 4418+ free(*primitive); 4419+ *primitive = ret_value; 4420+ } 4421+ } 4422+} 4423+ 4424+ReduceMode MindIR_ReduceScatter_GetMode(ConstPrimitivePtr primitive) { 4425+ if (primitive != nullptr) { 4426+ auto prim = static_cast<const schema::Primitive *>(primitive); 4427+ auto value = prim->value_as_ReduceScatter(); 4428+ if (prim != nullptr && value != nullptr) { 4429+ return static_cast<ReduceMode>(value->mode()); 4430+ } else { 4431+ ReduceMode en = static_cast<ReduceMode>(0); 4432+ return en; 4433+ } 4434+ } else { 4435+ ReduceMode en = static_cast<ReduceMode>(0); 4436+ return en; 4437+ } 4438+} 4439+ 4440+void MindIR_ReduceScatter_SetMode(PrimitivePtr *primitive, ReduceMode mode) { 4441+ if (primitive != nullptr && *primitive != nullptr) { 4442+ auto prim = static_cast<schema::Primitive *>(*primitive); 4443+ auto value = prim->value_as_ReduceScatter(); 4444+ if (prim != nullptr && value != nullptr) { 4445+ flatbuffers::FlatBufferBuilder fbb; 4446+ auto ops_offset = schema::CreateReduceScatter(fbb, fbb.CreateString(std::string(value->group()->c_str(), value->group()->size())), static_cast<schema::ReduceMode>(mode), value->rank_size()); 4447+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_REDUCE_SCATTER), ops_offset.o); 4448+ fbb.Finish(prim_offset); 4449+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 4450+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 4451+ free(*primitive); 4452+ *primitive = ret_value; 4453+ } 4454+ } 4455+} 4456+ 4457+int32_t MindIR_ReduceScatter_GetRankSize(ConstPrimitivePtr primitive) { 4458+ if (primitive != nullptr) { 4459+ auto prim = static_cast<const schema::Primitive *>(primitive); 4460+ auto value = prim->value_as_ReduceScatter(); 4461+ if (prim != nullptr && value != nullptr) { 4462+ return value->rank_size(); 4463+ } else { 4464+ return 0; 4465+ } 4466+ } else { 4467+ return 0; 4468+ } 4469+} 4470+ 4471+void MindIR_ReduceScatter_SetRankSize(PrimitivePtr *primitive, int32_t rank_size) { 4472+ if (primitive != nullptr && *primitive != nullptr) { 4473+ auto prim = static_cast<schema::Primitive *>(*primitive); 4474+ auto value = prim->value_as_ReduceScatter(); 4475+ if (prim != nullptr && value != nullptr) { 4476+ flatbuffers::FlatBufferBuilder fbb; 4477+ auto ops_offset = schema::CreateReduceScatter(fbb, fbb.CreateString(std::string(value->group()->c_str(), value->group()->size())), static_cast<schema::ReduceMode>(value->mode()), rank_size); 4478+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_REDUCE_SCATTER), ops_offset.o); 4479+ fbb.Finish(prim_offset); 4480+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 4481+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 4482+ free(*primitive); 4483+ *primitive = ret_value; 4484+ } 4485+ } 4486+} 4487+ 4488+// ********** DynamicQuant ********** 4489+PrimitivePtr MindIR_DynamicQuant_CreatePrimitive(bool symmetric, int64_t dst_type) { 4490+ flatbuffers::FlatBufferBuilder fbb; 4491+ auto ops_offset = schema::CreateDynamicQuant(fbb, symmetric, dst_type); 4492+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_DYNAMIC_QUANT), ops_offset.o); 4493+ fbb.Finish(prim_offset); 4494+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 4495+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 4496+ return ret_value; 4497+} 4498+ 4499+bool MindIR_DynamicQuant_GetSymmetric(ConstPrimitivePtr primitive) { 4500+ if (primitive != nullptr) { 4501+ auto prim = static_cast<const schema::Primitive *>(primitive); 4502+ auto value = prim->value_as_DynamicQuant(); 4503+ if (prim != nullptr && value != nullptr) { 4504+ return value->symmetric(); 4505+ } else { 4506+ return false; 4507+ } 4508+ } else { 4509+ return false; 4510+ } 4511+} 4512+ 4513+void MindIR_DynamicQuant_SetSymmetric(PrimitivePtr *primitive, bool symmetric) { 4514+ if (primitive != nullptr && *primitive != nullptr) { 4515+ auto prim = static_cast<schema::Primitive *>(*primitive); 4516+ auto value = prim->value_as_DynamicQuant(); 4517+ if (prim != nullptr && value != nullptr) { 4518+ flatbuffers::FlatBufferBuilder fbb; 4519+ auto ops_offset = schema::CreateDynamicQuant(fbb, symmetric, value->dst_type()); 4520+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_DYNAMIC_QUANT), ops_offset.o); 4521+ fbb.Finish(prim_offset); 4522+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 4523+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 4524+ free(*primitive); 4525+ *primitive = ret_value; 4526+ } 4527+ } 4528+} 4529+ 4530+int64_t MindIR_DynamicQuant_GetDstType(ConstPrimitivePtr primitive) { 4531+ if (primitive != nullptr) { 4532+ auto prim = static_cast<const schema::Primitive *>(primitive); 4533+ auto value = prim->value_as_DynamicQuant(); 4534+ if (prim != nullptr && value != nullptr) { 4535+ return value->dst_type(); 4536+ } else { 4537+ return 0; 4538+ } 4539+ } else { 4540+ return 0; 4541+ } 4542+} 4543+ 4544+void MindIR_DynamicQuant_SetDstType(PrimitivePtr *primitive, int64_t dst_type) { 4545+ if (primitive != nullptr && *primitive != nullptr) { 4546+ auto prim = static_cast<schema::Primitive *>(*primitive); 4547+ auto value = prim->value_as_DynamicQuant(); 4548+ if (prim != nullptr && value != nullptr) { 4549+ flatbuffers::FlatBufferBuilder fbb; 4550+ auto ops_offset = schema::CreateDynamicQuant(fbb, value->symmetric(), dst_type); 4551+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_DYNAMIC_QUANT), ops_offset.o); 4552+ fbb.Finish(prim_offset); 4553+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 4554+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 4555+ free(*primitive); 4556+ *primitive = ret_value; 4557+ } 4558+ } 4559+} 4560+ 4561+// ********** RandomNormal ********** 4562+PrimitivePtr MindIR_RandomNormal_CreatePrimitive(float seed, float mean, float scale) { 4563+ flatbuffers::FlatBufferBuilder fbb; 4564+ auto ops_offset = schema::CreateRandomNormal(fbb, seed, mean, scale); 4565+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_RANDOM_NORMAL), ops_offset.o); 4566+ fbb.Finish(prim_offset); 4567+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 4568+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 4569+ return ret_value; 4570+} 4571+ 4572+float MindIR_RandomNormal_GetSeed(ConstPrimitivePtr primitive) { 4573+ if (primitive != nullptr) { 4574+ auto prim = static_cast<const schema::Primitive *>(primitive); 4575+ auto value = prim->value_as_RandomNormal(); 4576+ if (prim != nullptr && value != nullptr) { 4577+ return value->seed(); 4578+ } else { 4579+ return .0; 4580+ } 4581+ } else { 4582+ return .0; 4583+ } 4584+} 4585+ 4586+void MindIR_RandomNormal_SetSeed(PrimitivePtr *primitive, float seed) { 4587+ if (primitive != nullptr && *primitive != nullptr) { 4588+ auto prim = static_cast<schema::Primitive *>(*primitive); 4589+ auto value = prim->value_as_RandomNormal(); 4590+ if (prim != nullptr && value != nullptr) { 4591+ flatbuffers::FlatBufferBuilder fbb; 4592+ auto ops_offset = schema::CreateRandomNormal(fbb, seed, value->mean(), value->scale()); 4593+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_RANDOM_NORMAL), ops_offset.o); 4594+ fbb.Finish(prim_offset); 4595+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 4596+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 4597+ free(*primitive); 4598+ *primitive = ret_value; 4599+ } 4600+ } 4601+} 4602+ 4603+float MindIR_RandomNormal_GetMean(ConstPrimitivePtr primitive) { 4604+ if (primitive != nullptr) { 4605+ auto prim = static_cast<const schema::Primitive *>(primitive); 4606+ auto value = prim->value_as_RandomNormal(); 4607+ if (prim != nullptr && value != nullptr) { 4608+ return value->mean(); 4609+ } else { 4610+ return .0; 4611+ } 4612+ } else { 4613+ return .0; 4614+ } 4615+} 4616+ 4617+void MindIR_RandomNormal_SetMean(PrimitivePtr *primitive, float mean) { 4618+ if (primitive != nullptr && *primitive != nullptr) { 4619+ auto prim = static_cast<schema::Primitive *>(*primitive); 4620+ auto value = prim->value_as_RandomNormal(); 4621+ if (prim != nullptr && value != nullptr) { 4622+ flatbuffers::FlatBufferBuilder fbb; 4623+ auto ops_offset = schema::CreateRandomNormal(fbb, value->seed(), mean, value->scale()); 4624+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_RANDOM_NORMAL), ops_offset.o); 4625+ fbb.Finish(prim_offset); 4626+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 4627+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 4628+ free(*primitive); 4629+ *primitive = ret_value; 4630+ } 4631+ } 4632+} 4633+ 4634+float MindIR_RandomNormal_GetScale(ConstPrimitivePtr primitive) { 4635+ if (primitive != nullptr) { 4636+ auto prim = static_cast<const schema::Primitive *>(primitive); 4637+ auto value = prim->value_as_RandomNormal(); 4638+ if (prim != nullptr && value != nullptr) { 4639+ return value->scale(); 4640+ } else { 4641+ return .0; 4642+ } 4643+ } else { 4644+ return .0; 4645+ } 4646+} 4647+ 4648+void MindIR_RandomNormal_SetScale(PrimitivePtr *primitive, float scale) { 4649+ if (primitive != nullptr && *primitive != nullptr) { 4650+ auto prim = static_cast<schema::Primitive *>(*primitive); 4651+ auto value = prim->value_as_RandomNormal(); 4652+ if (prim != nullptr && value != nullptr) { 4653+ flatbuffers::FlatBufferBuilder fbb; 4654+ auto ops_offset = schema::CreateRandomNormal(fbb, value->seed(), value->mean(), scale); 4655+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_RANDOM_NORMAL), ops_offset.o); 4656+ fbb.Finish(prim_offset); 4657+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 4658+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 4659+ free(*primitive); 4660+ *primitive = ret_value; 4661+ } 4662+ } 4663+} 4664+ 4665+// ********** FormatTranspose ********** 4666+PrimitivePtr MindIR_FormatTranspose_CreatePrimitive(Format src_format, Format dst_format) { 4667+ flatbuffers::FlatBufferBuilder fbb; 4668+ auto ops_offset = schema::CreateFormatTranspose(fbb, static_cast<schema::Format>(src_format), static_cast<schema::Format>(dst_format)); 4669+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_FORMAT_TRANSPOSE), ops_offset.o); 4670+ fbb.Finish(prim_offset); 4671+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 4672+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 4673+ return ret_value; 4674+} 4675+ 4676+Format MindIR_FormatTranspose_GetSrcFormat(ConstPrimitivePtr primitive) { 4677+ if (primitive != nullptr) { 4678+ auto prim = static_cast<const schema::Primitive *>(primitive); 4679+ auto value = prim->value_as_FormatTranspose(); 4680+ if (prim != nullptr && value != nullptr) { 4681+ return static_cast<Format>(value->src_format()); 4682+ } else { 4683+ Format en = static_cast<Format>(0); 4684+ return en; 4685+ } 4686+ } else { 4687+ Format en = static_cast<Format>(0); 4688+ return en; 4689+ } 4690+} 4691+ 4692+void MindIR_FormatTranspose_SetSrcFormat(PrimitivePtr *primitive, Format src_format) { 4693+ if (primitive != nullptr && *primitive != nullptr) { 4694+ auto prim = static_cast<schema::Primitive *>(*primitive); 4695+ auto value = prim->value_as_FormatTranspose(); 4696+ if (prim != nullptr && value != nullptr) { 4697+ flatbuffers::FlatBufferBuilder fbb; 4698+ auto ops_offset = schema::CreateFormatTranspose(fbb, static_cast<schema::Format>(src_format), static_cast<schema::Format>(value->dst_format())); 4699+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_FORMAT_TRANSPOSE), ops_offset.o); 4700+ fbb.Finish(prim_offset); 4701+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 4702+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 4703+ free(*primitive); 4704+ *primitive = ret_value; 4705+ } 4706+ } 4707+} 4708+ 4709+Format MindIR_FormatTranspose_GetDstFormat(ConstPrimitivePtr primitive) { 4710+ if (primitive != nullptr) { 4711+ auto prim = static_cast<const schema::Primitive *>(primitive); 4712+ auto value = prim->value_as_FormatTranspose(); 4713+ if (prim != nullptr && value != nullptr) { 4714+ return static_cast<Format>(value->dst_format()); 4715+ } else { 4716+ Format en = static_cast<Format>(0); 4717+ return en; 4718+ } 4719+ } else { 4720+ Format en = static_cast<Format>(0); 4721+ return en; 4722+ } 4723+} 4724+ 4725+void MindIR_FormatTranspose_SetDstFormat(PrimitivePtr *primitive, Format dst_format) { 4726+ if (primitive != nullptr && *primitive != nullptr) { 4727+ auto prim = static_cast<schema::Primitive *>(*primitive); 4728+ auto value = prim->value_as_FormatTranspose(); 4729+ if (prim != nullptr && value != nullptr) { 4730+ flatbuffers::FlatBufferBuilder fbb; 4731+ auto ops_offset = schema::CreateFormatTranspose(fbb, static_cast<schema::Format>(value->src_format()), static_cast<schema::Format>(dst_format)); 4732+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_FORMAT_TRANSPOSE), ops_offset.o); 4733+ fbb.Finish(prim_offset); 4734+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 4735+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 4736+ free(*primitive); 4737+ *primitive = ret_value; 4738+ } 4739+ } 4740+} 4741+ 4742+// ********** GatherD ********** 4743+PrimitivePtr MindIR_GatherD_CreatePrimitive() { 4744+ flatbuffers::FlatBufferBuilder fbb; 4745+ auto ops_offset = schema::CreateGatherD(fbb); 4746+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_GATHER_D), ops_offset.o); 4747+ fbb.Finish(prim_offset); 4748+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 4749+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 4750+ return ret_value; 4751+} 4752+ 4753+// ********** GroupNormFusion ********** 4754+PrimitivePtr MindIR_GroupNormFusion_CreatePrimitive(int64_t num_groups, float epsilon, bool affine) { 4755+ flatbuffers::FlatBufferBuilder fbb; 4756+ auto ops_offset = schema::CreateGroupNormFusion(fbb, num_groups, epsilon, affine); 4757+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_GROUP_NORM_FUSION), ops_offset.o); 4758+ fbb.Finish(prim_offset); 4759+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 4760+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 4761+ return ret_value; 4762+} 4763+ 4764+int64_t MindIR_GroupNormFusion_GetNumGroups(ConstPrimitivePtr primitive) { 4765+ if (primitive != nullptr) { 4766+ auto prim = static_cast<const schema::Primitive *>(primitive); 4767+ auto value = prim->value_as_GroupNormFusion(); 4768+ if (prim != nullptr && value != nullptr) { 4769+ return value->num_groups(); 4770+ } else { 4771+ return 0; 4772+ } 4773+ } else { 4774+ return 0; 4775+ } 4776+} 4777+ 4778+void MindIR_GroupNormFusion_SetNumGroups(PrimitivePtr *primitive, int64_t num_groups) { 4779+ if (primitive != nullptr && *primitive != nullptr) { 4780+ auto prim = static_cast<schema::Primitive *>(*primitive); 4781+ auto value = prim->value_as_GroupNormFusion(); 4782+ if (prim != nullptr && value != nullptr) { 4783+ flatbuffers::FlatBufferBuilder fbb; 4784+ auto ops_offset = schema::CreateGroupNormFusion(fbb, num_groups, value->epsilon(), value->affine()); 4785+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_GROUP_NORM_FUSION), ops_offset.o); 4786+ fbb.Finish(prim_offset); 4787+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 4788+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 4789+ free(*primitive); 4790+ *primitive = ret_value; 4791+ } 4792+ } 4793+} 4794+ 4795+float MindIR_GroupNormFusion_GetEpsilon(ConstPrimitivePtr primitive) { 4796+ if (primitive != nullptr) { 4797+ auto prim = static_cast<const schema::Primitive *>(primitive); 4798+ auto value = prim->value_as_GroupNormFusion(); 4799+ if (prim != nullptr && value != nullptr) { 4800+ return value->epsilon(); 4801+ } else { 4802+ return .0; 4803+ } 4804+ } else { 4805+ return .0; 4806+ } 4807+} 4808+ 4809+void MindIR_GroupNormFusion_SetEpsilon(PrimitivePtr *primitive, float epsilon) { 4810+ if (primitive != nullptr && *primitive != nullptr) { 4811+ auto prim = static_cast<schema::Primitive *>(*primitive); 4812+ auto value = prim->value_as_GroupNormFusion(); 4813+ if (prim != nullptr && value != nullptr) { 4814+ flatbuffers::FlatBufferBuilder fbb; 4815+ auto ops_offset = schema::CreateGroupNormFusion(fbb, value->num_groups(), epsilon, value->affine()); 4816+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_GROUP_NORM_FUSION), ops_offset.o); 4817+ fbb.Finish(prim_offset); 4818+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 4819+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 4820+ free(*primitive); 4821+ *primitive = ret_value; 4822+ } 4823+ } 4824+} 4825+ 4826+bool MindIR_GroupNormFusion_GetAffine(ConstPrimitivePtr primitive) { 4827+ if (primitive != nullptr) { 4828+ auto prim = static_cast<const schema::Primitive *>(primitive); 4829+ auto value = prim->value_as_GroupNormFusion(); 4830+ if (prim != nullptr && value != nullptr) { 4831+ return value->affine(); 4832+ } else { 4833+ return false; 4834+ } 4835+ } else { 4836+ return false; 4837+ } 4838+} 4839+ 4840+void MindIR_GroupNormFusion_SetAffine(PrimitivePtr *primitive, bool affine) { 4841+ if (primitive != nullptr && *primitive != nullptr) { 4842+ auto prim = static_cast<schema::Primitive *>(*primitive); 4843+ auto value = prim->value_as_GroupNormFusion(); 4844+ if (prim != nullptr && value != nullptr) { 4845+ flatbuffers::FlatBufferBuilder fbb; 4846+ auto ops_offset = schema::CreateGroupNormFusion(fbb, value->num_groups(), value->epsilon(), affine); 4847+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_GROUP_NORM_FUSION), ops_offset.o); 4848+ fbb.Finish(prim_offset); 4849+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 4850+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 4851+ free(*primitive); 4852+ *primitive = ret_value; 4853+ } 4854+ } 4855+} 4856+ 4857+// ********** Log1p ********** 4858+PrimitivePtr MindIR_Log1p_CreatePrimitive() { 4859+ flatbuffers::FlatBufferBuilder fbb; 4860+ auto ops_offset = schema::CreateLog1p(fbb); 4861+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_LOG1P), ops_offset.o); 4862+ fbb.Finish(prim_offset); 4863+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 4864+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 4865+ return ret_value; 4866+} 4867+ 4868+// ********** SparseFillEmptyRows ********** 4869+PrimitivePtr MindIR_SparseFillEmptyRows_CreatePrimitive() { 4870+ flatbuffers::FlatBufferBuilder fbb; 4871+ auto ops_offset = schema::CreateSparseFillEmptyRows(fbb); 4872+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_SPARSE_FILL_EMPTY_ROWS), ops_offset.o); 4873+ fbb.Finish(prim_offset); 4874+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 4875+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 4876+ return ret_value; 4877+} 4878+ 4879+// ********** SparseReshape ********** 4880+PrimitivePtr MindIR_SparseReshape_CreatePrimitive() { 4881+ flatbuffers::FlatBufferBuilder fbb; 4882+ auto ops_offset = schema::CreateSparseReshape(fbb); 4883+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_SPARSE_RESHAPE), ops_offset.o); 4884+ fbb.Finish(prim_offset); 4885+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 4886+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 4887+ return ret_value; 4888+} 4889+ 4890+// ********** SparseSegmentSum ********** 4891+PrimitivePtr MindIR_SparseSegmentSum_CreatePrimitive() { 4892+ flatbuffers::FlatBufferBuilder fbb; 4893+ auto ops_offset = schema::CreateSparseSegmentSum(fbb); 4894+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_SPARSE_SEGMENT_SUM), ops_offset.o); 4895+ fbb.Finish(prim_offset); 4896+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 4897+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 4898+ return ret_value; 4899+} 4900+ 4901+// ********** ScatterElements ********** 4902+PrimitivePtr MindIR_ScatterElements_CreatePrimitive(int64_t axis) { 4903+ flatbuffers::FlatBufferBuilder fbb; 4904+ auto ops_offset = schema::CreateScatterElements(fbb, axis); 4905+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_SCATTER_ELEMENTS), ops_offset.o); 4906+ fbb.Finish(prim_offset); 4907+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 4908+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 4909+ return ret_value; 4910+} 4911+ 4912+int64_t MindIR_ScatterElements_GetAxis(ConstPrimitivePtr primitive) { 4913+ if (primitive != nullptr) { 4914+ auto prim = static_cast<const schema::Primitive *>(primitive); 4915+ auto value = prim->value_as_ScatterElements(); 4916+ if (prim != nullptr && value != nullptr) { 4917+ return value->axis(); 4918+ } else { 4919+ return 0; 4920+ } 4921+ } else { 4922+ return 0; 4923+ } 4924+} 4925+ 4926+void MindIR_ScatterElements_SetAxis(PrimitivePtr *primitive, int64_t axis) { 4927+ if (primitive != nullptr && *primitive != nullptr) { 4928+ auto prim = static_cast<schema::Primitive *>(*primitive); 4929+ auto value = prim->value_as_ScatterElements(); 4930+ if (prim != nullptr && value != nullptr) { 4931+ flatbuffers::FlatBufferBuilder fbb; 4932+ auto ops_offset = schema::CreateScatterElements(fbb, axis); 4933+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_SCATTER_ELEMENTS), ops_offset.o); 4934+ fbb.Finish(prim_offset); 4935+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 4936+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 4937+ free(*primitive); 4938+ *primitive = ret_value; 4939+ } 4940+ } 4941+} 4942+ 4943+// ********** Triu ********** 4944+PrimitivePtr MindIR_Triu_CreatePrimitive() { 4945+ flatbuffers::FlatBufferBuilder fbb; 4946+ auto ops_offset = schema::CreateTriu(fbb); 4947+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_TRIU), ops_offset.o); 4948+ fbb.Finish(prim_offset); 4949+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 4950+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 4951+ return ret_value; 4952+} 4953+ 4954+// ********** Tril ********** 4955+PrimitivePtr MindIR_Tril_CreatePrimitive() { 4956+ flatbuffers::FlatBufferBuilder fbb; 4957+ auto ops_offset = schema::CreateTril(fbb); 4958+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_TRIL), ops_offset.o); 4959+ fbb.Finish(prim_offset); 4960+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 4961+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 4962+ return ret_value; 4963+} 4964+} // namespace lite 4965+} // namespace mindspore 4966diff --git a/mindspore/lite/mindir/src/mindir_tensor.cc b/mindspore/lite/mindir/src/mindir_tensor.cc 4967index 8888e2c9..0e6a631e 100644 4968--- a/mindspore/lite/mindir/src/mindir_tensor.cc 4969+++ b/mindspore/lite/mindir/src/mindir_tensor.cc 4970@@ -341,6 +341,19 @@ void MindIR_Tensor_SetQuantParams(TensorPtr *tensor, const std::vector<QuantPara 4971 } 4972 } 4973 4974+int32_t MindIR_Tensor_GetNodeType(ConstTensorPtr tensor) { 4975+ if (tensor != nullptr) { 4976+ auto value = static_cast<const schema::Tensor *>(tensor); 4977+ if (value != nullptr) { 4978+ return value->nodeType(); 4979+ } else { 4980+ return 0; 4981+ } 4982+ } else { 4983+ return 0; 4984+ } 4985+} 4986+ 4987 void MindIR_Tensor_Destroy(TensorPtr *tensor) { 4988 if (tensor != nullptr && *tensor != nullptr) { 4989 auto schema = static_cast<schema::Tensor *>(*tensor); 4990-- 49912.17.1 4992 4993