1From bcefb7478b4c90c3d09ce7c089e2cb00cd494c8e Mon Sep 17 00:00:00 2001 2From: chengfeng27 <chengfeng27@huawei.com> 3Date: Tue, 30 Jan 2024 19:55:44 +0800 4Subject: [PATCH] add mindir ops interface 5 6Signed-off-by: chengfeng27 <chengfeng27@huawei.com> 7--- 8 mindspore/lite/BUILD.gn | 5 +- 9 mindspore/lite/mindir/BUILD.gn | 15 +- 10 mindspore/lite/mindir/include/mindir.h | 152 +- 11 mindspore/lite/mindir/include/mindir_tensor.h | 29 - 12 mindspore/lite/mindir/include/mindir_types.h | 21 + 13 mindspore/lite/mindir/src/mindir.cc | 1179 +++++++++++++ 14 .../src/mindir_nnrt_lite_graph_to_model.cc | 1496 ---------------- 15 .../mindir_nnrt_lite_graph_to_model_v2_0.cc | 1497 ----------------- 16 mindspore/lite/mindir/src/mindir_tensor.cc | 80 - 17 mindspore/lite/src/litert/c_api/context_c.cc | 4 + 18 .../cpu/fp32_grad/strided_slice_grad.cc | 124 +- 19 .../kernel/cpu/fp32_grad/strided_slice_grad.h | 5 + 20 mindspore/lite/src/litert/lite_model.cc | 4 +- 21 13 files changed, 1446 insertions(+), 3165 deletions(-) 22 delete mode 100644 mindspore/lite/mindir/src/mindir_nnrt_lite_graph_to_model.cc 23 delete mode 100644 mindspore/lite/mindir/src/mindir_nnrt_lite_graph_to_model_v2_0.cc 24 25diff --git a/mindspore/lite/BUILD.gn b/mindspore/lite/BUILD.gn 26index d7fe4f55..4a83f498 100644 27--- a/mindspore/lite/BUILD.gn 28+++ b/mindspore/lite/BUILD.gn 29@@ -366,6 +366,7 @@ ohos_shared_library("mindspore_lib") { 30 "../core/mindrt/:mindrt_obj", 31 "src/litert/kernel/cpu/:cpu_kernel_obj", 32 "src/common/:lite_common_mid_obj", 33+ "//third_party/flatbuffers:flatbuffers_install_action", 34 ] 35 36 sources = all_sources 37@@ -473,7 +474,8 @@ ohos_shared_library("mindspore_lib") { 38 ohos_shared_library("mindspore_ndk") { 39 deps = [ 40 ":mindspore_lib", 41- ":mindspore_train_lib" 42+ ":mindspore_train_lib", 43+ "//third_party/flatbuffers:flatbuffers_install_action", 44 ] 45 46 sources = c_api_sources 47@@ -636,6 +638,7 @@ all_train_sources += fp32_train_kernel_sources 48 ohos_shared_library("mindspore_train_lib") { 49 deps = [ 50 ":mindspore_lib", 51+ "//third_party/flatbuffers:flatbuffers_install_action", 52 ] 53 54 sources = all_train_sources 55diff --git a/mindspore/lite/mindir/BUILD.gn b/mindspore/lite/mindir/BUILD.gn 56index b1435ef7..ad4eff84 100644 57--- a/mindspore/lite/mindir/BUILD.gn 58+++ b/mindspore/lite/mindir/BUILD.gn 59@@ -19,11 +19,17 @@ import("//build/ohos.gni") 60 # "tests:mindir_test", 61 # ] 62 # } 63+ 64+config("mindir_config") { 65+ include_dirs = [ 66+ "include", 67+ ] 68+} 69+ 70 ohos_shared_library("mindir_lib") { 71 include_dirs = [ 72 "../", 73 "../../core", 74- "include", 75 "inner_headers", 76 "//third_party/flatbuffers/include", 77 "//third_party/bounds_checking_function/include", 78@@ -34,8 +40,6 @@ ohos_shared_library("mindir_lib") { 79 "src/mindir.cc", 80 "src/mindir_memory_manager.cc", 81 "src/mindir_nnrt_lite_graph.cc", 82- "src/mindir_nnrt_lite_graph_to_model.cc", 83- "src/mindir_nnrt_lite_graph_to_model_v2_0.cc", 84 "src/mindir_tensor.cc", 85 "src/utils.cc", 86 ] 87@@ -45,14 +49,17 @@ ohos_shared_library("mindir_lib") { 88 "drivers_interface_nnrt:libnnrt_proxy_2.0", 89 "hdf_core:libhdi", 90 "hilog:libhilog", 91- "ipc:ipc_core", 92 "bounds_checking_function:libsec_shared", 93 "drivers_interface_nnrt:nnrt_idl_headers" 94 ] 95+ deps = [ 96+ "//third_party/flatbuffers:flatbuffers_install_action", 97+ ] 98 configs = [ 99 "../:disable_android", 100 "../:secure_option", 101 ] 102+ public_configs = [ ":mindir_config" ] 103 defines = [ "MS_COMPILE_OHOS" ] 104 output_name = "mindir" 105 innerapi_tags = [ "platformsdk_indirect" ] 106diff --git a/mindspore/lite/mindir/include/mindir.h b/mindspore/lite/mindir/include/mindir.h 107index f47cad8c..4f633493 100644 108--- a/mindspore/lite/mindir/include/mindir.h 109+++ b/mindspore/lite/mindir/include/mindir.h 110@@ -19,25 +19,6 @@ 111 #include "mindir_lite_graph.h" 112 #include "mindir_tensor.h" 113 #include "mindir_primitive.h" 114-namespace OHOS { 115-namespace HDI { 116-namespace Nnrt { 117-namespace V1_0 { 118-struct Model; 119-} // namespace V1_0 120-} // namespace Nnrt 121-} // namespace HDI 122-} // namespace OHOS 123- 124-namespace OHOS { 125-namespace HDI { 126-namespace Nnrt { 127-namespace V2_0 { 128-struct Model; 129-} // namespace V2_0 130-} // namespace Nnrt 131-} // namespace HDI 132-} // namespace OHOS 133 134 namespace mindspore { 135 namespace schema { 136@@ -45,16 +26,6 @@ struct Attribute; 137 } 138 139 namespace lite { 140- 141-// ********** Model ********** 142-OHOS::HDI::Nnrt::V1_0::Model *MindIR_LiteGraph_To_Model(const LiteGraph *lite_graph, 143- const OHOS::HDI::Nnrt::V1_0::SharedBuffer &buffer); 144-void MindIR_Model_Destroy(OHOS::HDI::Nnrt::V1_0::Model **model); 145- 146-OHOS::HDI::Nnrt::V2_0::Model *MindIR_LiteGraph_To_Model(const LiteGraph *lite_graph, 147- const OHOS::HDI::Nnrt::V2_0::SharedBuffer &buffer); 148-void MindIR_Model_Destroy(OHOS::HDI::Nnrt::V2_0::Model **model); 149- 150 // ********** Activation ********** 151 PrimitivePtr MindIR_Activation_CreatePrimitive(ActivationType activation_type, float alpha, float min_val, 152 float max_val, bool approximate); 153@@ -440,6 +411,129 @@ PrimitivePtr MindIR_Unsqueeze_CreatePrimitive(const std::vector<int64_t> &axis); 154 std::vector<int64_t> MindIR_Unsqueeze_GetAxis(ConstPrimitivePtr primitive); 155 void MindIR_Unsqueeze_SetAxis(PrimitivePtr *primitive, const std::vector<int64_t> &axis); 156 157+// ********** Abs ********** 158+PrimitivePtr MindIR_Abs_CreatePrimitive(); 159+ 160+// ********** BroadcastTo ********** 161+PrimitivePtr MindIR_BroadcastTo_CreatePrimitive(const std::vector<int64_t> &shape); 162+std::vector<int64_t> MindIR_BroadcastTo_GetShape(ConstPrimitivePtr primitive); 163+void MindIR_BroadcastTo_SetShape(PrimitivePtr *primitive, const std::vector<int64_t> &shape); 164+ 165+// ********** ConstantOfShape ********** 166+PrimitivePtr MindIR_ConstantOfShape_CreatePrimitive(int64_t data_type, const std::vector<float> &value); 167+int64_t MindIR_ConstantOfShape_GetDataType(ConstPrimitivePtr primitive); 168+void MindIR_ConstantOfShape_SetDataType(PrimitivePtr *primitive, int64_t data_type); 169+std::vector<float> MindIR_ConstantOfShape_GetValue(ConstPrimitivePtr primitive); 170+void MindIR_ConstantOfShape_SetValue(PrimitivePtr *primitive, const std::vector<float> &value); 171+ 172+// ********** DepthToSpace ********** 173+PrimitivePtr MindIR_DepthToSpace_CreatePrimitive(int64_t block_size, Format &format, std::string mode); 174+int64_t MindIR_DepthToSpace_GetBlockSize(ConstPrimitivePtr primitive); 175+void MindIR_DepthToSpace_SetBlockSize(PrimitivePtr *primitive, int64_t block_size); 176+Format MindIR_DepthToSpace_GetFormat(ConstPrimitivePtr primitive); 177+void MindIR_DepthToSpace_SetFormat(PrimitivePtr *primitive, Format &format); 178+std::string MindIR_DepthToSpace_GetMode(ConstPrimitivePtr primitive); 179+void MindIR_DepthToSpace_SetMode(PrimitivePtr *primitive, std::string mode); 180+ 181+// ********** ExpFusion ********** 182+PrimitivePtr MindIR_ExpFusion_CreatePrimitive(float base, float scale, float shift); 183+float MindIR_ExpFusion_GetBase(ConstPrimitivePtr primitive); 184+void MindIR_ExpFusion_SetBase(PrimitivePtr *primitive, float base); 185+float MindIR_ExpFusion_GetScale(ConstPrimitivePtr primitive); 186+void MindIR_ExpFusion_SetScale(PrimitivePtr *primitive, float scale); 187+float MindIR_ExpFusion_GetShift(ConstPrimitivePtr primitive); 188+void MindIR_ExpFusion_SetShift(PrimitivePtr *primitive, float shift); 189+ 190+// ********** Flatten ********** 191+PrimitivePtr MindIR_Flatten_CreatePrimitive(int64_t axis); 192+int64_t MindIR_Flatten_GetAxis(ConstPrimitivePtr primitive); 193+void MindIR_Flatten_SetAxis(PrimitivePtr *primitive, int64_t axis); 194+ 195+// ********** InstanceNorm ********** 196+PrimitivePtr MindIR_InstanceNorm_CreatePrimitive(float epsilon); 197+float MindIR_InstanceNorm_GetEpsilon(ConstPrimitivePtr primitive); 198+void MindIR_InstanceNorm_SetEpsilon(PrimitivePtr *primitive, float epsilon); 199+ 200+// ********** Less ********** 201+PrimitivePtr MindIR_Less_CreatePrimitive(); 202+ 203+// ********** Range ********** 204+PrimitivePtr MindIR_Range_CreatePrimitive(int64_t d_type, int64_t start, int64_t limit, int64_t delta); 205+int64_t MindIR_Range_GetDType(ConstPrimitivePtr primitive); 206+void MindIR_Range_SetDType(PrimitivePtr *primitive, int64_t d_type); 207+int64_t MindIR_Range_GetStart(ConstPrimitivePtr primitive); 208+void MindIR_Range_SetStart(PrimitivePtr *primitive, int64_t start); 209+int64_t MindIR_Range_GetLimit(ConstPrimitivePtr primitive); 210+void MindIR_Range_SetLimit(PrimitivePtr *primitive, int64_t limit); 211+int64_t MindIR_Range_GetDelta(ConstPrimitivePtr primitive); 212+void MindIR_Range_SetDelta(PrimitivePtr *primitive, int64_t delta); 213+ 214+// ********** RealDiv ********** 215+PrimitivePtr MindIR_RealDiv_CreatePrimitive(); 216+ 217+// ********** Square ********** 218+PrimitivePtr MindIR_Square_CreatePrimitive(); 219+ 220+// ********** Unstack ********** 221+PrimitivePtr MindIR_Unstack_CreatePrimitive(int64_t axis); 222+int64_t MindIR_Unstack_GetAxis(ConstPrimitivePtr primitive); 223+void MindIR_Unstack_SetAxis(PrimitivePtr *primitive, int64_t axis); 224+ 225+// ********** Select ********** 226+PrimitivePtr MindIR_Select_CreatePrimitive(); 227+ 228+// ********** Erf ********** 229+PrimitivePtr MindIR_Erf_CreatePrimitive(); 230+ 231+// ********** Equal ********** 232+PrimitivePtr MindIR_Equal_CreatePrimitive(); 233+ 234+// ********** Greater ********** 235+PrimitivePtr MindIR_Greater_CreatePrimitive(); 236+ 237+// ********** GreaterEqual ********** 238+PrimitivePtr MindIR_GreaterEqual_CreatePrimitive(); 239+ 240+// ********** NotEqual ********** 241+PrimitivePtr MindIR_NotEqual_CreatePrimitive(); 242+ 243+// ********** LeakyRelu ********** 244+PrimitivePtr MindIR_LeakyRelu_CreatePrimitive(float negative_slope); 245+float MindIR_LeakyRelu_GetNegativeSlope(ConstPrimitivePtr primitive); 246+void MindIR_LeakyRelu_SetNegativeSlope(PrimitivePtr *primitive, float negative_slope); 247+ 248+// ********** LSTM ********** 249+PrimitivePtr MindIR_LSTM_CreatePrimitive( 250+ bool bidirectional, bool has_bias, int64_t input_size, int64_t hidden_size, int64_t num_layers, 251+ int64_t num_directions, float dropout, float zoneout_cell, float zoneout_hidden, int64_t proj_size); 252+bool MindIR_LSTM_GetBidirectional(ConstPrimitivePtr primitive); 253+void MindIR_LSTM_SetBidirectional(PrimitivePtr *primitive, bool bidirectional); 254+bool MindIR_LSTM_GetHasBias(ConstPrimitivePtr primitive); 255+void MindIR_LSTM_SetHasBias(PrimitivePtr *primitive, bool has_bias); 256+int64_t MindIR_LSTM_GetInputSize(ConstPrimitivePtr primitive); 257+void MindIR_LSTM_SetInputSize(PrimitivePtr *primitive, int64_t input_size); 258+int64_t MindIR_LSTM_GetHiddenSize(ConstPrimitivePtr primitive); 259+void MindIR_LSTM_SetHiddenSize(PrimitivePtr *primitive, int64_t hidden_size); 260+int64_t MindIR_LSTM_GetNumLayers(ConstPrimitivePtr primitive); 261+void MindIR_LSTM_SetNumLayers(PrimitivePtr *primitive, int64_t num_layers); 262+int64_t MindIR_LSTM_GetNumDirections(ConstPrimitivePtr primitive); 263+void MindIR_LSTM_SetNumDirections(PrimitivePtr *primitive, int64_t num_directions); 264+float MindIR_LSTM_GetDropout(ConstPrimitivePtr primitive); 265+void MindIR_LSTM_SetDropout(PrimitivePtr *primitive, float dropout); 266+float MindIR_LSTM_GetZoneoutCell(ConstPrimitivePtr primitive); 267+void MindIR_LSTM_SetZoneoutCell(PrimitivePtr *primitive, float zoneout_cell); 268+float MindIR_LSTM_GetZoneoutHidden(ConstPrimitivePtr primitive); 269+void MindIR_LSTM_SetZoneoutHidden(PrimitivePtr *primitive, float zoneout_hidden); 270+int64_t MindIR_LSTM_GetProjSize(ConstPrimitivePtr primitive); 271+void MindIR_LSTM_SetProjSize(PrimitivePtr *primitive, int64_t proj_size); 272+ 273+// ********** Clip ********** 274+PrimitivePtr MindIR_Clip_CreatePrimitive(float max, float min); 275+float MindIR_Clip_GetMax(ConstPrimitivePtr primitive); 276+void MindIR_Clip_SetMax(PrimitivePtr *primitive, float max); 277+float MindIR_Clip_GetMin(ConstPrimitivePtr primitive); 278+void MindIR_Clip_SetMin(PrimitivePtr *primitive, float min); 279+ 280 // ********** Custom ********** 281 std::vector<const mindspore::schema::Attribute *> MindIR_Custom_GetAttr(ConstPrimitivePtr primitive); 282 std::string MindIR_Attribute_GetName(const mindspore::schema::Attribute &attr); 283diff --git a/mindspore/lite/mindir/include/mindir_tensor.h b/mindspore/lite/mindir/include/mindir_tensor.h 284index 836bc8af..c1ac89bf 100644 285--- a/mindspore/lite/mindir/include/mindir_tensor.h 286+++ b/mindspore/lite/mindir/include/mindir_tensor.h 287@@ -3,26 +3,6 @@ 288 #include "mindir_lite_graph.h" 289 #include "mindir_types.h" 290 291-namespace OHOS { 292-namespace HDI { 293-namespace Nnrt { 294-namespace V1_0 { 295-struct SharedBuffer; 296-} // namespace V1_0 297-} // namespace Nnrt 298-} // namespace HDI 299-} // namespace OHOS 300- 301-namespace OHOS { 302-namespace HDI { 303-namespace Nnrt { 304-namespace V2_0 { 305-struct SharedBuffer; 306-} // namespace V2_0 307-} // namespace Nnrt 308-} // namespace HDI 309-} // namespace OHOS 310- 311 namespace mindspore { 312 namespace lite { 313 314@@ -39,15 +19,6 @@ std::vector<int32_t> MindIR_Tensor_GetDims(ConstTensorPtr tensor); 315 void MindIR_Tensor_SetDims(TensorPtr *tensor, const std::vector<int32_t> &dims); 316 Format MindIR_Tensor_GetFormat(ConstTensorPtr tensor); 317 void MindIR_Tensor_SetFormat(TensorPtr *tensor, Format format); 318- 319-OHOS::HDI::Nnrt::V1_0::SharedBuffer MindIR_Tensor_GetData(ConstTensorPtr tensor, 320- const OHOS::HDI::Nnrt::V1_0::SharedBuffer &buffer_templete, 321- uint8_t *mmap_ptr, unsigned int offset); 322- 323-OHOS::HDI::Nnrt::V2_0::SharedBuffer MindIR_Tensor_GetData_V2_0(ConstTensorPtr tensor, 324- const OHOS::HDI::Nnrt::V2_0::SharedBuffer &buffer_templete, 325- uint8_t *mmap_ptr, unsigned int offset); 326- 327 void MindIR_Tensor_SetData(TensorPtr *tensor, const std::vector<uint8_t> &data); 328 std::vector<uint8_t> MindIR_Tensor_GetData(ConstTensorPtr tensor); 329 std::vector<QuantParam> MindIR_Tensor_GetQuantParams(ConstTensorPtr tensor); 330diff --git a/mindspore/lite/mindir/include/mindir_types.h b/mindspore/lite/mindir/include/mindir_types.h 331index ad272f8e..3ee6aca1 100644 332--- a/mindspore/lite/mindir/include/mindir_types.h 333+++ b/mindspore/lite/mindir/include/mindir_types.h 334@@ -53,34 +53,51 @@ enum QuantType : int8_t { 335 336 enum NodeType : uint32_t { 337 NODE_TYPE_NONE = 0, 338+ NODE_TYPE_ABS = 1, 339 NODE_TYPE_ACTIVATION = 2, 340 NODE_TYPE_ADD_FUSION = 5, 341 NODE_TYPE_ARGMAX_FUSION = 11, 342 NODE_TYPE_AVG_POOL_FUSION = 17, 343 NODE_TYPE_BATCH_TO_SPACE_ND = 22, 344 NODE_TYPE_BIAS_ADD = 23, 345+ NODE_TYPE_BROADCAST_TO = 27, 346 NODE_TYPE_CAST = 28, 347+ NODE_TYPE_CLIP = 30, 348 NODE_TYPE_CONCAT = 31, 349 NODE_TYPE_CONV2D_FUSION = 35, 350 NODE_TYPE_CONV2D_TRANSPOSE_FUSION = 36, 351+ NODE_TYPE_CONSTANT_OF_SHAPE = 38, 352+ NODE_TYPE_DEPTH_TO_SPACE = 45, 353 NODE_TYPE_DIV_FUSION = 47, 354 NODE_TYPE_ELTWISE = 52, 355+ NODE_TYPE_EQUAL = 53, 356+ NODE_TYPE_EXPFUSION = 55, 357 NODE_TYPE_EXPAND_DIMS = 56, 358+ NODE_TYPE_FLATTEN = 61, 359 NODE_TYPE_FILL = 66, 360 NODE_TYPE_FULL_CONNECTION = 67, 361 NODE_TYPE_FUSED_BATCH_NORM = 68, 362 NODE_TYPE_GATHER = 69, 363+ NODE_TYPE_GREATER = 71, 364+ NODE_TYPE_GREATER_EQUAL = 72, 365+ NODE_TYPE_INSTANCE_NORM = 74, 366 NODE_TYPE_LAYER_NORM_FUSION = 75, 367+ NODE_TYPE_LEAKY_RELU = 76, 368+ NODE_TYPE_LESS = 77, 369 NODE_TYPE_LESS_EQUAL = 78, 370+ NODE_TYPE_LSTM = 87, 371 NODE_TYPE_MATMUL_FUSION = 89, 372 NODE_TYPE_MAXIMUM = 90, 373 NODE_TYPE_MAX_POOL_FUSION = 92, 374 NODE_TYPE_MUL_FUSION = 99, 375+ NODE_TYPE_NOT_EQUAL = 103, 376 NODE_TYPE_ONE_HOT = 105, 377 NODE_TYPE_PAD_FUSION = 107, 378 NODE_TYPE_POW_FUSION = 110, 379 NODE_TYPE_PRELU_FUSION = 112, 380 NODE_TYPE_QUANT_DTYPE_CAST = 113, 381+ NODE_TYPE_RANGE = 115, 382+ NODE_TYPE_REAL_DIV = 117, 383 NODE_TYPE_REDUCE_FUSION = 118, 384 NODE_TYPE_RESHAPE = 119, 385 NODE_TYPE_RESIZE = 120, 386@@ -93,6 +110,7 @@ enum NodeType : uint32_t { 387 NODE_TYPE_SPLIT = 145, 388 NODE_TYPE_SQRT = 146, 389 NODE_TYPE_SQUEEZE = 147, 390+ NODE_TYPE_SQUARE = 148, 391 NODE_TYPE_SQUARED_DIFFERENCE = 149, 392 NODE_TYPE_STACK = 150, 393 NODE_TYPE_STRIDED_SLICE = 151, 394@@ -101,6 +119,9 @@ enum NodeType : uint32_t { 395 NODE_TYPE_TOPK_FUSION = 161, 396 NODE_TYPE_TRANSPOSE = 162, 397 NODE_TYPE_UNSQUEEZE = 165, 398+ NODE_TYPE_UNSTACK = 166, 399+ NODE_TYPE_SELECT = 170, 400+ NODE_TYPE_ERF = 178, 401 NODE_TYPE_CUSTOM = 191, 402 }; 403 404diff --git a/mindspore/lite/mindir/src/mindir.cc b/mindspore/lite/mindir/src/mindir.cc 405index 374bbef5..36056c59 100644 406--- a/mindspore/lite/mindir/src/mindir.cc 407+++ b/mindspore/lite/mindir/src/mindir.cc 408@@ -4339,6 +4339,1185 @@ void MindIR_Unsqueeze_SetAxis(PrimitivePtr *primitive, const std::vector<int64_t 409 } 410 } 411 412+// ********** Abs ********** 413+PrimitivePtr MindIR_Abs_CreatePrimitive() { 414+ flatbuffers::FlatBufferBuilder fbb; 415+ auto ops_offset = schema::CreateAbs(fbb); 416+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_ABS), ops_offset.o); 417+ fbb.Finish(prim_offset); 418+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 419+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 420+ return ret_value; 421+} 422+ 423+// ********** BroadcastTo ********** 424+PrimitivePtr MindIR_BroadcastTo_CreatePrimitive(const std::vector<int64_t> &shape) { 425+ flatbuffers::FlatBufferBuilder fbb; 426+ auto ops_offset = schema::CreateBroadcastTo(fbb, fbb.CreateVector(shape.data(), shape.size())); 427+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_BROADCAST_TO), ops_offset.o); 428+ fbb.Finish(prim_offset); 429+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 430+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 431+ return ret_value; 432+} 433+ 434+std::vector<int64_t> MindIR_BroadcastTo_GetShape(ConstPrimitivePtr primitive) { 435+ if (primitive != nullptr) { 436+ auto prim = static_cast<const schema::Primitive *>(primitive); 437+ auto value = prim->value_as_BroadcastTo(); 438+ if (prim != nullptr && value != nullptr) { 439+ std::vector<int64_t> result; 440+ auto src = value->shape(); 441+ result.resize(src->size()); 442+ std::transform(src->begin(), src->end(), result.begin(), [](int64_t item) { return item; }); 443+ return result; 444+ } else { 445+ return {}; 446+ } 447+ } else { 448+ return {}; 449+ } 450+} 451+ 452+void MindIR_BroadcastTo_SetShape(PrimitivePtr *primitive, const std::vector<int64_t> &shape) { 453+ if (primitive != nullptr && *primitive != nullptr) { 454+ auto prim = static_cast<schema::Primitive *>(*primitive); 455+ auto value = prim->value_as_BroadcastTo(); 456+ if (prim != nullptr && value != nullptr) { 457+ flatbuffers::FlatBufferBuilder fbb; 458+ auto ops_offset = schema::CreateBroadcastTo( 459+ fbb, fbb.CreateVector(shape.data(), shape.size())); 460+ auto prim_offset = 461+ schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_BROADCAST_TO), ops_offset.o); 462+ fbb.Finish(prim_offset); 463+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, prim); 464+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 465+ *primitive = ret_value; 466+ } 467+ } 468+} 469+ 470+// ********** ConstantOfShape ********** 471+PrimitivePtr MindIR_ConstantOfShape_CreatePrimitive(int64_t data_type, const std::vector<float> &value) { 472+ flatbuffers::FlatBufferBuilder fbb; 473+ auto ops_offset = schema::CreateConstantOfShape(fbb, data_type, fbb.CreateVector(value.data(), value.size())); 474+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_CONSTANT_OF_SHAPE), ops_offset.o); 475+ fbb.Finish(prim_offset); 476+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 477+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 478+ return ret_value; 479+} 480+ 481+int64_t MindIR_ConstantOfShape_GetDataType(ConstPrimitivePtr primitive) { 482+ if (primitive != nullptr) { 483+ auto prim = static_cast<const schema::Primitive *>(primitive); 484+ auto value_ = prim->value_as_ConstantOfShape(); 485+ if (prim != nullptr && value_ != nullptr) { 486+ return value_->data_type(); 487+ } else { 488+ return 0; 489+ } 490+ } else { 491+ return 0; 492+ } 493+} 494+ 495+void MindIR_ConstantOfShape_SetDataType(PrimitivePtr *primitive, int64_t data_type) { 496+ if (primitive != nullptr && *primitive != nullptr) { 497+ auto prim = static_cast<schema::Primitive *>(*primitive); 498+ auto value_ = prim->value_as_ConstantOfShape(); 499+ if (prim != nullptr && value_ != nullptr) { 500+ flatbuffers::FlatBufferBuilder fbb; 501+ auto ops_offset = schema::CreateConstantOfShape(fbb, data_type, fbb.CreateVector(value_->value()->data(), value_->value()->size())); 502+ auto prim_offset = 503+ schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_CONSTANT_OF_SHAPE), ops_offset.o); 504+ fbb.Finish(prim_offset); 505+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, prim); 506+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 507+ *primitive = ret_value; 508+ } 509+ } 510+} 511+ 512+std::vector<float> MindIR_ConstantOfShape_GetValue(ConstPrimitivePtr primitive) { 513+ if (primitive != nullptr) { 514+ auto prim = static_cast<const schema::Primitive *>(primitive); 515+ auto value_ = prim->value_as_ConstantOfShape(); 516+ if (prim != nullptr && value_ != nullptr) { 517+ std::vector<float> result; 518+ auto src = value_->value(); 519+ result.resize(src->size()); 520+ std::transform(src->begin(), src->end(), result.begin(), [](float item) { return item; }); 521+ return result; 522+ } else { 523+ return {}; 524+ } 525+ } else { 526+ return {}; 527+ } 528+} 529+ 530+void MindIR_ConstantOfShape_SetValue(PrimitivePtr *primitive, const std::vector<float> &value) { 531+ if (primitive != nullptr && *primitive != nullptr) { 532+ auto prim = static_cast<schema::Primitive *>(*primitive); 533+ auto value_ = prim->value_as_ConstantOfShape(); 534+ if (prim != nullptr && value_ != nullptr) { 535+ flatbuffers::FlatBufferBuilder fbb; 536+ auto ops_offset = schema::CreateConstantOfShape( 537+ fbb, value_->data_type(), fbb.CreateVector(value.data(), value.size())); 538+ auto prim_offset = 539+ schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_CONSTANT_OF_SHAPE), ops_offset.o); 540+ fbb.Finish(prim_offset); 541+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, prim); 542+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 543+ *primitive = ret_value; 544+ } 545+ } 546+} 547+ 548+// ********** DepthToSpace ********** 549+PrimitivePtr MindIR_DepthToSpace_CreatePrimitive(int64_t block_size, Format &format, std::string mode) { 550+ flatbuffers::FlatBufferBuilder fbb; 551+ auto ops_offset = schema::CreateDepthToSpace(fbb, block_size, static_cast<schema::Format>(format), fbb.CreateString(mode)); 552+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_DEPTH_TO_SPACE), ops_offset.o); 553+ fbb.Finish(prim_offset); 554+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 555+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 556+ return ret_value; 557+} 558+ 559+int64_t MindIR_DepthToSpace_GetBlockSize(ConstPrimitivePtr primitive) { 560+ if (primitive != nullptr) { 561+ auto prim = static_cast<const schema::Primitive *>(primitive); 562+ auto value = prim->value_as_DepthToSpace(); 563+ if (prim != nullptr && value != nullptr) { 564+ return value->block_size(); 565+ } else { 566+ return 0; 567+ } 568+ } else { 569+ return 0; 570+ } 571+} 572+ 573+void MindIR_DepthToSpace_SetBlockSize(PrimitivePtr *primitive, int64_t block_size) { 574+ if (primitive != nullptr && *primitive != nullptr) { 575+ auto prim = static_cast<schema::Primitive *>(*primitive); 576+ auto value = prim->value_as_DepthToSpace(); 577+ if (prim != nullptr && value != nullptr) { 578+ flatbuffers::FlatBufferBuilder fbb; 579+ auto ops_offset = schema::CreateDepthToSpace(fbb, block_size, static_cast<schema::Format>(value->format()), 580+ fbb.CreateString(std::string(value->mode()->c_str(), value->mode()->size()))); 581+ auto prim_offset = 582+ schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_DEPTH_TO_SPACE), ops_offset.o); 583+ fbb.Finish(prim_offset); 584+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, prim); 585+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 586+ *primitive = ret_value; 587+ } 588+ } 589+} 590+ 591+Format MindIR_DepthToSpace_GetFormat(ConstPrimitivePtr primitive) { 592+ if (primitive != nullptr) { 593+ auto prim = static_cast<const schema::Primitive *>(primitive); 594+ auto value = prim->value_as_DepthToSpace(); 595+ if (prim != nullptr && value != nullptr) { 596+ return static_cast<Format>(value->format()); 597+ } else { 598+ Format en = static_cast<Format>(0); 599+ return en; 600+ } 601+ } else { 602+ Format en = static_cast<Format>(0); 603+ return en; 604+ } 605+} 606+ 607+void MindIR_DepthToSpace_SetFormat(PrimitivePtr *primitive, Format &format) { 608+ if (primitive != nullptr && *primitive != nullptr) { 609+ auto prim = static_cast<schema::Primitive *>(*primitive); 610+ auto value = prim->value_as_DepthToSpace(); 611+ if (prim != nullptr && value != nullptr) { 612+ flatbuffers::FlatBufferBuilder fbb; 613+ auto ops_offset = schema::CreateDepthToSpace(fbb, value->block_size(), static_cast<schema::Format>(format), 614+ fbb.CreateString(std::string(value->mode()->c_str(), value->mode()->size()))); 615+ auto prim_offset = 616+ schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_DEPTH_TO_SPACE), ops_offset.o); 617+ fbb.Finish(prim_offset); 618+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, prim); 619+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 620+ *primitive = ret_value; 621+ } 622+ } 623+} 624+ 625+std::string MindIR_DepthToSpace_GetMode(ConstPrimitivePtr primitive) { 626+ if (primitive != nullptr) { 627+ auto prim = static_cast<const schema::Primitive *>(primitive); 628+ auto value = prim->value_as_DepthToSpace(); 629+ if (prim != nullptr && value != nullptr) { 630+ return std::string(value->mode()->c_str(),value->mode()->size()); 631+ } else { 632+ return nullptr; 633+ } 634+ } else { 635+ return nullptr; 636+ } 637+} 638+ 639+void MindIR_DepthToSpace_SetMode(PrimitivePtr *primitive, std::string mode) { 640+ if (primitive != nullptr && *primitive != nullptr) { 641+ auto prim = static_cast<schema::Primitive *>(*primitive); 642+ auto value = prim->value_as_DepthToSpace(); 643+ if (prim != nullptr && value != nullptr) { 644+ flatbuffers::FlatBufferBuilder fbb; 645+ auto ops_offset = schema::CreateDepthToSpace(fbb, value->block_size(), static_cast<schema::Format>(value->format()), fbb.CreateString(mode)); 646+ auto prim_offset = 647+ schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_DEPTH_TO_SPACE), ops_offset.o); 648+ fbb.Finish(prim_offset); 649+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, prim); 650+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 651+ *primitive = ret_value; 652+ } 653+ } 654+} 655+ 656+// ********** ExpFusion ********** 657+PrimitivePtr MindIR_ExpFusion_CreatePrimitive(float base, float scale, float shift) { 658+ flatbuffers::FlatBufferBuilder fbb; 659+ auto ops_offset = schema::CreateExpFusion(fbb, base, scale, shift); 660+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_EXPFUSION), ops_offset.o); 661+ fbb.Finish(prim_offset); 662+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 663+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 664+ return ret_value; 665+} 666+ 667+float MindIR_ExpFusion_GetBase(ConstPrimitivePtr primitive) { 668+ if (primitive != nullptr) { 669+ auto prim = static_cast<const schema::Primitive *>(primitive); 670+ auto value = prim->value_as_ExpFusion(); 671+ if (prim != nullptr && value != nullptr) { 672+ return value->base(); 673+ } else { 674+ return .0; 675+ } 676+ } else { 677+ return .0; 678+ } 679+} 680+ 681+void MindIR_ExpFusion_SetBase(PrimitivePtr *primitive, float base) { 682+ if (primitive != nullptr && *primitive != nullptr) { 683+ auto prim = static_cast<schema::Primitive *>(*primitive); 684+ auto value = prim->value_as_ExpFusion(); 685+ if (prim != nullptr && value != nullptr) { 686+ flatbuffers::FlatBufferBuilder fbb; 687+ auto ops_offset = schema::CreateExpFusion(fbb, base, value->scale(), value->shift()); 688+ auto prim_offset = 689+ schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_EXPFUSION), ops_offset.o); 690+ fbb.Finish(prim_offset); 691+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, prim); 692+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 693+ *primitive = ret_value; 694+ } 695+ } 696+} 697+ 698+float MindIR_ExpFusion_GetScale(ConstPrimitivePtr primitive) { 699+ if (primitive != nullptr) { 700+ auto prim = static_cast<const schema::Primitive *>(primitive); 701+ auto value = prim->value_as_ExpFusion(); 702+ if (prim != nullptr && value != nullptr) { 703+ return value->scale(); 704+ } else { 705+ return .0; 706+ } 707+ } else { 708+ return .0; 709+ } 710+} 711+ 712+void MindIR_ExpFusion_SetScale(PrimitivePtr *primitive, float scale) { 713+ if (primitive != nullptr && *primitive != nullptr) { 714+ auto prim = static_cast<schema::Primitive *>(*primitive); 715+ auto value = prim->value_as_ExpFusion(); 716+ if (prim != nullptr && value != nullptr) { 717+ flatbuffers::FlatBufferBuilder fbb; 718+ auto ops_offset = schema::CreateExpFusion(fbb, value->base(), scale, value->shift()); 719+ auto prim_offset = 720+ schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_EXPFUSION), ops_offset.o); 721+ fbb.Finish(prim_offset); 722+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, prim); 723+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 724+ *primitive = ret_value; 725+ } 726+ } 727+} 728+ 729+float MindIR_ExpFusion_GetShift(ConstPrimitivePtr primitive) { 730+ if (primitive != nullptr) { 731+ auto prim = static_cast<const schema::Primitive *>(primitive); 732+ auto value = prim->value_as_ExpFusion(); 733+ if (prim != nullptr && value != nullptr) { 734+ return value->shift(); 735+ } else { 736+ return .0; 737+ } 738+ } else { 739+ return .0; 740+ } 741+} 742+ 743+void MindIR_ExpFusion_SetShift(PrimitivePtr *primitive, float shift) { 744+ if (primitive != nullptr && *primitive != nullptr) { 745+ auto prim = static_cast<schema::Primitive *>(*primitive); 746+ auto value = prim->value_as_ExpFusion(); 747+ if (prim != nullptr && value != nullptr) { 748+ flatbuffers::FlatBufferBuilder fbb; 749+ auto ops_offset = schema::CreateExpFusion(fbb, value->base(), value->scale(), shift); 750+ auto prim_offset = 751+ schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_EXPFUSION), ops_offset.o); 752+ fbb.Finish(prim_offset); 753+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, prim); 754+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 755+ *primitive = ret_value; 756+ } 757+ } 758+} 759+ 760+// ********** Flatten ********** 761+PrimitivePtr MindIR_Flatten_CreatePrimitive(int64_t axis) { 762+ flatbuffers::FlatBufferBuilder fbb; 763+ auto ops_offset = schema::CreateFlatten(fbb, axis); 764+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_FLATTEN), ops_offset.o); 765+ fbb.Finish(prim_offset); 766+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 767+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 768+ return ret_value; 769+} 770+ 771+int64_t MindIR_Flatten_GetAxis(ConstPrimitivePtr primitive) { 772+ if (primitive != nullptr) { 773+ auto prim = static_cast<const schema::Primitive *>(primitive); 774+ auto value = prim->value_as_Flatten(); 775+ if (prim != nullptr && value != nullptr) { 776+ return value->axis(); 777+ } else { 778+ return 0; 779+ } 780+ } else { 781+ return 0; 782+ } 783+} 784+ 785+void MindIR_Flatten_SetAxis(PrimitivePtr *primitive, int64_t axis) { 786+ if (primitive != nullptr && *primitive != nullptr) { 787+ auto prim = static_cast<schema::Primitive *>(*primitive); 788+ auto value = prim->value_as_Flatten(); 789+ if (prim != nullptr && value != nullptr) { 790+ flatbuffers::FlatBufferBuilder fbb; 791+ auto ops_offset = schema::CreateFlatten(fbb, axis); 792+ auto prim_offset = 793+ schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_FLATTEN), ops_offset.o); 794+ fbb.Finish(prim_offset); 795+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, prim); 796+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 797+ *primitive = ret_value; 798+ } 799+ } 800+} 801+ 802+// ********** InstanceNorm ********** 803+PrimitivePtr MindIR_InstanceNorm_CreatePrimitive(float epsilon) { 804+ flatbuffers::FlatBufferBuilder fbb; 805+ auto ops_offset = schema::CreateInstanceNorm(fbb, epsilon); 806+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_INSTANCE_NORM), ops_offset.o); 807+ fbb.Finish(prim_offset); 808+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 809+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 810+ return ret_value; 811+} 812+ 813+float MindIR_InstanceNorm_GetEpsilon(ConstPrimitivePtr primitive) { 814+ if (primitive != nullptr) { 815+ auto prim = static_cast<const schema::Primitive *>(primitive); 816+ auto value = prim->value_as_InstanceNorm(); 817+ if (prim != nullptr && value != nullptr) { 818+ return value->epsilon(); 819+ } else { 820+ return .0; 821+ } 822+ } else { 823+ return .0; 824+ } 825+} 826+ 827+void MindIR_InstanceNorm_SetEpsilon(PrimitivePtr *primitive, float epsilon) { 828+ if (primitive != nullptr && *primitive != nullptr) { 829+ auto prim = static_cast<schema::Primitive *>(*primitive); 830+ auto value = prim->value_as_InstanceNorm(); 831+ if (prim != nullptr && value != nullptr) { 832+ flatbuffers::FlatBufferBuilder fbb; 833+ auto ops_offset = schema::CreateInstanceNorm(fbb, epsilon); 834+ auto prim_offset = 835+ schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_INSTANCE_NORM), ops_offset.o); 836+ fbb.Finish(prim_offset); 837+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, prim); 838+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 839+ *primitive = ret_value; 840+ } 841+ } 842+} 843+ 844+// ********** Less ********** 845+PrimitivePtr MindIR_Less_CreatePrimitive() { 846+ flatbuffers::FlatBufferBuilder fbb; 847+ auto ops_offset = schema::CreateLess(fbb); 848+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_LESS), ops_offset.o); 849+ fbb.Finish(prim_offset); 850+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 851+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 852+ return ret_value; 853+} 854+ 855+// ********** Range ********** 856+PrimitivePtr MindIR_Range_CreatePrimitive(int64_t d_type, int64_t start, int64_t limit, int64_t delta) { 857+ flatbuffers::FlatBufferBuilder fbb; 858+ auto ops_offset = schema::CreateRange(fbb, d_type, start, limit, delta); 859+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_RANGE), ops_offset.o); 860+ fbb.Finish(prim_offset); 861+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 862+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 863+ return ret_value; 864+} 865+ 866+int64_t MindIR_Range_GetDType(ConstPrimitivePtr primitive) { 867+ if (primitive != nullptr) { 868+ auto prim = static_cast<const schema::Primitive *>(primitive); 869+ auto value = prim->value_as_Range(); 870+ if (prim != nullptr && value != nullptr) { 871+ return value->d_type(); 872+ } else { 873+ return 0; 874+ } 875+ } else { 876+ return 0; 877+ } 878+} 879+ 880+void MindIR_Range_SetDType(PrimitivePtr *primitive, int64_t d_type) { 881+ if (primitive != nullptr && *primitive != nullptr) { 882+ auto prim = static_cast<schema::Primitive *>(*primitive); 883+ auto value = prim->value_as_Range(); 884+ if (prim != nullptr && value != nullptr) { 885+ flatbuffers::FlatBufferBuilder fbb; 886+ auto ops_offset = schema::CreateRange(fbb, d_type, value->start(), value->limit(), value->delta()); 887+ auto prim_offset = 888+ schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_RANGE), ops_offset.o); 889+ fbb.Finish(prim_offset); 890+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, prim); 891+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 892+ *primitive = ret_value; 893+ } 894+ } 895+} 896+ 897+int64_t MindIR_Range_GetStart(ConstPrimitivePtr primitive) { 898+ if (primitive != nullptr) { 899+ auto prim = static_cast<const schema::Primitive *>(primitive); 900+ auto value = prim->value_as_Range(); 901+ if (prim != nullptr && value != nullptr) { 902+ return value->start(); 903+ } else { 904+ return 0; 905+ } 906+ } else { 907+ return 0; 908+ } 909+} 910+ 911+void MindIR_Range_SetStart(PrimitivePtr *primitive, int64_t start) { 912+ if (primitive != nullptr && *primitive != nullptr) { 913+ auto prim = static_cast<schema::Primitive *>(*primitive); 914+ auto value = prim->value_as_Range(); 915+ if (prim != nullptr && value != nullptr) { 916+ flatbuffers::FlatBufferBuilder fbb; 917+ auto ops_offset = schema::CreateRange(fbb, value->d_type(), start, value->limit(), value->delta()); 918+ auto prim_offset = 919+ schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_RANGE), ops_offset.o); 920+ fbb.Finish(prim_offset); 921+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, prim); 922+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 923+ *primitive = ret_value; 924+ } 925+ } 926+} 927+ 928+int64_t MindIR_Range_GetLimit(ConstPrimitivePtr primitive) { 929+ if (primitive != nullptr) { 930+ auto prim = static_cast<const schema::Primitive *>(primitive); 931+ auto value = prim->value_as_Range(); 932+ if (prim != nullptr && value != nullptr) { 933+ return value->limit(); 934+ } else { 935+ return 0; 936+ } 937+ } else { 938+ return 0; 939+ } 940+} 941+ 942+void MindIR_Range_SetLimit(PrimitivePtr *primitive, int64_t limit) { 943+ if (primitive != nullptr && *primitive != nullptr) { 944+ auto prim = static_cast<schema::Primitive *>(*primitive); 945+ auto value = prim->value_as_Range(); 946+ if (prim != nullptr && value != nullptr) { 947+ flatbuffers::FlatBufferBuilder fbb; 948+ auto ops_offset = schema::CreateRange(fbb, value->d_type(), value->start(), limit, value->delta()); 949+ auto prim_offset = 950+ schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_RANGE), ops_offset.o); 951+ fbb.Finish(prim_offset); 952+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, prim); 953+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 954+ *primitive = ret_value; 955+ } 956+ } 957+} 958+ 959+int64_t MindIR_Range_GetDelta(ConstPrimitivePtr primitive) { 960+ if (primitive != nullptr) { 961+ auto prim = static_cast<const schema::Primitive *>(primitive); 962+ auto value = prim->value_as_Range(); 963+ if (prim != nullptr && value != nullptr) { 964+ return value->delta(); 965+ } else { 966+ return 0; 967+ } 968+ } else { 969+ return 0; 970+ } 971+} 972+ 973+void MindIR_Range_SetDelta(PrimitivePtr *primitive, int64_t delta) { 974+ if (primitive != nullptr && *primitive != nullptr) { 975+ auto prim = static_cast<schema::Primitive *>(*primitive); 976+ auto value = prim->value_as_Range(); 977+ if (prim != nullptr && value != nullptr) { 978+ flatbuffers::FlatBufferBuilder fbb; 979+ auto ops_offset = schema::CreateRange(fbb, value->d_type(), value->start(), value->limit(), delta); 980+ auto prim_offset = 981+ schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_RANGE), ops_offset.o); 982+ fbb.Finish(prim_offset); 983+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, prim); 984+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 985+ *primitive = ret_value; 986+ } 987+ } 988+} 989+ 990+// ********** RealDiv ********** 991+PrimitivePtr MindIR_RealDiv_CreatePrimitive() { 992+ flatbuffers::FlatBufferBuilder fbb; 993+ auto ops_offset = schema::CreateRealDiv(fbb); 994+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_REAL_DIV), ops_offset.o); 995+ fbb.Finish(prim_offset); 996+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 997+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 998+ return ret_value; 999+} 1000+ 1001+ 1002+// ********** Square ********** 1003+PrimitivePtr MindIR_Square_CreatePrimitive() { 1004+ flatbuffers::FlatBufferBuilder fbb; 1005+ auto ops_offset = schema::CreateSquare(fbb); 1006+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_SQUARE), ops_offset.o); 1007+ fbb.Finish(prim_offset); 1008+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1009+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1010+ return ret_value; 1011+} 1012+ 1013+// ********** Unstack ********** 1014+PrimitivePtr MindIR_Unstack_CreatePrimitive(int64_t axis) { 1015+ flatbuffers::FlatBufferBuilder fbb; 1016+ auto ops_offset = schema::CreateUnstack(fbb, axis); 1017+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_UNSTACK), ops_offset.o); 1018+ fbb.Finish(prim_offset); 1019+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1020+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1021+ return ret_value; 1022+} 1023+ 1024+int64_t MindIR_Unstack_GetAxis(ConstPrimitivePtr primitive) { 1025+ if (primitive != nullptr) { 1026+ auto prim = static_cast<const schema::Primitive *>(primitive); 1027+ auto value = prim->value_as_Unstack(); 1028+ if (prim != nullptr && value != nullptr) { 1029+ return value->axis(); 1030+ } else { 1031+ return 0; 1032+ } 1033+ } else { 1034+ return 0; 1035+ } 1036+} 1037+ 1038+void MindIR_Unstack_SetAxis(PrimitivePtr *primitive, int64_t axis) { 1039+ if (primitive != nullptr && *primitive != nullptr) { 1040+ auto prim = static_cast<schema::Primitive *>(*primitive); 1041+ auto value = prim->value_as_Unstack(); 1042+ if (prim != nullptr && value != nullptr) { 1043+ flatbuffers::FlatBufferBuilder fbb; 1044+ auto ops_offset = schema::CreateUnstack(fbb, axis); 1045+ auto prim_offset = 1046+ schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_UNSTACK), ops_offset.o); 1047+ fbb.Finish(prim_offset); 1048+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, prim); 1049+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1050+ *primitive = ret_value; 1051+ } 1052+ } 1053+} 1054+ 1055+// ********** Select ********** 1056+PrimitivePtr MindIR_Select_CreatePrimitive() { 1057+ flatbuffers::FlatBufferBuilder fbb; 1058+ auto ops_offset = schema::CreateSelect(fbb); 1059+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_SELECT), ops_offset.o); 1060+ fbb.Finish(prim_offset); 1061+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1062+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1063+ return ret_value; 1064+} 1065+ 1066+// ********** Erf ********** 1067+PrimitivePtr MindIR_Erf_CreatePrimitive() { 1068+ flatbuffers::FlatBufferBuilder fbb; 1069+ auto ops_offset = schema::CreateErf(fbb); 1070+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_ERF), ops_offset.o); 1071+ fbb.Finish(prim_offset); 1072+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1073+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1074+ return ret_value; 1075+} 1076+ 1077+// ********** Equal ********** 1078+PrimitivePtr MindIR_Equal_CreatePrimitive() { 1079+ flatbuffers::FlatBufferBuilder fbb; 1080+ auto ops_offset = schema::CreateEqual(fbb); 1081+ auto prim_offset = 1082+ schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_EQUAL), ops_offset.o); 1083+ fbb.Finish(prim_offset); 1084+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1085+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1086+ return ret_value; 1087+} 1088+ 1089+// ********** Greater ********** 1090+PrimitivePtr MindIR_Greater_CreatePrimitive() { 1091+ flatbuffers::FlatBufferBuilder fbb; 1092+ auto ops_offset = schema::CreateGreater(fbb); 1093+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_GREATER), ops_offset.o); 1094+ fbb.Finish(prim_offset); 1095+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1096+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1097+ return ret_value; 1098+} 1099+ 1100+// ********** GreaterEqual ********** 1101+PrimitivePtr MindIR_GreaterEqual_CreatePrimitive() { 1102+ flatbuffers::FlatBufferBuilder fbb; 1103+ auto ops_offset = schema::CreateGreaterEqual(fbb); 1104+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_GREATER_EQUAL), ops_offset.o); 1105+ fbb.Finish(prim_offset); 1106+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1107+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1108+ return ret_value; 1109+} 1110+ 1111+// ********** NotEqual ********** 1112+PrimitivePtr MindIR_NotEqual_CreatePrimitive() { 1113+ flatbuffers::FlatBufferBuilder fbb; 1114+ auto ops_offset = schema::CreateNotEqual(fbb); 1115+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_NOT_EQUAL), ops_offset.o); 1116+ fbb.Finish(prim_offset); 1117+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1118+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1119+ return ret_value; 1120+} 1121+ 1122+// ********** LeakyRelu ********** 1123+PrimitivePtr MindIR_LeakyRelu_CreatePrimitive(float negative_slope) { 1124+ flatbuffers::FlatBufferBuilder fbb; 1125+ auto ops_offset = schema::CreateLeakyRelu(fbb, negative_slope); 1126+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_LEAKY_RELU), ops_offset.o); 1127+ fbb.Finish(prim_offset); 1128+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1129+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1130+ return ret_value; 1131+} 1132+ 1133+float MindIR_LeakyRelu_GetNegativeSlope(ConstPrimitivePtr primitive) { 1134+ if (primitive != nullptr) { 1135+ auto prim = static_cast<const schema::Primitive *>(primitive); 1136+ auto value = prim->value_as_LeakyRelu(); 1137+ if (prim != nullptr && value != nullptr) { 1138+ return value->negative_slope(); 1139+ } else { 1140+ return .0; 1141+ } 1142+ } else { 1143+ return .0; 1144+ } 1145+} 1146+ 1147+void MindIR_LeakyRelu_SetNegativeSlope(PrimitivePtr *primitive, float negative_slope) { 1148+ if (primitive != nullptr && *primitive != nullptr) { 1149+ auto prim = static_cast<schema::Primitive *>(*primitive); 1150+ auto value = prim->value_as_LeakyRelu(); 1151+ if (prim != nullptr && value != nullptr) { 1152+ flatbuffers::FlatBufferBuilder fbb; 1153+ auto ops_offset = schema::CreateInstanceNorm(fbb, negative_slope); 1154+ auto prim_offset = 1155+ schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_LEAKY_RELU), ops_offset.o); 1156+ fbb.Finish(prim_offset); 1157+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, prim); 1158+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1159+ *primitive = ret_value; 1160+ } 1161+ } 1162+} 1163+ 1164+// ********** LSTM ********** 1165+PrimitivePtr MindIR_LSTM_CreatePrimitive( 1166+ bool bidirectional, bool has_bias, int64_t input_size, int64_t hidden_size, int64_t num_layers, 1167+ int64_t num_directions, float dropout, float zoneout_cell, float zoneout_hidden, int64_t proj_size) { 1168+ flatbuffers::FlatBufferBuilder fbb; 1169+ auto ops_offset = schema::CreateLSTM(fbb, bidirectional, has_bias, input_size, hidden_size, num_layers, 1170+ num_directions,dropout, zoneout_cell, zoneout_hidden, proj_size); 1171+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_LSTM), ops_offset.o); 1172+ fbb.Finish(prim_offset); 1173+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1174+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1175+ return ret_value; 1176+} 1177+ 1178+bool MindIR_LSTM_GetBidirectional(ConstPrimitivePtr primitive) { 1179+ if (primitive != nullptr) { 1180+ auto prim = static_cast<const schema::Primitive *>(primitive); 1181+ auto value = prim->value_as_LSTM(); 1182+ if (prim != nullptr && value != nullptr) { 1183+ return value->bidirectional(); 1184+ } else { 1185+ return false; 1186+ } 1187+ } else { 1188+ return false; 1189+ } 1190+} 1191+ 1192+void MindIR_LSTM_SetBidirectional(PrimitivePtr *primitive, bool bidirectional) { 1193+ if (primitive != nullptr && *primitive != nullptr) { 1194+ auto prim = static_cast<schema::Primitive *>(*primitive); 1195+ auto value = prim->value_as_LSTM(); 1196+ if (prim != nullptr && value != nullptr) { 1197+ flatbuffers::FlatBufferBuilder fbb; 1198+ auto ops_offset = 1199+ schema::CreateLSTM(fbb, bidirectional, value->has_bias(), value->input_size(), value->hidden_size(), 1200+ value->num_layers(), value->num_directions(), value->dropout(), value->zoneout_cell(), 1201+ value->zoneout_hidden(), value->proj_size()); 1202+ auto prim_offset = 1203+ schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_LSTM), ops_offset.o); 1204+ fbb.Finish(prim_offset); 1205+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, prim); 1206+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1207+ *primitive = ret_value; 1208+ } 1209+ } 1210+} 1211+ 1212+bool MindIR_LSTM_GetHasBias(ConstPrimitivePtr primitive) { 1213+ if (primitive != nullptr) { 1214+ auto prim = static_cast<const schema::Primitive *>(primitive); 1215+ auto value = prim->value_as_LSTM(); 1216+ if (prim != nullptr && value != nullptr) { 1217+ return value->has_bias(); 1218+ } else { 1219+ return false; 1220+ } 1221+ } else { 1222+ return false; 1223+ } 1224+} 1225+ 1226+void MindIR_LSTM_SetHasBias(PrimitivePtr *primitive, bool has_bias) { 1227+ if (primitive != nullptr && *primitive != nullptr) { 1228+ auto prim = static_cast<schema::Primitive *>(*primitive); 1229+ auto value = prim->value_as_LSTM(); 1230+ if (prim != nullptr && value != nullptr) { 1231+ flatbuffers::FlatBufferBuilder fbb; 1232+ auto ops_offset = 1233+ schema::CreateLSTM(fbb, value->bidirectional(), has_bias, value->input_size(), value->hidden_size(), 1234+ value->num_layers(), value->num_directions(), value->dropout(), value->zoneout_cell(), 1235+ value->zoneout_hidden(), value->proj_size()); 1236+ auto prim_offset = 1237+ schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_LSTM), ops_offset.o); 1238+ fbb.Finish(prim_offset); 1239+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, prim); 1240+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1241+ *primitive = ret_value; 1242+ } 1243+ } 1244+} 1245+ 1246+int64_t MindIR_LSTM_GetInputSize(ConstPrimitivePtr primitive) { 1247+ if (primitive != nullptr) { 1248+ auto prim = static_cast<const schema::Primitive *>(primitive); 1249+ auto value = prim->value_as_LSTM(); 1250+ if (prim != nullptr && value != nullptr) { 1251+ return value->input_size(); 1252+ } else { 1253+ return 0; 1254+ } 1255+ } else { 1256+ return 0; 1257+ } 1258+} 1259+ 1260+void MindIR_LSTM_SetInputSize(PrimitivePtr *primitive, int64_t input_size) { 1261+ if (primitive != nullptr && *primitive != nullptr) { 1262+ auto prim = static_cast<schema::Primitive *>(*primitive); 1263+ auto value = prim->value_as_LSTM(); 1264+ if (prim != nullptr && value != nullptr) { 1265+ flatbuffers::FlatBufferBuilder fbb; 1266+ auto ops_offset = 1267+ schema::CreateLSTM(fbb, value->bidirectional(), value->has_bias(), input_size, value->hidden_size(), 1268+ value->num_layers(), value->num_directions(), value->dropout(), value->zoneout_cell(), 1269+ value->zoneout_hidden(), value->proj_size()); 1270+ auto prim_offset = 1271+ schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_LSTM), ops_offset.o); 1272+ fbb.Finish(prim_offset); 1273+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, prim); 1274+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1275+ *primitive = ret_value; 1276+ } 1277+ } 1278+} 1279+ 1280+int64_t MindIR_LSTM_GetHiddenSize(ConstPrimitivePtr primitive) { 1281+ if (primitive != nullptr) { 1282+ auto prim = static_cast<const schema::Primitive *>(primitive); 1283+ auto value = prim->value_as_LSTM(); 1284+ if (prim != nullptr && value != nullptr) { 1285+ return value->hidden_size(); 1286+ } else { 1287+ return 0; 1288+ } 1289+ } else { 1290+ return 0; 1291+ } 1292+} 1293+ 1294+void MindIR_LSTM_SetHiddenSize(PrimitivePtr *primitive, int64_t hidden_size) { 1295+ if (primitive != nullptr && *primitive != nullptr) { 1296+ auto prim = static_cast<schema::Primitive *>(*primitive); 1297+ auto value = prim->value_as_LSTM(); 1298+ if (prim != nullptr && value != nullptr) { 1299+ flatbuffers::FlatBufferBuilder fbb; 1300+ auto ops_offset = 1301+ schema::CreateLSTM(fbb, value->bidirectional(), value->has_bias(), value->input_size(), hidden_size, 1302+ value->num_layers(), value->num_directions(), value->dropout(), value->zoneout_cell(), 1303+ value->zoneout_hidden(), value->proj_size()); 1304+ auto prim_offset = 1305+ schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_LSTM), ops_offset.o); 1306+ fbb.Finish(prim_offset); 1307+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, prim); 1308+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1309+ *primitive = ret_value; 1310+ } 1311+ } 1312+} 1313+ 1314+int64_t MindIR_LSTM_GetNumLayers(ConstPrimitivePtr primitive) { 1315+ if (primitive != nullptr) { 1316+ auto prim = static_cast<const schema::Primitive *>(primitive); 1317+ auto value = prim->value_as_LSTM(); 1318+ if (prim != nullptr && value != nullptr) { 1319+ return value->num_layers(); 1320+ } else { 1321+ return 0; 1322+ } 1323+ } else { 1324+ return 0; 1325+ } 1326+} 1327+ 1328+void MindIR_LSTM_SetNumLayers(PrimitivePtr *primitive, int64_t num_layers) { 1329+ if (primitive != nullptr && *primitive != nullptr) { 1330+ auto prim = static_cast<schema::Primitive *>(*primitive); 1331+ auto value = prim->value_as_LSTM(); 1332+ if (prim != nullptr && value != nullptr) { 1333+ flatbuffers::FlatBufferBuilder fbb; 1334+ auto ops_offset = 1335+ schema::CreateLSTM(fbb, value->bidirectional(), value->has_bias(), value->input_size(), value->hidden_size(), 1336+ num_layers, value->num_directions(), value->dropout(), value->zoneout_cell(), 1337+ value->zoneout_hidden(), value->proj_size()); 1338+ auto prim_offset = 1339+ schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_LSTM), ops_offset.o); 1340+ fbb.Finish(prim_offset); 1341+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, prim); 1342+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1343+ *primitive = ret_value; 1344+ } 1345+ } 1346+} 1347+ 1348+int64_t MindIR_LSTM_GetNumDirections(ConstPrimitivePtr primitive) { 1349+ if (primitive != nullptr) { 1350+ auto prim = static_cast<const schema::Primitive *>(primitive); 1351+ auto value = prim->value_as_LSTM(); 1352+ if (prim != nullptr && value != nullptr) { 1353+ return value->num_directions(); 1354+ } else { 1355+ return 0; 1356+ } 1357+ } else { 1358+ return 0; 1359+ } 1360+} 1361+ 1362+void MindIR_LSTM_SetNumDirections(PrimitivePtr *primitive, int64_t num_directions) { 1363+ if (primitive != nullptr && *primitive != nullptr) { 1364+ auto prim = static_cast<schema::Primitive *>(*primitive); 1365+ auto value = prim->value_as_LSTM(); 1366+ if (prim != nullptr && value != nullptr) { 1367+ flatbuffers::FlatBufferBuilder fbb; 1368+ auto ops_offset = 1369+ schema::CreateLSTM(fbb, value->bidirectional(), value->has_bias(), value->input_size(), value->hidden_size(), 1370+ value->num_layers(), num_directions, value->dropout(), value->zoneout_cell(), 1371+ value->zoneout_hidden(), value->proj_size()); 1372+ auto prim_offset = 1373+ schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_LSTM), ops_offset.o); 1374+ fbb.Finish(prim_offset); 1375+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, prim); 1376+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1377+ *primitive = ret_value; 1378+ } 1379+ } 1380+} 1381+ 1382+float MindIR_LSTM_GetDropout(ConstPrimitivePtr primitive) { 1383+ if (primitive != nullptr) { 1384+ auto prim = static_cast<const schema::Primitive *>(primitive); 1385+ auto value = prim->value_as_LSTM(); 1386+ if (prim != nullptr && value != nullptr) { 1387+ return value->dropout(); 1388+ } else { 1389+ return .0; 1390+ } 1391+ } else { 1392+ return .0; 1393+ } 1394+} 1395+ 1396+void MindIR_LSTM_SetDropout(PrimitivePtr *primitive, float dropout) { 1397+ if (primitive != nullptr && *primitive != nullptr) { 1398+ auto prim = static_cast<schema::Primitive *>(*primitive); 1399+ auto value = prim->value_as_LSTM(); 1400+ if (prim != nullptr && value != nullptr) { 1401+ flatbuffers::FlatBufferBuilder fbb; 1402+ auto ops_offset = 1403+ schema::CreateLSTM(fbb, value->bidirectional(), value->has_bias(), value->input_size(), value->hidden_size(), 1404+ value->num_layers(), value->num_directions(), dropout, value->zoneout_cell(), 1405+ value->zoneout_hidden(), value->proj_size()); 1406+ auto prim_offset = 1407+ schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_LSTM), ops_offset.o); 1408+ fbb.Finish(prim_offset); 1409+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, prim); 1410+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1411+ *primitive = ret_value; 1412+ } 1413+ } 1414+} 1415+ 1416+float MindIR_LSTM_GetZoneoutCell(ConstPrimitivePtr primitive) { 1417+ if (primitive != nullptr) { 1418+ auto prim = static_cast<const schema::Primitive *>(primitive); 1419+ auto value = prim->value_as_LSTM(); 1420+ if (prim != nullptr && value != nullptr) { 1421+ return value->zoneout_cell(); 1422+ } else { 1423+ return .0; 1424+ } 1425+ } else { 1426+ return .0; 1427+ } 1428+} 1429+ 1430+void MindIR_LSTM_SetZoneoutCell(PrimitivePtr *primitive, float zoneout_cell) { 1431+ if (primitive != nullptr && *primitive != nullptr) { 1432+ auto prim = static_cast<schema::Primitive *>(*primitive); 1433+ auto value = prim->value_as_LSTM(); 1434+ if (prim != nullptr && value != nullptr) { 1435+ flatbuffers::FlatBufferBuilder fbb; 1436+ auto ops_offset = 1437+ schema::CreateLSTM(fbb, value->bidirectional(), value->has_bias(), value->input_size(), value->hidden_size(), 1438+ value->num_layers(), value->num_directions(), value->dropout(), zoneout_cell, 1439+ value->zoneout_hidden(), value->proj_size()); 1440+ auto prim_offset = 1441+ schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_LSTM), ops_offset.o); 1442+ fbb.Finish(prim_offset); 1443+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, prim); 1444+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1445+ *primitive = ret_value; 1446+ } 1447+ } 1448+} 1449+ 1450+float MindIR_LSTM_GetZoneoutHidden(ConstPrimitivePtr primitive) { 1451+ if (primitive != nullptr) { 1452+ auto prim = static_cast<const schema::Primitive *>(primitive); 1453+ auto value = prim->value_as_LSTM(); 1454+ if (prim != nullptr && value != nullptr) { 1455+ return value->zoneout_hidden(); 1456+ } else { 1457+ return .0; 1458+ } 1459+ } else { 1460+ return .0; 1461+ } 1462+} 1463+ 1464+void MindIR_LSTM_SetZoneoutHidden(PrimitivePtr *primitive, float zoneout_hidden) { 1465+ if (primitive != nullptr && *primitive != nullptr) { 1466+ auto prim = static_cast<schema::Primitive *>(*primitive); 1467+ auto value = prim->value_as_LSTM(); 1468+ if (prim != nullptr && value != nullptr) { 1469+ flatbuffers::FlatBufferBuilder fbb; 1470+ auto ops_offset = 1471+ schema::CreateLSTM(fbb, value->bidirectional(), value->has_bias(), value->input_size(), value->hidden_size(), 1472+ value->num_layers(), value->num_directions(), value->dropout(), value->zoneout_cell(), 1473+ zoneout_hidden, value->proj_size()); 1474+ auto prim_offset = 1475+ schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_LSTM), ops_offset.o); 1476+ fbb.Finish(prim_offset); 1477+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, prim); 1478+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1479+ *primitive = ret_value; 1480+ } 1481+ } 1482+} 1483+ 1484+int64_t MindIR_LSTM_GetProjSize(ConstPrimitivePtr primitive) { 1485+ if (primitive != nullptr) { 1486+ auto prim = static_cast<const schema::Primitive *>(primitive); 1487+ auto value = prim->value_as_LSTM(); 1488+ if (prim != nullptr && value != nullptr) { 1489+ return value->proj_size(); 1490+ } else { 1491+ return 0; 1492+ } 1493+ } else { 1494+ return 0; 1495+ } 1496+} 1497+ 1498+void MindIR_LSTM_SetProjSize(PrimitivePtr *primitive, int64_t proj_size) { 1499+ if (primitive != nullptr && *primitive != nullptr) { 1500+ auto prim = static_cast<schema::Primitive *>(*primitive); 1501+ auto value = prim->value_as_LSTM(); 1502+ if (prim != nullptr && value != nullptr) { 1503+ flatbuffers::FlatBufferBuilder fbb; 1504+ auto ops_offset = 1505+ schema::CreateLSTM(fbb, value->bidirectional(), value->has_bias(), value->input_size(), value->hidden_size(), 1506+ value->num_layers(), value->num_directions(), value->dropout(), value->zoneout_cell(), 1507+ value->zoneout_hidden(), proj_size); 1508+ auto prim_offset = 1509+ schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_LSTM), ops_offset.o); 1510+ fbb.Finish(prim_offset); 1511+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, prim); 1512+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1513+ *primitive = ret_value; 1514+ } 1515+ } 1516+} 1517+ 1518+// ********** Clip ********** 1519+PrimitivePtr MindIR_Clip_CreatePrimitive(float max, float min) { 1520+ flatbuffers::FlatBufferBuilder fbb; 1521+ auto ops_offset = schema::CreateClip(fbb, max, min); 1522+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_CLIP), ops_offset.o); 1523+ fbb.Finish(prim_offset); 1524+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1525+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1526+ return ret_value; 1527+} 1528+ 1529+float MindIR_Clip_GetMax(ConstPrimitivePtr primitive) { 1530+ if (primitive != nullptr) { 1531+ auto prim = static_cast<const schema::Primitive *>(primitive); 1532+ auto value = prim->value_as_Clip(); 1533+ if (prim != nullptr && value != nullptr) { 1534+ return value->max(); 1535+ } else { 1536+ return .0; 1537+ } 1538+ } else { 1539+ return .0; 1540+ } 1541+} 1542+ 1543+void MindIR_Clip_SetMax(PrimitivePtr *primitive, float max) { 1544+ if (primitive != nullptr && *primitive != nullptr) { 1545+ auto prim = static_cast<schema::Primitive *>(*primitive); 1546+ auto value = prim->value_as_Clip(); 1547+ if (prim != nullptr && value != nullptr) { 1548+ flatbuffers::FlatBufferBuilder fbb; 1549+ auto ops_offset = schema::CreateClip(fbb, max, value->min()); 1550+ auto prim_offset = 1551+ schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_CLIP), ops_offset.o); 1552+ fbb.Finish(prim_offset); 1553+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, prim); 1554+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1555+ *primitive = ret_value; 1556+ } 1557+ } 1558+} 1559+ 1560+float MindIR_Clip_GetMin(ConstPrimitivePtr primitive) { 1561+ if (primitive != nullptr) { 1562+ auto prim = static_cast<const schema::Primitive *>(primitive); 1563+ auto value = prim->value_as_Clip(); 1564+ if (prim != nullptr && value != nullptr) { 1565+ return value->min(); 1566+ } else { 1567+ return .0; 1568+ } 1569+ } else { 1570+ return .0; 1571+ } 1572+} 1573+ 1574+void MindIR_Clip_SetMin(PrimitivePtr *primitive, float min) { 1575+ if (primitive != nullptr && *primitive != nullptr) { 1576+ auto prim = static_cast<schema::Primitive *>(*primitive); 1577+ auto value = prim->value_as_Clip(); 1578+ if (prim != nullptr && value != nullptr) { 1579+ flatbuffers::FlatBufferBuilder fbb; 1580+ auto ops_offset = schema::CreateClip(fbb, value->max(), min); 1581+ auto prim_offset = 1582+ schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_CLIP), ops_offset.o); 1583+ fbb.Finish(prim_offset); 1584+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, prim); 1585+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1586+ *primitive = ret_value; 1587+ } 1588+ } 1589+} 1590+ 1591 // ********** Custom ********** 1592 std::vector<const mindspore::schema::Attribute *> MindIR_Custom_GetAttr(ConstPrimitivePtr primitive) { 1593 if (primitive == nullptr) { 1594diff --git a/mindspore/lite/mindir/src/mindir_nnrt_lite_graph_to_model.cc b/mindspore/lite/mindir/src/mindir_nnrt_lite_graph_to_model.cc 1595deleted file mode 100644 1596index df39e04b..00000000 1597--- a/mindspore/lite/mindir/src/mindir_nnrt_lite_graph_to_model.cc 1598+++ /dev/null 1599@@ -1,1496 +0,0 @@ 1600-/** 1601- * Copyright 2021 Huawei Technologies Co., Ltd 1602- * 1603- * Licensed under the Apache License, Version 2.0 (the "License"); 1604- * you may not use this file except in compliance with the License. 1605- * You may obtain a copy of the License at 1606- * 1607- * http://www.apache.org/licenses/LICENSE-2.0 1608- * 1609- * Unless required by applicable law or agreed to in writing, software 1610- * distributed under the License is distributed on an "AS IS" BASIS, 1611- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 1612- * See the License for the specific language governing permissions and 1613- * limitations under the License. 1614- */ 1615-#include "mindir.h" 1616-#include <vector> 1617-#include <algorithm> 1618-#include <sys/mman.h> 1619-#include "src/common/log.h" 1620-#include "lite_graph.h" 1621-#include "schema/model_generated.h" 1622-#include "mindir_types.h" 1623-#include "message_parcel.h" 1624-#include "nnrt/v1_0/nnrt_types.h" 1625-#include "nnrt/v1_0/node_attr_types.h" 1626-#include "nnrt/v1_0/model_types.h" 1627- 1628-using namespace OHOS::HDI::Nnrt::V1_0; 1629-namespace mindspore { 1630-namespace lite { 1631- 1632-constexpr size_t kNumTwo = 2; 1633-constexpr size_t kNumFour = 4; 1634-constexpr size_t kNumEight = 8; 1635- 1636-inline std::vector<OHOS::HDI::Nnrt::V1_0::QuantParam> MindIR_Tensor_GetQuantParams_OHOS(TensorPtr tensor) { 1637- if (tensor != nullptr) { 1638- auto value = static_cast<schema::Tensor *>(tensor); 1639- 1640- if (value != nullptr) { 1641- std::vector<OHOS::HDI::Nnrt::V1_0::QuantParam> result; 1642- auto src = value->quantParams(); 1643- if (src == nullptr) { 1644- return {}; 1645- } 1646- size_t size = src->size(); 1647- result.reserve(src->size()); 1648- for (size_t i = 0; i < size; i++) { 1649- auto tmp = src->Get(i); 1650- OHOS::HDI::Nnrt::V1_0::QuantParam quantParam{tmp->numBits(), tmp->zeroPoint(), tmp->scale()}; 1651- result.emplace_back(quantParam); 1652- } 1653- return result; 1654- } else { 1655- return {}; 1656- } 1657- } else { 1658- return {}; 1659- } 1660-} 1661- 1662-void MindIR_Model_Destroy(OHOS::HDI::Nnrt::V1_0::Model **model) { 1663- if (model != nullptr) { 1664- auto model_data = *model; 1665- if (model_data != nullptr) { 1666- delete (model_data); 1667- *model = nullptr; 1668- } else { 1669- MS_LOG(ERROR) << "*model is nullptr, desrtoy model fail."; 1670- } 1671- } 1672-} 1673- 1674-OHOS::HDI::Nnrt::V1_0::Model *MindIR_LiteGraph_To_Model(const LiteGraph *lite_graph, const OHOS::HDI::Nnrt::V1_0::SharedBuffer &buffer) { 1675- if (lite_graph != nullptr) { 1676- MS_LOG(INFO) << "MindIR_LiteGraph_To_Model begin"; 1677- if (!lite_graph->name_.empty()) { 1678- MS_LOG(INFO) << "Start converting lite graph,name =" << lite_graph->name_; 1679- } else { 1680- MS_LOG(INFO) << "Start converting lite graph, but lite graph has no name."; 1681- } 1682- std::vector<uint32_t> inputIndex; 1683- std::vector<uint32_t> outputIndex; 1684- std::vector<OHOS::HDI::Nnrt::V1_0::Node> nodes; 1685- std::vector<OHOS::HDI::Nnrt::V1_0::Tensor> allTensors; 1686- std::vector<OHOS::HDI::Nnrt::V1_0::SubGraph> subGraph; 1687- // nodes 1688- MS_LOG(INFO) << "Start converting nodes, vector size = " << lite_graph->all_nodes_.size(); 1689- nodes.reserve(lite_graph->all_nodes_.size()); 1690- for (auto node : lite_graph->all_nodes_) { 1691- if (node == nullptr) { 1692- MS_LOG(ERROR) << "node is nullptr, convert fail."; 1693- return nullptr; 1694- } 1695- OHOS::HDI::Nnrt::V1_0::Node tmp; 1696- tmp.name = node->name_; 1697- if (node->primitive_ == nullptr) { 1698- MS_LOG(ERROR) << "node primitive is nullptr, convert fail."; 1699- return nullptr; 1700- } 1701- auto prim = static_cast<schema::Primitive *>(node->primitive_); 1702- auto value = prim->value_type(); 1703- tmp.nodeType = static_cast<HDI::Nnrt::V1_0::NodeType>(value); 1704- tmp.nodeAttr = Convert(static_cast<NodeType>(value), node->primitive_); 1705- tmp.inputIndex = node->input_indices_; 1706- tmp.outputIndex = node->output_indices_; 1707- tmp.quantType = static_cast<HDI::Nnrt::V1_0::QuantType>(node->quant_type_); 1708- nodes.emplace_back(tmp); 1709- } 1710- 1711- MS_LOG(INFO) << "Start converting Tensor,Tensor size=" << lite_graph->all_tensors_.size(); 1712- // Tensor 1713- allTensors.reserve(lite_graph->all_tensors_.size()); 1714- unsigned int tensor_buffer_offset = 0; 1715- uint8_t *mmap_ptr = nullptr; 1716- if (buffer.fd != -1) { 1717- mmap_ptr = 1718- static_cast<uint8_t *>(mmap(nullptr, buffer.bufferSize, PROT_READ | PROT_WRITE, MAP_SHARED, buffer.fd, 0)); 1719- if (mmap_ptr == MAP_FAILED) { 1720- MS_LOG(ERROR) << "mmap failed"; 1721- return nullptr; 1722- } 1723- } 1724- MS_LOG(INFO) << "Start parsing tensor, mmap buffer size = " << buffer.bufferSize; 1725- for (auto tensor : lite_graph->all_tensors_) { 1726- OHOS::HDI::Nnrt::V1_0::Tensor tmp; 1727- tmp.name = MindIR_Tensor_GetName(tensor); 1728- tmp.dataType = static_cast<HDI::Nnrt::V1_0::HDI::Nnrt::V1_0::DataType>(MindIR_Tensor_GetDataType(tensor)); 1729- tmp.dims = MindIR_Tensor_GetDims(tensor); 1730- tmp.format = static_cast<HDI::Nnrt::V1_0::HDI::Nnrt::V1_0::Format>(MindIR_Tensor_GetFormat(tensor)); 1731- tmp.data = MindIR_Tensor_GetData(tensor, buffer, mmap_ptr, tensor_buffer_offset); 1732- tmp.quantParams = MindIR_Tensor_GetQuantParams_OHOS(tensor); 1733- allTensors.emplace_back(tmp); 1734- tensor_buffer_offset = tmp.data.offset + tmp.data.dataSize; 1735- } 1736- MS_LOG(INFO) << ("Parsing tensor finish."); 1737- if (buffer.fd != -1) { 1738- auto munmap_res = munmap(mmap_ptr, buffer.bufferSize); 1739- if (munmap_res != 0) { 1740- MS_LOG(ERROR) << "unmap failed."; 1741- return nullptr; 1742- } 1743- } 1744- 1745- MS_LOG(INFO) << "Start converting SubGraph,SubGraph size=" << lite_graph->sub_graphs_.size(); 1746- // SubGraph 1747- subGraph.reserve(lite_graph->sub_graphs_.size()); 1748- for (auto graph : lite_graph->sub_graphs_) { 1749- OHOS::HDI::Nnrt::V1_0::SubGraph tmp; 1750- tmp.name = graph->name_; 1751- tmp.inputIndices = std::vector<uint32_t>(graph->input_indices_); 1752- tmp.outputIndices = std::vector<uint32_t>(graph->output_indices_); 1753- tmp.nodeIndices = std::vector<uint32_t>(graph->node_indices_); 1754- subGraph.emplace_back(tmp); 1755- } 1756- 1757- MS_LOG(INFO) << "Start copying model"; 1758- auto *ret_model = new (std::nothrow) Model(); 1759- if (ret_model == nullptr) { 1760- MS_LOG(ERROR) << "new Model failed."; 1761- return nullptr; 1762- } 1763- ret_model->name = lite_graph->name_; 1764- ret_model->inputIndex = lite_graph->input_indices_; 1765- ret_model->outputIndex = lite_graph->output_indices_; 1766- ret_model->nodes = nodes; 1767- ret_model->allTensors = allTensors; 1768- ret_model->subGraph = subGraph; 1769- MS_LOG(INFO) << "MindIR_LiteGraph_To_Model success"; 1770- return ret_model; 1771- } else { 1772- MS_LOG(ERROR) << "lite graph is nullptr"; 1773- return nullptr; 1774- } 1775-} 1776- 1777-std::vector<int8_t> ConvertActivation(PrimitivePtr primitive) { 1778- if (primitive != nullptr) { 1779- auto prim = static_cast<schema::Primitive *>(primitive); 1780- auto value = prim->value_as_Activation(); 1781- if (value != nullptr) { 1782- Activation activation{}; 1783- activation.activationType = 1784- static_cast<HDI::Nnrt::V1_0::HDI::Nnrt::V1_0::ActivationType>(value->activation_type()); 1785- activation.alpha = value->alpha(); 1786- activation.minVal = value->min_val(); 1787- activation.maxVal = value->max_val(); 1788- activation.approximate = value->approximate(); 1789- OHOS::MessageParcel data; 1790- (void)ActivationBlockMarshalling(data, activation); 1791- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 1792- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 1793- return ret; 1794- } else { 1795- return {}; 1796- } 1797- } else { 1798- return {}; 1799- } 1800-} 1801-std::vector<int8_t> ConvertAddFusion(PrimitivePtr primitive) { 1802- if (primitive != nullptr) { 1803- auto prim = static_cast<schema::Primitive *>(primitive); 1804- auto value = prim->value_as_AddFusion(); 1805- if (value != nullptr) { 1806- AddFusion add_fusion{}; 1807- add_fusion.activationType = static_cast<HDI::Nnrt::V1_0::ActivationType>(value->activation_type()); 1808- OHOS::MessageParcel data; 1809- (void)AddFusionBlockMarshalling(data, add_fusion); 1810- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 1811- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 1812- return ret; 1813- } else { 1814- return {}; 1815- } 1816- } else { 1817- return {}; 1818- } 1819-} 1820-std::vector<int8_t> ConvertArgMaxFusion(PrimitivePtr primitive) { 1821- if (primitive != nullptr) { 1822- auto prim = static_cast<schema::Primitive *>(primitive); 1823- auto value = prim->value_as_ArgMaxFusion(); 1824- if (value != nullptr) { 1825- ArgMaxFusion arg_max_fusion{}; 1826- arg_max_fusion.axis = value->axis(); 1827- arg_max_fusion.topK = value->top_k(); 1828- arg_max_fusion.keepDims = value->keep_dims(); 1829- arg_max_fusion.outMaxValue = value->out_max_value(); 1830- OHOS::MessageParcel data; 1831- (void)ArgMaxFusionBlockMarshalling(data, arg_max_fusion); 1832- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 1833- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 1834- return ret; 1835- } else { 1836- return {}; 1837- } 1838- } else { 1839- return {}; 1840- } 1841-} 1842-std::vector<int8_t> ConvertAvgPoolFusion(PrimitivePtr primitive) { 1843- if (primitive != nullptr) { 1844- auto prim = static_cast<schema::Primitive *>(primitive); 1845- auto value = prim->value_as_AvgPoolFusion(); 1846- if (value != nullptr) { 1847- AvgPoolFusion avg_pool_fusion{}; 1848- std::vector<int64_t> kernel_size; 1849- kernel_size.reserve(kNumTwo); 1850- if (value->kernel_size() == nullptr || value->kernel_size()->size() < kNumTwo) { 1851- kernel_size = {}; 1852- } else { 1853- kernel_size = std::vector<int64_t>(value->kernel_size()->begin(), value->kernel_size()->end()); 1854- } 1855- std::vector<int64_t> strides; 1856- strides.reserve(kNumTwo); 1857- if (value->strides() == nullptr || value->strides()->size() < kNumTwo) { 1858- strides = {}; 1859- } else { 1860- strides = std::vector<int64_t>(value->strides()->begin(), value->strides()->end()); 1861- } 1862- std::vector<int64_t> padList; 1863- strides.reserve(kNumTwo); 1864- if (value->pad() == nullptr || value->pad()->size() < kNumFour) { 1865- padList = {}; 1866- } else { 1867- padList = std::vector<int64_t>(value->pad()->begin(), value->pad()->end()); 1868- } 1869- avg_pool_fusion.kernelSize = kernel_size; 1870- avg_pool_fusion.strides = strides; 1871- avg_pool_fusion.pad = padList; 1872- avg_pool_fusion.padMode = static_cast<HDI::Nnrt::V1_0::PadMode>(value->pad_mode()); 1873- avg_pool_fusion.roundMode = static_cast<HDI::Nnrt::V1_0::RoundMode>(value->round_mode()); 1874- avg_pool_fusion.format = static_cast<HDI::Nnrt::V1_0::Format>(value->format()); 1875- avg_pool_fusion.global = value->global(); 1876- avg_pool_fusion.activationType = static_cast<HDI::Nnrt::V1_0::ActivationType>(value->activation_type()); 1877- OHOS::MessageParcel data; 1878- (void)AvgPoolFusionBlockMarshalling(data, avg_pool_fusion); 1879- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 1880- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 1881- return ret; 1882- } else { 1883- return {}; 1884- } 1885- } else { 1886- return {}; 1887- } 1888-} 1889-std::vector<int8_t> ConvertBatchToSpaceND(PrimitivePtr primitive) { 1890- if (primitive != nullptr) { 1891- auto prim = static_cast<schema::Primitive *>(primitive); 1892- auto value = prim->value_as_BatchToSpaceND(); 1893- if (value != nullptr) { 1894- BatchToSpaceND batch_to_space_n_d{}; 1895- std::vector<int64_t> blockShape; 1896- blockShape.reserve(kNumTwo); 1897- if (value->block_shape() == nullptr || value->block_shape()->size() < kNumTwo) { 1898- blockShape = {0, 0}; 1899- } else { 1900- blockShape = std::vector<int64_t>(value->block_shape()->begin(), value->block_shape()->end()); 1901- } 1902- batch_to_space_n_d.blockShape = blockShape; 1903- auto crops = value->crops(); 1904- std::vector<std::vector<int64_t>> crops_vec2d; 1905- if (crops->data() == nullptr) { 1906- MS_LOG(ERROR) << "crops_data is nullptr"; 1907- crops_vec2d = {{}}; 1908- } else { 1909- crops_vec2d.reserve(crops->data()->size()); 1910- for (size_t i = 0; i < crops->data()->size(); i++) { 1911- auto vet = crops->data()->Get(i); 1912- crops_vec2d.emplace_back(std::vector<int64_t>(vet->data()->begin(), vet->data()->end())); 1913- } 1914- } 1915- batch_to_space_n_d.crops = crops_vec2d; 1916- OHOS::MessageParcel data; 1917- (void)BatchToSpaceNDBlockMarshalling(data, batch_to_space_n_d); 1918- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 1919- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 1920- return ret; 1921- } else { 1922- return {}; 1923- } 1924- } else { 1925- return {}; 1926- } 1927-} 1928-std::vector<int8_t> ConvertBiasAdd(PrimitivePtr primitive) { 1929- if (primitive != nullptr) { 1930- auto prim = static_cast<schema::Primitive *>(primitive); 1931- auto value = prim->value_as_BiasAdd(); 1932- if (value != nullptr) { 1933- BiasAdd bias_add{}; 1934- OHOS::MessageParcel data; 1935- (void)BiasAddBlockMarshalling(data, bias_add); 1936- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 1937- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 1938- return ret; 1939- } else { 1940- return {}; 1941- } 1942- } else { 1943- return {}; 1944- } 1945-} 1946-std::vector<int8_t> ConvertCast(PrimitivePtr primitive) { 1947- if (primitive != nullptr) { 1948- auto prim = static_cast<schema::Primitive *>(primitive); 1949- auto value = prim->value_as_Cast(); 1950- if (value != nullptr) { 1951- Cast cast{}; 1952- OHOS::MessageParcel data; 1953- (void)CastBlockMarshalling(data, cast); 1954- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 1955- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 1956- return ret; 1957- } else { 1958- return {}; 1959- } 1960- } else { 1961- return {}; 1962- } 1963-} 1964-std::vector<int8_t> ConvertConcat(PrimitivePtr primitive) { 1965- if (primitive != nullptr) { 1966- auto prim = static_cast<schema::Primitive *>(primitive); 1967- auto value = prim->value_as_Concat(); 1968- if (value != nullptr) { 1969- Concat concat{}; 1970- concat.axis = value->axis(); 1971- OHOS::MessageParcel data; 1972- (void)ConcatBlockMarshalling(data, concat); 1973- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 1974- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 1975- return ret; 1976- } else { 1977- return {}; 1978- } 1979- } else { 1980- return {}; 1981- } 1982-} 1983-std::vector<int8_t> ConvertConv2DFusion(PrimitivePtr primitive) { 1984- if (primitive != nullptr) { 1985- auto prim = static_cast<schema::Primitive *>(primitive); 1986- auto value = prim->value_as_Conv2DFusion(); 1987- if (value != nullptr) { 1988- Conv2DFusion conv2_d_fusion{}; 1989- std::vector<int64_t> kernel_size; 1990- kernel_size.reserve(kNumTwo); 1991- if (value->kernel_size() == nullptr || value->kernel_size()->size() < kNumTwo) { 1992- kernel_size = {}; 1993- } else { 1994- kernel_size = std::vector<int64_t>(value->kernel_size()->begin(), value->kernel_size()->end()); 1995- } 1996- std::vector<int64_t> strides; 1997- strides.reserve(kNumTwo); 1998- if (value->stride() == nullptr || value->stride()->size() < kNumTwo) { 1999- strides = {}; 2000- } else { 2001- strides = std::vector<int64_t>(value->stride()->begin(), value->stride()->end()); 2002- } 2003- std::vector<int64_t> dilation; 2004- dilation.reserve(kNumTwo); 2005- if (value->dilation() == nullptr || value->dilation()->size() < kNumTwo) { 2006- dilation = {}; 2007- } else { 2008- dilation = std::vector<int64_t>(value->dilation()->begin(), value->dilation()->end()); 2009- } 2010- std::vector<int64_t> padList; 2011- strides.reserve(kNumTwo); 2012- if (value->pad_list() == nullptr || value->pad_list()->size() < kNumFour) { 2013- padList = {}; 2014- } else { 2015- padList = std::vector<int64_t>(value->pad_list()->begin(), value->pad_list()->end()); 2016- } 2017- conv2_d_fusion.kernelSize = kernel_size; 2018- conv2_d_fusion.stride = strides; 2019- conv2_d_fusion.dilation = dilation; 2020- conv2_d_fusion.padMode = static_cast<HDI::Nnrt::V1_0::PadMode>(value->pad_mode()); 2021- conv2_d_fusion.padList = padList; 2022- conv2_d_fusion.group = value->group(); 2023- conv2_d_fusion.inChannel = value->in_channel(); 2024- conv2_d_fusion.outChannel = value->out_channel(); 2025- conv2_d_fusion.activationType = static_cast<HDI::Nnrt::V1_0::ActivationType>(value->activation_type()); 2026- OHOS::MessageParcel data; 2027- (void)Conv2DFusionBlockMarshalling(data, conv2_d_fusion); 2028- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 2029- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 2030- return ret; 2031- } else { 2032- return {}; 2033- } 2034- } else { 2035- return {}; 2036- } 2037-} 2038-std::vector<int8_t> ConvertConv2dTransposeFusion(PrimitivePtr primitive) { 2039- if (primitive != nullptr) { 2040- auto prim = static_cast<schema::Primitive *>(primitive); 2041- auto value = prim->value_as_Conv2dTransposeFusion(); 2042- if (value != nullptr) { 2043- Conv2dTransposeFusion conv2d_transpose_fusion{}; 2044- std::vector<int64_t> kernel_size; 2045- kernel_size.reserve(kNumTwo); 2046- if (value->kernel_size() == nullptr || value->kernel_size()->size() < kNumTwo) { 2047- kernel_size = {}; 2048- } else { 2049- kernel_size = std::vector<int64_t>(value->kernel_size()->begin(), value->kernel_size()->end()); 2050- } 2051- std::vector<int64_t> strides; 2052- strides.reserve(kNumTwo); 2053- if (value->stride() == nullptr || value->stride()->size() < kNumTwo) { 2054- strides = {}; 2055- } else { 2056- strides = std::vector<int64_t>(value->stride()->begin(), value->stride()->end()); 2057- } 2058- std::vector<int64_t> dilation; 2059- dilation.reserve(kNumTwo); 2060- if (value->dilation() == nullptr || value->dilation()->size() < kNumTwo) { 2061- dilation = {}; 2062- } else { 2063- dilation = std::vector<int64_t>(value->dilation()->begin(), value->dilation()->end()); 2064- } 2065- std::vector<int64_t> padList; 2066- strides.reserve(kNumTwo); 2067- if (value->pad_list() == nullptr || value->pad_list()->size() < kNumFour) { 2068- padList = {}; 2069- } else { 2070- padList = std::vector<int64_t>(value->pad_list()->begin(), value->pad_list()->end()); 2071- } 2072- std::vector<int64_t> output_paddings; 2073- output_paddings.reserve(kNumTwo); 2074- if (value->output_paddings() == nullptr || value->output_paddings()->size() < kNumTwo) { 2075- output_paddings = {}; 2076- } else { 2077- output_paddings = std::vector<int64_t>(value->output_paddings()->begin(), value->output_paddings()->end()); 2078- } 2079- conv2d_transpose_fusion.kernelSize = kernel_size; 2080- conv2d_transpose_fusion.stride = strides; 2081- conv2d_transpose_fusion.dilation = dilation; 2082- conv2d_transpose_fusion.padMode = static_cast<HDI::Nnrt::V1_0::PadMode>(value->pad_mode()); 2083- conv2d_transpose_fusion.padList = padList; 2084- conv2d_transpose_fusion.group = value->group(); 2085- conv2d_transpose_fusion.inChannel = value->in_channel(); 2086- conv2d_transpose_fusion.outChannel = value->out_channel(); 2087- conv2d_transpose_fusion.activationType = static_cast<HDI::Nnrt::V1_0::ActivationType>(value->activation_type()); 2088- conv2d_transpose_fusion.outputPaddings = output_paddings; 2089- OHOS::MessageParcel data; 2090- (void)Conv2dTransposeFusionBlockMarshalling(data, conv2d_transpose_fusion); 2091- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 2092- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 2093- return ret; 2094- } else { 2095- return {}; 2096- } 2097- } else { 2098- return {}; 2099- } 2100-} 2101-std::vector<int8_t> ConvertDivFusion(PrimitivePtr primitive) { 2102- if (primitive != nullptr) { 2103- auto prim = static_cast<schema::Primitive *>(primitive); 2104- auto value = prim->value_as_DivFusion(); 2105- if (value != nullptr) { 2106- DivFusion div_fusion{}; 2107- div_fusion.activationType = static_cast<HDI::Nnrt::V1_0::ActivationType>(value->activation_type()); 2108- OHOS::MessageParcel data; 2109- (void)DivFusionBlockMarshalling(data, div_fusion); 2110- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 2111- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 2112- return ret; 2113- } else { 2114- return {}; 2115- } 2116- } else { 2117- return {}; 2118- } 2119-} 2120-std::vector<int8_t> ConvertEltwise(PrimitivePtr primitive) { 2121- if (primitive != nullptr) { 2122- auto prim = static_cast<schema::Primitive *>(primitive); 2123- auto value = prim->value_as_Eltwise(); 2124- if (value != nullptr) { 2125- Eltwise eltwise{}; 2126- eltwise.mode = static_cast<HDI::Nnrt::V1_0::EltwiseMode>(value->mode()); 2127- OHOS::MessageParcel data; 2128- (void)EltwiseBlockMarshalling(data, eltwise); 2129- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 2130- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 2131- return ret; 2132- } else { 2133- return {}; 2134- } 2135- } else { 2136- return {}; 2137- } 2138-} 2139-std::vector<int8_t> ConvertExpandDims(PrimitivePtr primitive) { 2140- if (primitive != nullptr) { 2141- auto prim = static_cast<schema::Primitive *>(primitive); 2142- auto value = prim->value_as_ExpandDims(); 2143- if (value != nullptr) { 2144- ExpandDims expand_dims{}; 2145- OHOS::MessageParcel data; 2146- (void)ExpandDimsBlockMarshalling(data, expand_dims); 2147- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 2148- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 2149- return ret; 2150- } else { 2151- return {}; 2152- } 2153- } else { 2154- return {}; 2155- } 2156-} 2157-std::vector<int8_t> ConvertFill(PrimitivePtr primitive) { 2158- if (primitive != nullptr) { 2159- auto prim = static_cast<schema::Primitive *>(primitive); 2160- auto value = prim->value_as_Fill(); 2161- if (value != nullptr) { 2162- Fill fill{}; 2163- OHOS::MessageParcel data; 2164- (void)FillBlockMarshalling(data, fill); 2165- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 2166- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 2167- return ret; 2168- } else { 2169- return {}; 2170- } 2171- } else { 2172- return {}; 2173- } 2174-} 2175-std::vector<int8_t> ConvertFullConnection(PrimitivePtr primitive) { 2176- if (primitive != nullptr) { 2177- auto prim = static_cast<schema::Primitive *>(primitive); 2178- auto value = prim->value_as_FullConnection(); 2179- if (value != nullptr) { 2180- FullConnection full_connection{}; 2181- full_connection.hasBias = value->has_bias(); 2182- full_connection.useAxis = value->use_axis(); 2183- full_connection.axis = value->axis(); 2184- full_connection.activationType = static_cast<HDI::Nnrt::V1_0::ActivationType>(value->activation_type()); 2185- OHOS::MessageParcel data; 2186- (void)FullConnectionBlockMarshalling(data, full_connection); 2187- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 2188- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 2189- return ret; 2190- } else { 2191- return {}; 2192- } 2193- } else { 2194- return {}; 2195- } 2196-} 2197-std::vector<int8_t> ConvertFusedBatchNorm(PrimitivePtr primitive) { 2198- if (primitive != nullptr) { 2199- auto prim = static_cast<schema::Primitive *>(primitive); 2200- auto value = prim->value_as_FusedBatchNorm(); 2201- if (value != nullptr) { 2202- FusedBatchNorm fused_batch_norm{}; 2203- fused_batch_norm.epsilon = value->epsilon(); 2204- OHOS::MessageParcel data; 2205- (void)FusedBatchNormBlockMarshalling(data, fused_batch_norm); 2206- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 2207- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 2208- return ret; 2209- } else { 2210- return {}; 2211- } 2212- } else { 2213- return {}; 2214- } 2215-} 2216-std::vector<int8_t> ConvertGather(PrimitivePtr primitive) { 2217- if (primitive != nullptr) { 2218- auto prim = static_cast<schema::Primitive *>(primitive); 2219- auto value = prim->value_as_Gather(); 2220- if (value != nullptr) { 2221- Gather gather{}; 2222- OHOS::MessageParcel data; 2223- (void)GatherBlockMarshalling(data, gather); 2224- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 2225- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 2226- return ret; 2227- } else { 2228- return {}; 2229- } 2230- } else { 2231- return {}; 2232- } 2233-} 2234-std::vector<int8_t> ConvertLayerNormFusion(PrimitivePtr primitive) { 2235- if (primitive != nullptr) { 2236- auto prim = static_cast<schema::Primitive *>(primitive); 2237- auto value = prim->value_as_LayerNormFusion(); 2238- if (value != nullptr) { 2239- LayerNormFusion layer_norm_fusion{}; 2240- layer_norm_fusion.beginNormAxis = value->begin_norm_axis(); 2241- layer_norm_fusion.epsilon = value->epsilon(); 2242- layer_norm_fusion.elementwiseAffine = value->elementwise_affine(); 2243- layer_norm_fusion.beginParamsAxis = value->begin_params_axis(); 2244- OHOS::MessageParcel data; 2245- (void)LayerNormFusionBlockMarshalling(data, layer_norm_fusion); 2246- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 2247- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 2248- return ret; 2249- } else { 2250- return {}; 2251- } 2252- } else { 2253- return {}; 2254- } 2255-} 2256-std::vector<int8_t> ConvertLessEqual(PrimitivePtr primitive) { 2257- if (primitive != nullptr) { 2258- auto prim = static_cast<schema::Primitive *>(primitive); 2259- auto value = prim->value_as_LessEqual(); 2260- if (value != nullptr) { 2261- LessEqual less_equal{}; 2262- OHOS::MessageParcel data; 2263- (void)LessEqualBlockMarshalling(data, less_equal); 2264- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 2265- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 2266- return ret; 2267- } else { 2268- return {}; 2269- } 2270- } else { 2271- return {}; 2272- } 2273-} 2274-std::vector<int8_t> ConvertMatMulFusion(PrimitivePtr primitive) { 2275- if (primitive != nullptr) { 2276- auto prim = static_cast<schema::Primitive *>(primitive); 2277- auto value = prim->value_as_MatMulFusion(); 2278- if (value != nullptr) { 2279- MatMulFusion mat_mul_fusion{}; 2280- mat_mul_fusion.transposeA = value->transpose_a(); 2281- mat_mul_fusion.transposeB = value->transpose_b(); 2282- mat_mul_fusion.activationType = static_cast<HDI::Nnrt::V1_0::ActivationType>(value->activation_type()); 2283- OHOS::MessageParcel data; 2284- (void)MatMulFusionBlockMarshalling(data, mat_mul_fusion); 2285- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 2286- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 2287- return ret; 2288- } else { 2289- return {}; 2290- } 2291- } else { 2292- return {}; 2293- } 2294-} 2295-std::vector<int8_t> ConvertMaximum(PrimitivePtr primitive) { 2296- if (primitive != nullptr) { 2297- auto prim = static_cast<schema::Primitive *>(primitive); 2298- auto value = prim->value_as_Maximum(); 2299- if (value != nullptr) { 2300- Maximum maximum{}; 2301- OHOS::MessageParcel data; 2302- (void)MaximumBlockMarshalling(data, maximum); 2303- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 2304- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 2305- return ret; 2306- } else { 2307- return {}; 2308- } 2309- } else { 2310- return {}; 2311- } 2312-} 2313-std::vector<int8_t> ConvertMaxPoolFusion(PrimitivePtr primitive) { 2314- if (primitive != nullptr) { 2315- auto prim = static_cast<schema::Primitive *>(primitive); 2316- auto value = prim->value_as_MaxPoolFusion(); 2317- if (value != nullptr) { 2318- MaxPoolFusion max_pool_fusion{}; 2319- std::vector<int64_t> kernel_size; 2320- kernel_size.reserve(kNumTwo); 2321- if (value->kernel_size() == nullptr || value->kernel_size()->size() < kNumTwo) { 2322- kernel_size = {}; 2323- } else { 2324- kernel_size = std::vector<int64_t>(value->kernel_size()->begin(), value->kernel_size()->end()); 2325- } 2326- std::vector<int64_t> strides; 2327- strides.reserve(kNumTwo); 2328- if (value->strides() == nullptr || value->strides()->size() < kNumTwo) { 2329- strides = {}; 2330- } else { 2331- strides = std::vector<int64_t>(value->strides()->begin(), value->strides()->end()); 2332- } 2333- std::vector<int64_t> padList; 2334- padList.reserve(kNumFour); 2335- if (value->pad() == nullptr || value->pad()->size() < kNumFour) { 2336- padList = {}; 2337- } else { 2338- padList = std::vector<int64_t>(value->pad()->begin(), value->pad()->end()); 2339- } 2340- max_pool_fusion.kernelSize = kernel_size; 2341- max_pool_fusion.strides = strides; 2342- max_pool_fusion.pad = padList; 2343- max_pool_fusion.padMode = static_cast<HDI::Nnrt::V1_0::PadMode>(value->pad_mode()); 2344- max_pool_fusion.format = static_cast<HDI::Nnrt::V1_0::Format>(value->format()); 2345- max_pool_fusion.global = value->global(); 2346- max_pool_fusion.activationType = static_cast<HDI::Nnrt::V1_0::ActivationType>(value->activation_type()); 2347- OHOS::MessageParcel data; 2348- (void)MaxPoolFusionBlockMarshalling(data, max_pool_fusion); 2349- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 2350- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 2351- return ret; 2352- } else { 2353- return {}; 2354- } 2355- } else { 2356- return {}; 2357- } 2358-} 2359-std::vector<int8_t> ConvertMulFusion(PrimitivePtr primitive) { 2360- if (primitive != nullptr) { 2361- auto prim = static_cast<schema::Primitive *>(primitive); 2362- auto value = prim->value_as_MulFusion(); 2363- if (value != nullptr) { 2364- MulFusion mul_fusion{}; 2365- mul_fusion.activationType = static_cast<HDI::Nnrt::V1_0::ActivationType>(value->activation_type()); 2366- OHOS::MessageParcel data; 2367- (void)MulFusionBlockMarshalling(data, mul_fusion); 2368- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 2369- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 2370- return ret; 2371- } else { 2372- return {}; 2373- } 2374- } else { 2375- return {}; 2376- } 2377-} 2378-std::vector<int8_t> ConvertOneHot(PrimitivePtr primitive) { 2379- if (primitive != nullptr) { 2380- auto prim = static_cast<schema::Primitive *>(primitive); 2381- auto value = prim->value_as_OneHot(); 2382- if (value != nullptr) { 2383- OneHot one_hot{}; 2384- one_hot.axis = value->axis(); 2385- OHOS::MessageParcel data; 2386- (void)OneHotBlockMarshalling(data, one_hot); 2387- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 2388- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 2389- return ret; 2390- } else { 2391- return {}; 2392- } 2393- } else { 2394- return {}; 2395- } 2396-} 2397-std::vector<int8_t> ConvertPadFusion(PrimitivePtr primitive) { 2398- if (primitive != nullptr) { 2399- auto prim = static_cast<schema::Primitive *>(primitive); 2400- auto value = prim->value_as_PadFusion(); 2401- if (value != nullptr) { 2402- PadFusion pad_fusion{}; 2403- auto paddings = value->paddings(); 2404- std::vector<std::vector<int64_t>> paddings_vec2d; 2405- if (paddings == nullptr || paddings->data()->size() < kNumTwo) { 2406- paddings_vec2d = {{0}, {0}, {0}, {0}}; 2407- } else { 2408- paddings_vec2d.reserve(paddings->data()->size()); 2409- for (size_t i = 0; i < paddings->data()->size(); i++) { 2410- auto vet = paddings->data()->Get(i); 2411- paddings_vec2d.emplace_back(std::vector<int64_t>(vet->data()->begin(), vet->data()->end())); 2412- } 2413- } 2414- pad_fusion.paddings = paddings_vec2d; 2415- pad_fusion.paddingMode = static_cast<HDI::Nnrt::V1_0::PaddingMode>(value->padding_mode()); 2416- pad_fusion.constantValue = value->constant_value(); 2417- OHOS::MessageParcel data; 2418- (void)PadFusionBlockMarshalling(data, pad_fusion); 2419- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 2420- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 2421- return ret; 2422- } else { 2423- return {}; 2424- } 2425- } else { 2426- return {}; 2427- } 2428-} 2429-std::vector<int8_t> ConvertPowFusion(PrimitivePtr primitive) { 2430- if (primitive != nullptr) { 2431- auto prim = static_cast<schema::Primitive *>(primitive); 2432- auto value = prim->value_as_PowFusion(); 2433- if (value != nullptr) { 2434- PowFusion pow_fusion{}; 2435- pow_fusion.scale = value->scale(); 2436- pow_fusion.shift = value->shift(); 2437- OHOS::MessageParcel data; 2438- (void)PowFusionBlockMarshalling(data, pow_fusion); 2439- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 2440- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 2441- return ret; 2442- } else { 2443- return {}; 2444- } 2445- } else { 2446- return {}; 2447- } 2448-} 2449-std::vector<int8_t> ConvertPReLUFusion(PrimitivePtr primitive) { 2450- if (primitive != nullptr) { 2451- auto prim = static_cast<schema::Primitive *>(primitive); 2452- auto value = prim->value_as_PReLUFusion(); 2453- if (value != nullptr) { 2454- PReLUFusion p_re_l_u_fusion{}; 2455- p_re_l_u_fusion.channelShared = value->channel_shared(); 2456- OHOS::MessageParcel data; 2457- (void)PReLUFusionBlockMarshalling(data, p_re_l_u_fusion); 2458- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 2459- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 2460- return ret; 2461- } else { 2462- return {}; 2463- } 2464- } else { 2465- return {}; 2466- } 2467-} 2468-std::vector<int8_t> ConvertQuantDTypeCast(PrimitivePtr primitive) { 2469- if (primitive != nullptr) { 2470- auto prim = static_cast<schema::Primitive *>(primitive); 2471- auto value = prim->value_as_QuantDTypeCast(); 2472- if (value != nullptr) { 2473- QuantDTypeCast quant_d_type_cast{}; 2474- quant_d_type_cast.srcT = value->src_t(); 2475- quant_d_type_cast.dstT = value->dst_t(); 2476- OHOS::MessageParcel data; 2477- (void)QuantDTypeCastBlockMarshalling(data, quant_d_type_cast); 2478- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 2479- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 2480- return ret; 2481- } else { 2482- return {}; 2483- } 2484- } else { 2485- return {}; 2486- } 2487-} 2488-std::vector<int8_t> ConvertReduceFusion(PrimitivePtr primitive) { 2489- if (primitive != nullptr) { 2490- auto prim = static_cast<schema::Primitive *>(primitive); 2491- auto value = prim->value_as_ReduceFusion(); 2492- if (value != nullptr) { 2493- ReduceFusion reduce_fusion{}; 2494- reduce_fusion.keepDims = value->keep_dims(); 2495- reduce_fusion.mode = static_cast<HDI::Nnrt::V1_0::ReduceMode>(value->mode()); 2496- reduce_fusion.reduceToEnd = value->reduce_to_end(); 2497- reduce_fusion.coeff = value->coeff(); 2498- OHOS::MessageParcel data; 2499- (void)ReduceFusionBlockMarshalling(data, reduce_fusion); 2500- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 2501- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 2502- return ret; 2503- } else { 2504- return {}; 2505- } 2506- } else { 2507- return {}; 2508- } 2509-} 2510-std::vector<int8_t> ConvertReshape(PrimitivePtr primitive) { 2511- if (primitive != nullptr) { 2512- auto prim = static_cast<schema::Primitive *>(primitive); 2513- auto value = prim->value_as_Reshape(); 2514- if (value != nullptr) { 2515- Reshape reshape{}; 2516- OHOS::MessageParcel data; 2517- (void)ReshapeBlockMarshalling(data, reshape); 2518- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 2519- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 2520- return ret; 2521- } else { 2522- return {}; 2523- } 2524- } else { 2525- return {}; 2526- } 2527-} 2528- 2529-std::vector<int8_t> ConvertResize(PrimitivePtr primitive) { 2530- if (primitive != nullptr) { 2531- auto prim = static_cast<schema::Primitive *>(primitive); 2532- auto value = prim->value_as_Resize(); 2533- if (value != nullptr) { 2534- Resize resize{}; 2535- resize.method = static_cast<HDI::Nnrt::V1_0::ResizeMethod>(value->method()); 2536- resize.newHeight = value->new_height(); 2537- resize.newWidth = value->new_width(); 2538- resize.preserveAspectRatio = value->preserve_aspect_ratio(); 2539- resize.coordinateTransformMode = 2540- static_cast<HDI::Nnrt::V1_0::CoordinateTransformMode>(value->coordinate_transform_mode()); 2541- resize.cubicCoeff = value->cubic_coeff(); 2542- resize.excludeOutside = value->exclude_outside(); 2543- resize.extrapolationValue = value->extrapolation_value(); 2544- resize.nearestMode = static_cast<HDI::Nnrt::V1_0::NearestMode>(value->nearest_mode()); 2545- OHOS::MessageParcel data; 2546- (void)ResizeBlockMarshalling(data, resize); 2547- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 2548- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 2549- return ret; 2550- } else { 2551- return {}; 2552- } 2553- } else { 2554- return {}; 2555- } 2556-} 2557-std::vector<int8_t> ConvertRsqrt(PrimitivePtr primitive) { 2558- if (primitive != nullptr) { 2559- auto prim = static_cast<schema::Primitive *>(primitive); 2560- auto value = prim->value_as_Rsqrt(); 2561- if (value != nullptr) { 2562- Rsqrt rsqrt{}; 2563- OHOS::MessageParcel data; 2564- (void)RsqrtBlockMarshalling(data, rsqrt); 2565- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 2566- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 2567- return ret; 2568- } else { 2569- return {}; 2570- } 2571- } else { 2572- return {}; 2573- } 2574-} 2575-std::vector<int8_t> ConvertScaleFusion(PrimitivePtr primitive) { 2576- if (primitive != nullptr) { 2577- auto prim = static_cast<schema::Primitive *>(primitive); 2578- auto value = prim->value_as_ScaleFusion(); 2579- if (value != nullptr) { 2580- ScaleFusion scale_fusion{}; 2581- scale_fusion.axis = value->axis(); 2582- scale_fusion.activationType = static_cast<HDI::Nnrt::V1_0::ActivationType>(value->activation_type()); 2583- OHOS::MessageParcel data; 2584- (void)ScaleFusionBlockMarshalling(data, scale_fusion); 2585- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 2586- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 2587- return ret; 2588- } else { 2589- return {}; 2590- } 2591- } else { 2592- return {}; 2593- } 2594-} 2595-std::vector<int8_t> ConvertShape(PrimitivePtr primitive) { 2596- if (primitive != nullptr) { 2597- auto prim = static_cast<schema::Primitive *>(primitive); 2598- auto value = prim->value_as_Shape(); 2599- if (value != nullptr) { 2600- Shape shape{}; 2601- OHOS::MessageParcel data; 2602- (void)ShapeBlockMarshalling(data, shape); 2603- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 2604- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 2605- return ret; 2606- } else { 2607- return {}; 2608- } 2609- } else { 2610- return {}; 2611- } 2612-} 2613-std::vector<int8_t> ConvertSliceFusion(PrimitivePtr primitive) { 2614- if (primitive != nullptr) { 2615- auto prim = static_cast<schema::Primitive *>(primitive); 2616- auto value = prim->value_as_SliceFusion(); 2617- if (value != nullptr) { 2618- SliceFusion slice_fusion{}; 2619- std::vector<int64_t> axes; 2620- if (value->axes() == nullptr) { 2621- axes = {1, 2, 3, 4, 5, 6, 7}; 2622- } else { 2623- axes = std::vector<int64_t>(value->axes()->begin(), value->axes()->end()); 2624- } 2625- slice_fusion.axes = axes; 2626- OHOS::MessageParcel data; 2627- (void)SliceFusionBlockMarshalling(data, slice_fusion); 2628- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 2629- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 2630- return ret; 2631- } else { 2632- return {}; 2633- } 2634- } else { 2635- return {}; 2636- } 2637-} 2638-std::vector<int8_t> ConvertSoftmax(PrimitivePtr primitive) { 2639- if (primitive != nullptr) { 2640- auto prim = static_cast<schema::Primitive *>(primitive); 2641- auto value = prim->value_as_Softmax(); 2642- if (value != nullptr) { 2643- Softmax softmax{}; 2644- std::vector<int64_t> axis; 2645- if (value->axis() == nullptr) { 2646- axis = {}; 2647- } else { 2648- axis = std::vector<int64_t>(value->axis()->begin(), value->axis()->end()); 2649- } 2650- softmax.axis = axis; 2651- OHOS::MessageParcel data; 2652- (void)SoftmaxBlockMarshalling(data, softmax); 2653- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 2654- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 2655- return ret; 2656- } else { 2657- return {}; 2658- } 2659- } else { 2660- return {}; 2661- } 2662-} 2663-std::vector<int8_t> ConvertSpaceToBatchND(PrimitivePtr primitive) { 2664- if (primitive != nullptr) { 2665- auto prim = static_cast<schema::Primitive *>(primitive); 2666- auto value = prim->value_as_SpaceToBatchND(); 2667- if (value != nullptr) { 2668- SpaceToBatchND space_to_batch_n_d{}; 2669- std::vector<int64_t> blockShape; 2670- blockShape.reserve(kNumTwo); 2671- if (value->block_shape() == nullptr || value->block_shape()->size() < kNumTwo) { 2672- blockShape = {0, 0}; 2673- } else { 2674- blockShape = std::vector<int64_t>(value->block_shape()->begin(), value->block_shape()->end()); 2675- } 2676- space_to_batch_n_d.blockShape = blockShape; 2677- auto paddings = value->paddings(); 2678- std::vector<std::vector<int64_t>> paddings_vec2d; 2679- if (paddings == nullptr || paddings->data()->size() == 0 || *(paddings->data()->begin()) == nullptr || 2680- (*(paddings->data()->begin()))->data() == nullptr) { 2681- paddings_vec2d = {}; 2682- } else { 2683- paddings_vec2d.reserve(paddings->data()->size()); 2684- for (size_t i = 0; i < paddings->data()->size(); i++) { 2685- auto vet = paddings->data()->Get(i); 2686- paddings_vec2d.emplace_back(std::vector<int64_t>(vet->data()->begin(), vet->data()->end())); 2687- } 2688- } 2689- space_to_batch_n_d.paddings = paddings_vec2d; 2690- OHOS::MessageParcel data; 2691- (void)SpaceToBatchNDBlockMarshalling(data, space_to_batch_n_d); 2692- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 2693- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 2694- return ret; 2695- } else { 2696- return {}; 2697- } 2698- } else { 2699- return {}; 2700- } 2701-} 2702-std::vector<int8_t> ConvertSplit(PrimitivePtr primitive) { 2703- if (primitive != nullptr) { 2704- auto prim = static_cast<schema::Primitive *>(primitive); 2705- auto value = prim->value_as_Split(); 2706- if (value != nullptr) { 2707- Split split{}; 2708- split.outputNum = value->output_num(); 2709- std::vector<int64_t> sizeSplits; 2710- sizeSplits.reserve(split.outputNum); 2711- if (value->size_splits() == nullptr || value->size_splits()->size() <= static_cast<uint32_t>(split.outputNum)) { 2712- sizeSplits = {}; 2713- } else { 2714- sizeSplits = std::vector<int64_t>(value->size_splits()->begin(), value->size_splits()->end()); 2715- } 2716- split.sizeSplits = sizeSplits; 2717- split.axis = value->axis(); 2718- OHOS::MessageParcel data; 2719- (void)SplitBlockMarshalling(data, split); 2720- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 2721- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 2722- return ret; 2723- } else { 2724- return {}; 2725- } 2726- } else { 2727- return {}; 2728- } 2729-} 2730-std::vector<int8_t> ConvertSqrt(PrimitivePtr primitive) { 2731- if (primitive != nullptr) { 2732- auto prim = static_cast<schema::Primitive *>(primitive); 2733- auto value = prim->value_as_Sqrt(); 2734- if (value != nullptr) { 2735- Sqrt sqrt{}; 2736- OHOS::MessageParcel data; 2737- (void)SqrtBlockMarshalling(data, sqrt); 2738- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 2739- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 2740- return ret; 2741- } else { 2742- return {}; 2743- } 2744- } else { 2745- return {}; 2746- } 2747-} 2748-std::vector<int8_t> ConvertSquaredDifference(PrimitivePtr primitive) { 2749- if (primitive != nullptr) { 2750- auto prim = static_cast<schema::Primitive *>(primitive); 2751- auto value = prim->value_as_SquaredDifference(); 2752- if (value != nullptr) { 2753- SquaredDifference squared_difference{}; 2754- OHOS::MessageParcel data; 2755- (void)SquaredDifferenceBlockMarshalling(data, squared_difference); 2756- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 2757- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 2758- return ret; 2759- } else { 2760- return {}; 2761- } 2762- } else { 2763- return {}; 2764- } 2765-} 2766-std::vector<int8_t> ConvertSqueeze(PrimitivePtr primitive) { 2767- if (primitive != nullptr) { 2768- auto prim = static_cast<schema::Primitive *>(primitive); 2769- auto value = prim->value_as_Squeeze(); 2770- if (value != nullptr) { 2771- Squeeze squeeze{}; 2772- std::vector<int64_t> axis; 2773- if (value->axis() == nullptr) { 2774- axis = {}; 2775- } else { 2776- axis = std::vector<int64_t>(value->axis()->begin(), value->axis()->end()); 2777- } 2778- squeeze.axis = axis; 2779- OHOS::MessageParcel data; 2780- (void)SqueezeBlockMarshalling(data, squeeze); 2781- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 2782- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 2783- return ret; 2784- } else { 2785- return {}; 2786- } 2787- } else { 2788- return {}; 2789- } 2790-} 2791-std::vector<int8_t> ConvertStack(PrimitivePtr primitive) { 2792- if (primitive != nullptr) { 2793- auto prim = static_cast<schema::Primitive *>(primitive); 2794- auto value = prim->value_as_Stack(); 2795- if (value != nullptr) { 2796- Stack stack{}; 2797- stack.axis = value->axis(); 2798- OHOS::MessageParcel data; 2799- (void)StackBlockMarshalling(data, stack); 2800- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 2801- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 2802- return ret; 2803- } else { 2804- return {}; 2805- } 2806- } else { 2807- return {}; 2808- } 2809-} 2810-std::vector<int8_t> ConvertStridedSlice(PrimitivePtr primitive) { 2811- if (primitive != nullptr) { 2812- auto prim = static_cast<schema::Primitive *>(primitive); 2813- auto value = prim->value_as_StridedSlice(); 2814- if (value != nullptr) { 2815- StridedSlice strided_slice{}; 2816- strided_slice.beginMask = value->begin_mask(); 2817- strided_slice.endMask = value->end_mask(); 2818- strided_slice.ellipsisMask = value->ellipsis_mask(); 2819- strided_slice.newAxisMask = value->new_axis_mask(); 2820- strided_slice.shrinkAxisMask = value->shrink_axis_mask(); 2821- OHOS::MessageParcel data; 2822- (void)StridedSliceBlockMarshalling(data, strided_slice); 2823- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 2824- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 2825- return ret; 2826- } else { 2827- return {}; 2828- } 2829- } else { 2830- return {}; 2831- } 2832-} 2833-std::vector<int8_t> ConvertSubFusion(PrimitivePtr primitive) { 2834- if (primitive != nullptr) { 2835- auto prim = static_cast<schema::Primitive *>(primitive); 2836- auto value = prim->value_as_SubFusion(); 2837- if (value != nullptr) { 2838- SubFusion sub_fusion{}; 2839- sub_fusion.activationType = static_cast<HDI::Nnrt::V1_0::ActivationType>(value->activation_type()); 2840- OHOS::MessageParcel data; 2841- (void)SubFusionBlockMarshalling(data, sub_fusion); 2842- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 2843- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 2844- return ret; 2845- } else { 2846- return {}; 2847- } 2848- } else { 2849- return {}; 2850- } 2851-} 2852-std::vector<int8_t> ConvertTileFusion(PrimitivePtr primitive) { 2853- if (primitive != nullptr) { 2854- auto prim = static_cast<schema::Primitive *>(primitive); 2855- auto value = prim->value_as_TileFusion(); 2856- if (value != nullptr) { 2857- TileFusion tile_fusion{}; 2858- std::vector<int64_t> dims; 2859- dims.reserve(kNumEight); 2860- if (value->dims() == nullptr) { 2861- dims = {0, 0, 0, 0, 0, 0, 0, 0}; 2862- } else { 2863- dims = std::vector<int64_t>(value->dims()->begin(), value->dims()->end()); 2864- } 2865- tile_fusion.dims = dims; 2866- OHOS::MessageParcel data; 2867- (void)TileFusionBlockMarshalling(data, tile_fusion); 2868- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 2869- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 2870- return ret; 2871- } else { 2872- return {}; 2873- } 2874- } else { 2875- return {}; 2876- } 2877-} 2878-std::vector<int8_t> ConvertTopKFusion(PrimitivePtr primitive) { 2879- if (primitive != nullptr) { 2880- auto prim = static_cast<schema::Primitive *>(primitive); 2881- auto value = prim->value_as_TopKFusion(); 2882- if (value != nullptr) { 2883- TopKFusion top_k_fusion{}; 2884- top_k_fusion.sorted = value->sorted(); 2885- top_k_fusion.axis = value->axis(); 2886- OHOS::MessageParcel data; 2887- (void)TopKFusionBlockMarshalling(data, top_k_fusion); 2888- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 2889- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 2890- return ret; 2891- } else { 2892- return {}; 2893- } 2894- } else { 2895- return {}; 2896- } 2897-} 2898-std::vector<int8_t> ConvertTranspose(PrimitivePtr primitive) { 2899- if (primitive != nullptr) { 2900- auto prim = static_cast<schema::Primitive *>(primitive); 2901- auto value = prim->value_as_Transpose(); 2902- if (value != nullptr) { 2903- Transpose transpose{}; 2904- OHOS::MessageParcel data; 2905- (void)TransposeBlockMarshalling(data, transpose); 2906- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 2907- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 2908- return ret; 2909- } else { 2910- return {}; 2911- } 2912- } else { 2913- return {}; 2914- } 2915-} 2916-std::vector<int8_t> ConvertUnsqueeze(PrimitivePtr primitive) { 2917- if (primitive != nullptr) { 2918- auto prim = static_cast<schema::Primitive *>(primitive); 2919- auto value = prim->value_as_Unsqueeze(); 2920- if (value != nullptr) { 2921- Unsqueeze unsqueeze{}; 2922- std::vector<int64_t> axis; 2923- axis.reserve(kNumEight); 2924- if (value->axis() == nullptr) { 2925- axis = {0, 0, 0, 0}; 2926- } else { 2927- axis = std::vector<int64_t>(value->axis()->begin(), value->axis()->end()); 2928- } 2929- unsqueeze.axis = axis; 2930- OHOS::MessageParcel data; 2931- (void)UnsqueezeBlockMarshalling(data, unsqueeze); 2932- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 2933- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 2934- return ret; 2935- } else { 2936- return {}; 2937- } 2938- } else { 2939- return {}; 2940- } 2941-} 2942- 2943-std::vector<int8_t> Convert(NodeType type, PrimitivePtr primitive) { 2944- switch (type) { 2945- case NODE_TYPE_ACTIVATION: 2946- return ConvertActivation(primitive); 2947- break; 2948- case NODE_TYPE_ADD_FUSION: 2949- return ConvertAddFusion(primitive); 2950- break; 2951- case NODE_TYPE_ARGMAX_FUSION: 2952- return ConvertArgMaxFusion(primitive); 2953- break; 2954- case NODE_TYPE_AVG_POOL_FUSION: 2955- return ConvertAvgPoolFusion(primitive); 2956- break; 2957- case NODE_TYPE_BATCH_TO_SPACE_ND: 2958- return ConvertBatchToSpaceND(primitive); 2959- break; 2960- case NODE_TYPE_BIAS_ADD: 2961- return ConvertBiasAdd(primitive); 2962- break; 2963- case NODE_TYPE_CAST: 2964- return ConvertCast(primitive); 2965- break; 2966- case NODE_TYPE_CONCAT: 2967- return ConvertConcat(primitive); 2968- break; 2969- case NODE_TYPE_CONV2D_FUSION: 2970- return ConvertConv2DFusion(primitive); 2971- break; 2972- case NODE_TYPE_CONV2D_TRANSPOSE_FUSION: 2973- return ConvertConv2dTransposeFusion(primitive); 2974- break; 2975- case NODE_TYPE_DIV_FUSION: 2976- return ConvertDivFusion(primitive); 2977- break; 2978- case NODE_TYPE_ELTWISE: 2979- return ConvertEltwise(primitive); 2980- break; 2981- case NODE_TYPE_EXPAND_DIMS: 2982- return ConvertExpandDims(primitive); 2983- break; 2984- case NODE_TYPE_FILL: 2985- return ConvertFill(primitive); 2986- break; 2987- case NODE_TYPE_FULL_CONNECTION: 2988- return ConvertFullConnection(primitive); 2989- break; 2990- case NODE_TYPE_FUSED_BATCH_NORM: 2991- return ConvertFusedBatchNorm(primitive); 2992- break; 2993- case NODE_TYPE_GATHER: 2994- return ConvertGather(primitive); 2995- break; 2996- case NODE_TYPE_LAYER_NORM_FUSION: 2997- return ConvertLayerNormFusion(primitive); 2998- break; 2999- case NODE_TYPE_LESS_EQUAL: 3000- return ConvertLessEqual(primitive); 3001- break; 3002- case NODE_TYPE_MATMUL_FUSION: 3003- return ConvertMatMulFusion(primitive); 3004- break; 3005- case NODE_TYPE_MAXIMUM: 3006- return ConvertMaximum(primitive); 3007- break; 3008- case NODE_TYPE_MAX_POOL_FUSION: 3009- return ConvertMaxPoolFusion(primitive); 3010- break; 3011- case NODE_TYPE_MUL_FUSION: 3012- return ConvertMulFusion(primitive); 3013- break; 3014- case NODE_TYPE_ONE_HOT: 3015- return ConvertOneHot(primitive); 3016- break; 3017- case NODE_TYPE_PAD_FUSION: 3018- return ConvertPadFusion(primitive); 3019- break; 3020- case NODE_TYPE_POW_FUSION: 3021- return ConvertPowFusion(primitive); 3022- break; 3023- case NODE_TYPE_PRELU_FUSION: 3024- return ConvertPReLUFusion(primitive); 3025- break; 3026- case NODE_TYPE_QUANT_DTYPE_CAST: 3027- return ConvertQuantDTypeCast(primitive); 3028- break; 3029- case NODE_TYPE_REDUCE_FUSION: 3030- return ConvertReduceFusion(primitive); 3031- break; 3032- case NODE_TYPE_RESHAPE: 3033- return ConvertReshape(primitive); 3034- break; 3035- case NODE_TYPE_RESIZE: 3036- return ConvertResize(primitive); 3037- break; 3038- case NODE_TYPE_RSQRT: 3039- return ConvertRsqrt(primitive); 3040- break; 3041- case NODE_TYPE_SCALE_FUSION: 3042- return ConvertScaleFusion(primitive); 3043- break; 3044- case NODE_TYPE_SHAPE: 3045- return ConvertShape(primitive); 3046- break; 3047- case NODE_TYPE_SLICE_FUSION: 3048- return ConvertSliceFusion(primitive); 3049- break; 3050- case NODE_TYPE_SOFTMAX: 3051- return ConvertSoftmax(primitive); 3052- break; 3053- case NODE_TYPE_SPACE_TO_BATCH_ND: 3054- return ConvertSpaceToBatchND(primitive); 3055- break; 3056- case NODE_TYPE_SPLIT: 3057- return ConvertSplit(primitive); 3058- break; 3059- case NODE_TYPE_SQRT: 3060- return ConvertSqrt(primitive); 3061- break; 3062- case NODE_TYPE_SQUARED_DIFFERENCE: 3063- return ConvertSquaredDifference(primitive); 3064- break; 3065- case NODE_TYPE_SQUEEZE: 3066- return ConvertSqueeze(primitive); 3067- break; 3068- case NODE_TYPE_STACK: 3069- return ConvertStack(primitive); 3070- break; 3071- case NODE_TYPE_STRIDED_SLICE: 3072- return ConvertStridedSlice(primitive); 3073- break; 3074- case NODE_TYPE_SUB_FUSION: 3075- return ConvertSubFusion(primitive); 3076- break; 3077- case NODE_TYPE_TILE_FUSION: 3078- return ConvertTileFusion(primitive); 3079- break; 3080- case NODE_TYPE_TOPK_FUSION: 3081- return ConvertTopKFusion(primitive); 3082- break; 3083- case NODE_TYPE_TRANSPOSE: 3084- return ConvertTranspose(primitive); 3085- break; 3086- case NODE_TYPE_UNSQUEEZE: 3087- return ConvertUnsqueeze(primitive); 3088- break; 3089- default: 3090- return {}; 3091- } 3092-} 3093- 3094-} // namespace lite 3095-} // namespace mindspore 3096\ No newline at end of file 3097diff --git a/mindspore/lite/mindir/src/mindir_nnrt_lite_graph_to_model_v2_0.cc b/mindspore/lite/mindir/src/mindir_nnrt_lite_graph_to_model_v2_0.cc 3098deleted file mode 100644 3099index 4e109eff..00000000 3100--- a/mindspore/lite/mindir/src/mindir_nnrt_lite_graph_to_model_v2_0.cc 3101+++ /dev/null 3102@@ -1,1497 +0,0 @@ 3103-/** 3104- * Copyright 2021 Huawei Technologies Co., Ltd 3105- * 3106- * Licensed under the Apache License, Version 2.0 (the "License"); 3107- * you may not use this file except in compliance with the License. 3108- * You may obtain a copy of the License at 3109- * 3110- * http://www.apache.org/licenses/LICENSE-2.0 3111- * 3112- * Unless required by applicable law or agreed to in writing, software 3113- * distributed under the License is distributed on an "AS IS" BASIS, 3114- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 3115- * See the License for the specific language governing permissions and 3116- * limitations under the License. 3117- */ 3118-#include "mindir.h" 3119-#include <vector> 3120-#include <algorithm> 3121-#include <sys/mman.h> 3122-#include "src/common/log.h" 3123-#include "lite_graph.h" 3124-#include "schema/model_generated.h" 3125-#include "mindir_types.h" 3126-#include "message_parcel.h" 3127-#include "nnrt/v2_0/nnrt_types.h" 3128-#include "nnrt/v2_0/node_attr_types.h" 3129-#include "nnrt/v2_0/model_types.h" 3130- 3131-using namespace OHOS::HDI::Nnrt::V2_0; 3132-namespace mindspore { 3133-namespace lite { 3134- 3135-constexpr size_t kNumTwo = 2; 3136-constexpr size_t kNumFour = 4; 3137-constexpr size_t kNumEight = 8; 3138- 3139-inline std::vector<OHOS::HDI::Nnrt::V2_0::QuantParam> MindIR_Tensor_GetQuantParams_OHOS_V2_0(TensorPtr tensor) { 3140- if (tensor != nullptr) { 3141- auto value = static_cast<schema::Tensor *>(tensor); 3142- 3143- if (value != nullptr) { 3144- std::vector<OHOS::HDI::Nnrt::V2_0::QuantParam> result; 3145- auto src = value->quantParams(); 3146- if (src == nullptr) { 3147- return {}; 3148- } 3149- size_t size = src->size(); 3150- result.reserve(src->size()); 3151- for (size_t i = 0; i < size; i++) { 3152- auto tmp = src->Get(i); 3153- OHOS::HDI::Nnrt::V2_0::QuantParam quantParam{tmp->numBits(), tmp->zeroPoint(), tmp->scale()}; 3154- result.emplace_back(quantParam); 3155- } 3156- return result; 3157- } else { 3158- return {}; 3159- } 3160- } else { 3161- return {}; 3162- } 3163-} 3164- 3165-void MindIR_Model_Destroy(OHOS::HDI::Nnrt::V2_0::Model **model) { 3166- if (model != nullptr) { 3167- auto model_data = *model; 3168- if (model_data != nullptr) { 3169- delete (model_data); 3170- *model = nullptr; 3171- } else { 3172- MS_LOG(ERROR) << "*model is nullptr, desrtoy model fail."; 3173- } 3174- } 3175-} 3176- 3177-std::vector<int8_t> ConvertActivation_V2_0(PrimitivePtr primitive) { 3178- if (primitive != nullptr) { 3179- auto prim = static_cast<schema::Primitive *>(primitive); 3180- auto value = prim->value_as_Activation(); 3181- if (value != nullptr) { 3182- Activation activation{}; 3183- activation.activationType = 3184- static_cast<HDI::Nnrt::V2_0::HDI::Nnrt::V2_0::ActivationType>(value->activation_type()); 3185- activation.alpha = value->alpha(); 3186- activation.minVal = value->min_val(); 3187- activation.maxVal = value->max_val(); 3188- activation.approximate = value->approximate(); 3189- OHOS::MessageParcel data; 3190- (void)ActivationBlockMarshalling(data, activation); 3191- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 3192- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 3193- return ret; 3194- } else { 3195- return {}; 3196- } 3197- } else { 3198- return {}; 3199- } 3200-} 3201-std::vector<int8_t> ConvertAddFusion_V2_0(PrimitivePtr primitive) { 3202- if (primitive != nullptr) { 3203- auto prim = static_cast<schema::Primitive *>(primitive); 3204- auto value = prim->value_as_AddFusion(); 3205- if (value != nullptr) { 3206- AddFusion add_fusion{}; 3207- add_fusion.activationType = static_cast<HDI::Nnrt::V2_0::ActivationType>(value->activation_type()); 3208- OHOS::MessageParcel data; 3209- (void)AddFusionBlockMarshalling(data, add_fusion); 3210- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 3211- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 3212- return ret; 3213- } else { 3214- return {}; 3215- } 3216- } else { 3217- return {}; 3218- } 3219-} 3220-std::vector<int8_t> ConvertArgMaxFusion_V2_0(PrimitivePtr primitive) { 3221- if (primitive != nullptr) { 3222- auto prim = static_cast<schema::Primitive *>(primitive); 3223- auto value = prim->value_as_ArgMaxFusion(); 3224- if (value != nullptr) { 3225- ArgMaxFusion arg_max_fusion{}; 3226- arg_max_fusion.axis = value->axis(); 3227- arg_max_fusion.topK = value->top_k(); 3228- arg_max_fusion.keepDims = value->keep_dims(); 3229- arg_max_fusion.outMaxValue = value->out_max_value(); 3230- OHOS::MessageParcel data; 3231- (void)ArgMaxFusionBlockMarshalling(data, arg_max_fusion); 3232- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 3233- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 3234- return ret; 3235- } else { 3236- return {}; 3237- } 3238- } else { 3239- return {}; 3240- } 3241-} 3242-std::vector<int8_t> ConvertAvgPoolFusion_V2_0(PrimitivePtr primitive) { 3243- if (primitive != nullptr) { 3244- auto prim = static_cast<schema::Primitive *>(primitive); 3245- auto value = prim->value_as_AvgPoolFusion(); 3246- if (value != nullptr) { 3247- AvgPoolFusion avg_pool_fusion{}; 3248- std::vector<int64_t> kernel_size; 3249- kernel_size.reserve(kNumTwo); 3250- if (value->kernel_size() == nullptr || value->kernel_size()->size() < kNumTwo) { 3251- kernel_size = {}; 3252- } else { 3253- kernel_size = std::vector<int64_t>(value->kernel_size()->begin(), value->kernel_size()->end()); 3254- } 3255- std::vector<int64_t> strides; 3256- strides.reserve(kNumTwo); 3257- if (value->strides() == nullptr || value->strides()->size() < kNumTwo) { 3258- strides = {}; 3259- } else { 3260- strides = std::vector<int64_t>(value->strides()->begin(), value->strides()->end()); 3261- } 3262- std::vector<int64_t> padList; 3263- strides.reserve(kNumTwo); 3264- if (value->pad() == nullptr || value->pad()->size() < kNumFour) { 3265- padList = {}; 3266- } else { 3267- padList = std::vector<int64_t>(value->pad()->begin(), value->pad()->end()); 3268- } 3269- avg_pool_fusion.kernelSize = kernel_size; 3270- avg_pool_fusion.strides = strides; 3271- avg_pool_fusion.pad = padList; 3272- avg_pool_fusion.padMode = static_cast<HDI::Nnrt::V2_0::PadMode>(value->pad_mode()); 3273- avg_pool_fusion.roundMode = static_cast<HDI::Nnrt::V2_0::RoundMode>(value->round_mode()); 3274- avg_pool_fusion.format = static_cast<HDI::Nnrt::V2_0::Format>(value->format()); 3275- avg_pool_fusion.global = value->global(); 3276- avg_pool_fusion.activationType = static_cast<HDI::Nnrt::V2_0::ActivationType>(value->activation_type()); 3277- OHOS::MessageParcel data; 3278- (void)AvgPoolFusionBlockMarshalling(data, avg_pool_fusion); 3279- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 3280- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 3281- return ret; 3282- } else { 3283- return {}; 3284- } 3285- } else { 3286- return {}; 3287- } 3288-} 3289-std::vector<int8_t> ConvertBatchToSpaceND_V2_0(PrimitivePtr primitive) { 3290- if (primitive != nullptr) { 3291- auto prim = static_cast<schema::Primitive *>(primitive); 3292- auto value = prim->value_as_BatchToSpaceND(); 3293- if (value != nullptr) { 3294- BatchToSpaceND batch_to_space_n_d{}; 3295- std::vector<int64_t> blockShape; 3296- blockShape.reserve(kNumTwo); 3297- if (value->block_shape() == nullptr || value->block_shape()->size() < kNumTwo) { 3298- blockShape = {0, 0}; 3299- } else { 3300- blockShape = std::vector<int64_t>(value->block_shape()->begin(), value->block_shape()->end()); 3301- } 3302- batch_to_space_n_d.blockShape = blockShape; 3303- auto crops = value->crops(); 3304- std::vector<std::vector<int64_t>> crops_vec2d; 3305- if (crops->data() == nullptr) { 3306- MS_LOG(ERROR) << "crops_data is nullptr"; 3307- crops_vec2d = {{}}; 3308- } else { 3309- crops_vec2d.reserve(crops->data()->size()); 3310- for (size_t i = 0; i < crops->data()->size(); i++) { 3311- auto vet = crops->data()->Get(i); 3312- crops_vec2d.emplace_back(std::vector<int64_t>(vet->data()->begin(), vet->data()->end())); 3313- } 3314- } 3315- batch_to_space_n_d.crops = crops_vec2d; 3316- OHOS::MessageParcel data; 3317- (void)BatchToSpaceNDBlockMarshalling(data, batch_to_space_n_d); 3318- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 3319- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 3320- return ret; 3321- } else { 3322- return {}; 3323- } 3324- } else { 3325- return {}; 3326- } 3327-} 3328-std::vector<int8_t> ConvertBiasAdd_V2_0(PrimitivePtr primitive) { 3329- if (primitive != nullptr) { 3330- auto prim = static_cast<schema::Primitive *>(primitive); 3331- auto value = prim->value_as_BiasAdd(); 3332- if (value != nullptr) { 3333- BiasAdd bias_add{}; 3334- OHOS::MessageParcel data; 3335- (void)BiasAddBlockMarshalling(data, bias_add); 3336- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 3337- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 3338- return ret; 3339- } else { 3340- return {}; 3341- } 3342- } else { 3343- return {}; 3344- } 3345-} 3346-std::vector<int8_t> ConvertCast_V2_0(PrimitivePtr primitive) { 3347- if (primitive != nullptr) { 3348- auto prim = static_cast<schema::Primitive *>(primitive); 3349- auto value = prim->value_as_Cast(); 3350- if (value != nullptr) { 3351- Cast cast{}; 3352- OHOS::MessageParcel data; 3353- (void)CastBlockMarshalling(data, cast); 3354- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 3355- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 3356- return ret; 3357- } else { 3358- return {}; 3359- } 3360- } else { 3361- return {}; 3362- } 3363-} 3364-std::vector<int8_t> ConvertConcat_V2_0(PrimitivePtr primitive) { 3365- if (primitive != nullptr) { 3366- auto prim = static_cast<schema::Primitive *>(primitive); 3367- auto value = prim->value_as_Concat(); 3368- if (value != nullptr) { 3369- Concat concat{}; 3370- concat.axis = value->axis(); 3371- OHOS::MessageParcel data; 3372- (void)ConcatBlockMarshalling(data, concat); 3373- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 3374- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 3375- return ret; 3376- } else { 3377- return {}; 3378- } 3379- } else { 3380- return {}; 3381- } 3382-} 3383-std::vector<int8_t> ConvertConv2DFusion_V2_0(PrimitivePtr primitive) { 3384- if (primitive != nullptr) { 3385- auto prim = static_cast<schema::Primitive *>(primitive); 3386- auto value = prim->value_as_Conv2DFusion(); 3387- if (value != nullptr) { 3388- Conv2DFusion conv2_d_fusion{}; 3389- std::vector<int64_t> kernel_size; 3390- kernel_size.reserve(kNumTwo); 3391- if (value->kernel_size() == nullptr || value->kernel_size()->size() < kNumTwo) { 3392- kernel_size = {}; 3393- } else { 3394- kernel_size = std::vector<int64_t>(value->kernel_size()->begin(), value->kernel_size()->end()); 3395- } 3396- std::vector<int64_t> strides; 3397- strides.reserve(kNumTwo); 3398- if (value->stride() == nullptr || value->stride()->size() < kNumTwo) { 3399- strides = {}; 3400- } else { 3401- strides = std::vector<int64_t>(value->stride()->begin(), value->stride()->end()); 3402- } 3403- std::vector<int64_t> dilation; 3404- dilation.reserve(kNumTwo); 3405- if (value->dilation() == nullptr || value->dilation()->size() < kNumTwo) { 3406- dilation = {}; 3407- } else { 3408- dilation = std::vector<int64_t>(value->dilation()->begin(), value->dilation()->end()); 3409- } 3410- std::vector<int64_t> padList; 3411- strides.reserve(kNumTwo); 3412- if (value->pad_list() == nullptr || value->pad_list()->size() < kNumFour) { 3413- padList = {}; 3414- } else { 3415- padList = std::vector<int64_t>(value->pad_list()->begin(), value->pad_list()->end()); 3416- } 3417- conv2_d_fusion.kernelSize = kernel_size; 3418- conv2_d_fusion.stride = strides; 3419- conv2_d_fusion.dilation = dilation; 3420- conv2_d_fusion.padMode = static_cast<HDI::Nnrt::V2_0::PadMode>(value->pad_mode()); 3421- conv2_d_fusion.padList = padList; 3422- conv2_d_fusion.group = value->group(); 3423- conv2_d_fusion.inChannel = value->in_channel(); 3424- conv2_d_fusion.outChannel = value->out_channel(); 3425- conv2_d_fusion.activationType = static_cast<HDI::Nnrt::V2_0::ActivationType>(value->activation_type()); 3426- OHOS::MessageParcel data; 3427- (void)Conv2DFusionBlockMarshalling(data, conv2_d_fusion); 3428- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 3429- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 3430- return ret; 3431- } else { 3432- return {}; 3433- } 3434- } else { 3435- return {}; 3436- } 3437-} 3438-std::vector<int8_t> ConvertConv2dTransposeFusion_V2_0(PrimitivePtr primitive) { 3439- if (primitive != nullptr) { 3440- auto prim = static_cast<schema::Primitive *>(primitive); 3441- auto value = prim->value_as_Conv2dTransposeFusion(); 3442- if (value != nullptr) { 3443- Conv2dTransposeFusion conv2d_transpose_fusion{}; 3444- std::vector<int64_t> kernel_size; 3445- kernel_size.reserve(kNumTwo); 3446- if (value->kernel_size() == nullptr || value->kernel_size()->size() < kNumTwo) { 3447- kernel_size = {}; 3448- } else { 3449- kernel_size = std::vector<int64_t>(value->kernel_size()->begin(), value->kernel_size()->end()); 3450- } 3451- std::vector<int64_t> strides; 3452- strides.reserve(kNumTwo); 3453- if (value->stride() == nullptr || value->stride()->size() < kNumTwo) { 3454- strides = {}; 3455- } else { 3456- strides = std::vector<int64_t>(value->stride()->begin(), value->stride()->end()); 3457- } 3458- std::vector<int64_t> dilation; 3459- dilation.reserve(kNumTwo); 3460- if (value->dilation() == nullptr || value->dilation()->size() < kNumTwo) { 3461- dilation = {}; 3462- } else { 3463- dilation = std::vector<int64_t>(value->dilation()->begin(), value->dilation()->end()); 3464- } 3465- std::vector<int64_t> padList; 3466- strides.reserve(kNumTwo); 3467- if (value->pad_list() == nullptr || value->pad_list()->size() < kNumFour) { 3468- padList = {}; 3469- } else { 3470- padList = std::vector<int64_t>(value->pad_list()->begin(), value->pad_list()->end()); 3471- } 3472- std::vector<int64_t> output_paddings; 3473- output_paddings.reserve(kNumTwo); 3474- if (value->output_paddings() == nullptr || value->output_paddings()->size() < kNumTwo) { 3475- output_paddings = {}; 3476- } else { 3477- output_paddings = std::vector<int64_t>(value->output_paddings()->begin(), value->output_paddings()->end()); 3478- } 3479- conv2d_transpose_fusion.kernelSize = kernel_size; 3480- conv2d_transpose_fusion.stride = strides; 3481- conv2d_transpose_fusion.dilation = dilation; 3482- conv2d_transpose_fusion.padMode = static_cast<HDI::Nnrt::V2_0::PadMode>(value->pad_mode()); 3483- conv2d_transpose_fusion.padList = padList; 3484- conv2d_transpose_fusion.group = value->group(); 3485- conv2d_transpose_fusion.inChannel = value->in_channel(); 3486- conv2d_transpose_fusion.outChannel = value->out_channel(); 3487- conv2d_transpose_fusion.activationType = static_cast<HDI::Nnrt::V2_0::ActivationType>(value->activation_type()); 3488- conv2d_transpose_fusion.outputPaddings = output_paddings; 3489- OHOS::MessageParcel data; 3490- (void)Conv2dTransposeFusionBlockMarshalling(data, conv2d_transpose_fusion); 3491- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 3492- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 3493- return ret; 3494- } else { 3495- return {}; 3496- } 3497- } else { 3498- return {}; 3499- } 3500-} 3501-std::vector<int8_t> ConvertDivFusion_V2_0(PrimitivePtr primitive) { 3502- if (primitive != nullptr) { 3503- auto prim = static_cast<schema::Primitive *>(primitive); 3504- auto value = prim->value_as_DivFusion(); 3505- if (value != nullptr) { 3506- DivFusion div_fusion{}; 3507- div_fusion.activationType = static_cast<HDI::Nnrt::V2_0::ActivationType>(value->activation_type()); 3508- OHOS::MessageParcel data; 3509- (void)DivFusionBlockMarshalling(data, div_fusion); 3510- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 3511- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 3512- return ret; 3513- } else { 3514- return {}; 3515- } 3516- } else { 3517- return {}; 3518- } 3519-} 3520-std::vector<int8_t> ConvertEltwise_V2_0(PrimitivePtr primitive) { 3521- if (primitive != nullptr) { 3522- auto prim = static_cast<schema::Primitive *>(primitive); 3523- auto value = prim->value_as_Eltwise(); 3524- if (value != nullptr) { 3525- Eltwise eltwise{}; 3526- eltwise.mode = static_cast<HDI::Nnrt::V2_0::EltwiseMode>(value->mode()); 3527- OHOS::MessageParcel data; 3528- (void)EltwiseBlockMarshalling(data, eltwise); 3529- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 3530- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 3531- return ret; 3532- } else { 3533- return {}; 3534- } 3535- } else { 3536- return {}; 3537- } 3538-} 3539-std::vector<int8_t> ConvertExpandDims_V2_0(PrimitivePtr primitive) { 3540- if (primitive != nullptr) { 3541- auto prim = static_cast<schema::Primitive *>(primitive); 3542- auto value = prim->value_as_ExpandDims(); 3543- if (value != nullptr) { 3544- ExpandDims expand_dims{}; 3545- OHOS::MessageParcel data; 3546- (void)ExpandDimsBlockMarshalling(data, expand_dims); 3547- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 3548- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 3549- return ret; 3550- } else { 3551- return {}; 3552- } 3553- } else { 3554- return {}; 3555- } 3556-} 3557-std::vector<int8_t> ConvertFill_V2_0(PrimitivePtr primitive) { 3558- if (primitive != nullptr) { 3559- auto prim = static_cast<schema::Primitive *>(primitive); 3560- auto value = prim->value_as_Fill(); 3561- if (value != nullptr) { 3562- Fill fill{}; 3563- OHOS::MessageParcel data; 3564- (void)FillBlockMarshalling(data, fill); 3565- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 3566- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 3567- return ret; 3568- } else { 3569- return {}; 3570- } 3571- } else { 3572- return {}; 3573- } 3574-} 3575-std::vector<int8_t> ConvertFullConnection_V2_0(PrimitivePtr primitive) { 3576- if (primitive != nullptr) { 3577- auto prim = static_cast<schema::Primitive *>(primitive); 3578- auto value = prim->value_as_FullConnection(); 3579- if (value != nullptr) { 3580- FullConnection full_connection{}; 3581- full_connection.hasBias = value->has_bias(); 3582- full_connection.useAxis = value->use_axis(); 3583- full_connection.axis = value->axis(); 3584- full_connection.activationType = static_cast<HDI::Nnrt::V2_0::ActivationType>(value->activation_type()); 3585- OHOS::MessageParcel data; 3586- (void)FullConnectionBlockMarshalling(data, full_connection); 3587- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 3588- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 3589- return ret; 3590- } else { 3591- return {}; 3592- } 3593- } else { 3594- return {}; 3595- } 3596-} 3597-std::vector<int8_t> ConvertFusedBatchNorm_V2_0(PrimitivePtr primitive) { 3598- if (primitive != nullptr) { 3599- auto prim = static_cast<schema::Primitive *>(primitive); 3600- auto value = prim->value_as_FusedBatchNorm(); 3601- if (value != nullptr) { 3602- FusedBatchNorm fused_batch_norm{}; 3603- fused_batch_norm.epsilon = value->epsilon(); 3604- OHOS::MessageParcel data; 3605- (void)FusedBatchNormBlockMarshalling(data, fused_batch_norm); 3606- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 3607- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 3608- return ret; 3609- } else { 3610- return {}; 3611- } 3612- } else { 3613- return {}; 3614- } 3615-} 3616-std::vector<int8_t> ConvertGather_V2_0(PrimitivePtr primitive) { 3617- if (primitive != nullptr) { 3618- auto prim = static_cast<schema::Primitive *>(primitive); 3619- auto value = prim->value_as_Gather(); 3620- if (value != nullptr) { 3621- Gather gather{}; 3622- OHOS::MessageParcel data; 3623- (void)GatherBlockMarshalling(data, gather); 3624- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 3625- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 3626- return ret; 3627- } else { 3628- return {}; 3629- } 3630- } else { 3631- return {}; 3632- } 3633-} 3634-std::vector<int8_t> ConvertLayerNormFusion_V2_0(PrimitivePtr primitive) { 3635- if (primitive != nullptr) { 3636- auto prim = static_cast<schema::Primitive *>(primitive); 3637- auto value = prim->value_as_LayerNormFusion(); 3638- if (value != nullptr) { 3639- LayerNormFusion layer_norm_fusion{}; 3640- layer_norm_fusion.beginNormAxis = value->begin_norm_axis(); 3641- layer_norm_fusion.epsilon = value->epsilon(); 3642- layer_norm_fusion.elementwiseAffine = value->elementwise_affine(); 3643- layer_norm_fusion.beginParamsAxis = value->begin_params_axis(); 3644- OHOS::MessageParcel data; 3645- (void)LayerNormFusionBlockMarshalling(data, layer_norm_fusion); 3646- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 3647- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 3648- return ret; 3649- } else { 3650- return {}; 3651- } 3652- } else { 3653- return {}; 3654- } 3655-} 3656-std::vector<int8_t> ConvertLessEqual_V2_0(PrimitivePtr primitive) { 3657- if (primitive != nullptr) { 3658- auto prim = static_cast<schema::Primitive *>(primitive); 3659- auto value = prim->value_as_LessEqual(); 3660- if (value != nullptr) { 3661- LessEqual less_equal{}; 3662- OHOS::MessageParcel data; 3663- (void)LessEqualBlockMarshalling(data, less_equal); 3664- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 3665- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 3666- return ret; 3667- } else { 3668- return {}; 3669- } 3670- } else { 3671- return {}; 3672- } 3673-} 3674-std::vector<int8_t> ConvertMatMulFusion_V2_0(PrimitivePtr primitive) { 3675- if (primitive != nullptr) { 3676- auto prim = static_cast<schema::Primitive *>(primitive); 3677- auto value = prim->value_as_MatMulFusion(); 3678- if (value != nullptr) { 3679- MatMulFusion mat_mul_fusion{}; 3680- mat_mul_fusion.transposeA = value->transpose_a(); 3681- mat_mul_fusion.transposeB = value->transpose_b(); 3682- mat_mul_fusion.activationType = static_cast<HDI::Nnrt::V2_0::ActivationType>(value->activation_type()); 3683- OHOS::MessageParcel data; 3684- (void)MatMulFusionBlockMarshalling(data, mat_mul_fusion); 3685- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 3686- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 3687- return ret; 3688- } else { 3689- return {}; 3690- } 3691- } else { 3692- return {}; 3693- } 3694-} 3695-std::vector<int8_t> ConvertMaximum_V2_0(PrimitivePtr primitive) { 3696- if (primitive != nullptr) { 3697- auto prim = static_cast<schema::Primitive *>(primitive); 3698- auto value = prim->value_as_Maximum(); 3699- if (value != nullptr) { 3700- Maximum maximum{}; 3701- OHOS::MessageParcel data; 3702- (void)MaximumBlockMarshalling(data, maximum); 3703- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 3704- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 3705- return ret; 3706- } else { 3707- return {}; 3708- } 3709- } else { 3710- return {}; 3711- } 3712-} 3713-std::vector<int8_t> ConvertMaxPoolFusion_V2_0(PrimitivePtr primitive) { 3714- if (primitive != nullptr) { 3715- auto prim = static_cast<schema::Primitive *>(primitive); 3716- auto value = prim->value_as_MaxPoolFusion(); 3717- if (value != nullptr) { 3718- MaxPoolFusion max_pool_fusion{}; 3719- std::vector<int64_t> kernel_size; 3720- kernel_size.reserve(kNumTwo); 3721- if (value->kernel_size() == nullptr || value->kernel_size()->size() < kNumTwo) { 3722- kernel_size = {}; 3723- } else { 3724- kernel_size = std::vector<int64_t>(value->kernel_size()->begin(), value->kernel_size()->end()); 3725- } 3726- std::vector<int64_t> strides; 3727- strides.reserve(kNumTwo); 3728- if (value->strides() == nullptr || value->strides()->size() < kNumTwo) { 3729- strides = {}; 3730- } else { 3731- strides = std::vector<int64_t>(value->strides()->begin(), value->strides()->end()); 3732- } 3733- std::vector<int64_t> padList; 3734- padList.reserve(kNumFour); 3735- if (value->pad() == nullptr || value->pad()->size() < kNumFour) { 3736- padList = {}; 3737- } else { 3738- padList = std::vector<int64_t>(value->pad()->begin(), value->pad()->end()); 3739- } 3740- max_pool_fusion.kernelSize = kernel_size; 3741- max_pool_fusion.strides = strides; 3742- max_pool_fusion.pad = padList; 3743- max_pool_fusion.padMode = static_cast<HDI::Nnrt::V2_0::PadMode>(value->pad_mode()); 3744- max_pool_fusion.format = static_cast<HDI::Nnrt::V2_0::Format>(value->format()); 3745- max_pool_fusion.global = value->global(); 3746- max_pool_fusion.activationType = static_cast<HDI::Nnrt::V2_0::ActivationType>(value->activation_type()); 3747- max_pool_fusion.roundMode = static_cast<HDI::Nnrt::V2_0::RoundMode>(value->round_mode()); 3748- OHOS::MessageParcel data; 3749- (void)MaxPoolFusionBlockMarshalling(data, max_pool_fusion); 3750- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 3751- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 3752- return ret; 3753- } else { 3754- return {}; 3755- } 3756- } else { 3757- return {}; 3758- } 3759-} 3760-std::vector<int8_t> ConvertMulFusion_V2_0(PrimitivePtr primitive) { 3761- if (primitive != nullptr) { 3762- auto prim = static_cast<schema::Primitive *>(primitive); 3763- auto value = prim->value_as_MulFusion(); 3764- if (value != nullptr) { 3765- MulFusion mul_fusion{}; 3766- mul_fusion.activationType = static_cast<HDI::Nnrt::V2_0::ActivationType>(value->activation_type()); 3767- OHOS::MessageParcel data; 3768- (void)MulFusionBlockMarshalling(data, mul_fusion); 3769- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 3770- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 3771- return ret; 3772- } else { 3773- return {}; 3774- } 3775- } else { 3776- return {}; 3777- } 3778-} 3779-std::vector<int8_t> ConvertOneHot_V2_0(PrimitivePtr primitive) { 3780- if (primitive != nullptr) { 3781- auto prim = static_cast<schema::Primitive *>(primitive); 3782- auto value = prim->value_as_OneHot(); 3783- if (value != nullptr) { 3784- OneHot one_hot{}; 3785- one_hot.axis = value->axis(); 3786- OHOS::MessageParcel data; 3787- (void)OneHotBlockMarshalling(data, one_hot); 3788- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 3789- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 3790- return ret; 3791- } else { 3792- return {}; 3793- } 3794- } else { 3795- return {}; 3796- } 3797-} 3798-std::vector<int8_t> ConvertPadFusion_V2_0(PrimitivePtr primitive) { 3799- if (primitive != nullptr) { 3800- auto prim = static_cast<schema::Primitive *>(primitive); 3801- auto value = prim->value_as_PadFusion(); 3802- if (value != nullptr) { 3803- PadFusion pad_fusion{}; 3804- auto paddings = value->paddings(); 3805- std::vector<std::vector<int64_t>> paddings_vec2d; 3806- if (paddings == nullptr || paddings->data()->size() < kNumTwo) { 3807- paddings_vec2d = {{0}, {0}, {0}, {0}}; 3808- } else { 3809- paddings_vec2d.reserve(paddings->data()->size()); 3810- for (size_t i = 0; i < paddings->data()->size(); i++) { 3811- auto vet = paddings->data()->Get(i); 3812- paddings_vec2d.emplace_back(std::vector<int64_t>(vet->data()->begin(), vet->data()->end())); 3813- } 3814- } 3815- pad_fusion.paddings = paddings_vec2d; 3816- pad_fusion.paddingMode = static_cast<HDI::Nnrt::V2_0::PaddingMode>(value->padding_mode()); 3817- pad_fusion.constantValue = value->constant_value(); 3818- OHOS::MessageParcel data; 3819- (void)PadFusionBlockMarshalling(data, pad_fusion); 3820- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 3821- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 3822- return ret; 3823- } else { 3824- return {}; 3825- } 3826- } else { 3827- return {}; 3828- } 3829-} 3830-std::vector<int8_t> ConvertPowFusion_V2_0(PrimitivePtr primitive) { 3831- if (primitive != nullptr) { 3832- auto prim = static_cast<schema::Primitive *>(primitive); 3833- auto value = prim->value_as_PowFusion(); 3834- if (value != nullptr) { 3835- PowFusion pow_fusion{}; 3836- pow_fusion.scale = value->scale(); 3837- pow_fusion.shift = value->shift(); 3838- OHOS::MessageParcel data; 3839- (void)PowFusionBlockMarshalling(data, pow_fusion); 3840- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 3841- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 3842- return ret; 3843- } else { 3844- return {}; 3845- } 3846- } else { 3847- return {}; 3848- } 3849-} 3850-std::vector<int8_t> ConvertPReLUFusion_V2_0(PrimitivePtr primitive) { 3851- if (primitive != nullptr) { 3852- auto prim = static_cast<schema::Primitive *>(primitive); 3853- auto value = prim->value_as_PReLUFusion(); 3854- if (value != nullptr) { 3855- PReLUFusion p_re_l_u_fusion{}; 3856- p_re_l_u_fusion.channelShared = value->channel_shared(); 3857- OHOS::MessageParcel data; 3858- (void)PReLUFusionBlockMarshalling(data, p_re_l_u_fusion); 3859- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 3860- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 3861- return ret; 3862- } else { 3863- return {}; 3864- } 3865- } else { 3866- return {}; 3867- } 3868-} 3869-std::vector<int8_t> ConvertQuantDTypeCast_V2_0(PrimitivePtr primitive) { 3870- if (primitive != nullptr) { 3871- auto prim = static_cast<schema::Primitive *>(primitive); 3872- auto value = prim->value_as_QuantDTypeCast(); 3873- if (value != nullptr) { 3874- QuantDTypeCast quant_d_type_cast{}; 3875- quant_d_type_cast.srcT = value->src_t(); 3876- quant_d_type_cast.dstT = value->dst_t(); 3877- OHOS::MessageParcel data; 3878- (void)QuantDTypeCastBlockMarshalling(data, quant_d_type_cast); 3879- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 3880- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 3881- return ret; 3882- } else { 3883- return {}; 3884- } 3885- } else { 3886- return {}; 3887- } 3888-} 3889-std::vector<int8_t> ConvertReduceFusion_V2_0(PrimitivePtr primitive) { 3890- if (primitive != nullptr) { 3891- auto prim = static_cast<schema::Primitive *>(primitive); 3892- auto value = prim->value_as_ReduceFusion(); 3893- if (value != nullptr) { 3894- ReduceFusion reduce_fusion{}; 3895- reduce_fusion.keepDims = value->keep_dims(); 3896- reduce_fusion.mode = static_cast<HDI::Nnrt::V2_0::ReduceMode>(value->mode()); 3897- reduce_fusion.reduceToEnd = value->reduce_to_end(); 3898- reduce_fusion.coeff = value->coeff(); 3899- OHOS::MessageParcel data; 3900- (void)ReduceFusionBlockMarshalling(data, reduce_fusion); 3901- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 3902- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 3903- return ret; 3904- } else { 3905- return {}; 3906- } 3907- } else { 3908- return {}; 3909- } 3910-} 3911-std::vector<int8_t> ConvertReshape_V2_0(PrimitivePtr primitive) { 3912- if (primitive != nullptr) { 3913- auto prim = static_cast<schema::Primitive *>(primitive); 3914- auto value = prim->value_as_Reshape(); 3915- if (value != nullptr) { 3916- Reshape reshape{}; 3917- OHOS::MessageParcel data; 3918- (void)ReshapeBlockMarshalling(data, reshape); 3919- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 3920- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 3921- return ret; 3922- } else { 3923- return {}; 3924- } 3925- } else { 3926- return {}; 3927- } 3928-} 3929- 3930-std::vector<int8_t> ConvertResize_V2_0(PrimitivePtr primitive) { 3931- if (primitive != nullptr) { 3932- auto prim = static_cast<schema::Primitive *>(primitive); 3933- auto value = prim->value_as_Resize(); 3934- if (value != nullptr) { 3935- Resize resize{}; 3936- resize.method = static_cast<HDI::Nnrt::V2_0::ResizeMethod>(value->method()); 3937- resize.newHeight = value->new_height(); 3938- resize.newWidth = value->new_width(); 3939- resize.preserveAspectRatio = value->preserve_aspect_ratio(); 3940- resize.coordinateTransformMode = 3941- static_cast<HDI::Nnrt::V2_0::CoordinateTransformMode>(value->coordinate_transform_mode()); 3942- resize.cubicCoeff = value->cubic_coeff(); 3943- resize.excludeOutside = value->exclude_outside(); 3944- resize.extrapolationValue = value->extrapolation_value(); 3945- resize.nearestMode = static_cast<HDI::Nnrt::V2_0::NearestMode>(value->nearest_mode()); 3946- OHOS::MessageParcel data; 3947- (void)ResizeBlockMarshalling(data, resize); 3948- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 3949- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 3950- return ret; 3951- } else { 3952- return {}; 3953- } 3954- } else { 3955- return {}; 3956- } 3957-} 3958-std::vector<int8_t> ConvertRsqrt_V2_0(PrimitivePtr primitive) { 3959- if (primitive != nullptr) { 3960- auto prim = static_cast<schema::Primitive *>(primitive); 3961- auto value = prim->value_as_Rsqrt(); 3962- if (value != nullptr) { 3963- Rsqrt rsqrt{}; 3964- OHOS::MessageParcel data; 3965- (void)RsqrtBlockMarshalling(data, rsqrt); 3966- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 3967- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 3968- return ret; 3969- } else { 3970- return {}; 3971- } 3972- } else { 3973- return {}; 3974- } 3975-} 3976-std::vector<int8_t> ConvertScaleFusion_V2_0(PrimitivePtr primitive) { 3977- if (primitive != nullptr) { 3978- auto prim = static_cast<schema::Primitive *>(primitive); 3979- auto value = prim->value_as_ScaleFusion(); 3980- if (value != nullptr) { 3981- ScaleFusion scale_fusion{}; 3982- scale_fusion.axis = value->axis(); 3983- scale_fusion.activationType = static_cast<HDI::Nnrt::V2_0::ActivationType>(value->activation_type()); 3984- OHOS::MessageParcel data; 3985- (void)ScaleFusionBlockMarshalling(data, scale_fusion); 3986- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 3987- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 3988- return ret; 3989- } else { 3990- return {}; 3991- } 3992- } else { 3993- return {}; 3994- } 3995-} 3996-std::vector<int8_t> ConvertShape_V2_0(PrimitivePtr primitive) { 3997- if (primitive != nullptr) { 3998- auto prim = static_cast<schema::Primitive *>(primitive); 3999- auto value = prim->value_as_Shape(); 4000- if (value != nullptr) { 4001- Shape shape{}; 4002- OHOS::MessageParcel data; 4003- (void)ShapeBlockMarshalling(data, shape); 4004- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 4005- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 4006- return ret; 4007- } else { 4008- return {}; 4009- } 4010- } else { 4011- return {}; 4012- } 4013-} 4014-std::vector<int8_t> ConvertSliceFusion_V2_0(PrimitivePtr primitive) { 4015- if (primitive != nullptr) { 4016- auto prim = static_cast<schema::Primitive *>(primitive); 4017- auto value = prim->value_as_SliceFusion(); 4018- if (value != nullptr) { 4019- SliceFusion slice_fusion{}; 4020- std::vector<int64_t> axes; 4021- if (value->axes() == nullptr) { 4022- axes = {1, 2, 3, 4, 5, 6, 7}; 4023- } else { 4024- axes = std::vector<int64_t>(value->axes()->begin(), value->axes()->end()); 4025- } 4026- slice_fusion.axes = axes; 4027- OHOS::MessageParcel data; 4028- (void)SliceFusionBlockMarshalling(data, slice_fusion); 4029- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 4030- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 4031- return ret; 4032- } else { 4033- return {}; 4034- } 4035- } else { 4036- return {}; 4037- } 4038-} 4039-std::vector<int8_t> ConvertSoftmax_V2_0(PrimitivePtr primitive) { 4040- if (primitive != nullptr) { 4041- auto prim = static_cast<schema::Primitive *>(primitive); 4042- auto value = prim->value_as_Softmax(); 4043- if (value != nullptr) { 4044- Softmax softmax{}; 4045- std::vector<int64_t> axis; 4046- if (value->axis() == nullptr) { 4047- axis = {}; 4048- } else { 4049- axis = std::vector<int64_t>(value->axis()->begin(), value->axis()->end()); 4050- } 4051- softmax.axis = axis; 4052- OHOS::MessageParcel data; 4053- (void)SoftmaxBlockMarshalling(data, softmax); 4054- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 4055- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 4056- return ret; 4057- } else { 4058- return {}; 4059- } 4060- } else { 4061- return {}; 4062- } 4063-} 4064-std::vector<int8_t> ConvertSpaceToBatchND_V2_0(PrimitivePtr primitive) { 4065- if (primitive != nullptr) { 4066- auto prim = static_cast<schema::Primitive *>(primitive); 4067- auto value = prim->value_as_SpaceToBatchND(); 4068- if (value != nullptr) { 4069- SpaceToBatchND space_to_batch_n_d{}; 4070- std::vector<int64_t> blockShape; 4071- blockShape.reserve(kNumTwo); 4072- if (value->block_shape() == nullptr || value->block_shape()->size() < kNumTwo) { 4073- blockShape = {0, 0}; 4074- } else { 4075- blockShape = std::vector<int64_t>(value->block_shape()->begin(), value->block_shape()->end()); 4076- } 4077- space_to_batch_n_d.blockShape = blockShape; 4078- auto paddings = value->paddings(); 4079- std::vector<std::vector<int64_t>> paddings_vec2d; 4080- if (paddings == nullptr || paddings->data()->size() == 0 || *(paddings->data()->begin()) == nullptr || 4081- (*(paddings->data()->begin()))->data() == nullptr) { 4082- paddings_vec2d = {}; 4083- } else { 4084- paddings_vec2d.reserve(paddings->data()->size()); 4085- for (size_t i = 0; i < paddings->data()->size(); i++) { 4086- auto vet = paddings->data()->Get(i); 4087- paddings_vec2d.emplace_back(std::vector<int64_t>(vet->data()->begin(), vet->data()->end())); 4088- } 4089- } 4090- space_to_batch_n_d.paddings = paddings_vec2d; 4091- OHOS::MessageParcel data; 4092- (void)SpaceToBatchNDBlockMarshalling(data, space_to_batch_n_d); 4093- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 4094- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 4095- return ret; 4096- } else { 4097- return {}; 4098- } 4099- } else { 4100- return {}; 4101- } 4102-} 4103-std::vector<int8_t> ConvertSplit_V2_0(PrimitivePtr primitive) { 4104- if (primitive != nullptr) { 4105- auto prim = static_cast<schema::Primitive *>(primitive); 4106- auto value = prim->value_as_Split(); 4107- if (value != nullptr) { 4108- Split split{}; 4109- split.outputNum = value->output_num(); 4110- std::vector<int64_t> sizeSplits; 4111- sizeSplits.reserve(split.outputNum); 4112- if (value->size_splits() == nullptr || value->size_splits()->size() <= static_cast<uint32_t>(split.outputNum)) { 4113- sizeSplits = {}; 4114- } else { 4115- sizeSplits = std::vector<int64_t>(value->size_splits()->begin(), value->size_splits()->end()); 4116- } 4117- split.sizeSplits = sizeSplits; 4118- split.axis = value->axis(); 4119- OHOS::MessageParcel data; 4120- (void)SplitBlockMarshalling(data, split); 4121- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 4122- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 4123- return ret; 4124- } else { 4125- return {}; 4126- } 4127- } else { 4128- return {}; 4129- } 4130-} 4131-std::vector<int8_t> ConvertSqrt_V2_0(PrimitivePtr primitive) { 4132- if (primitive != nullptr) { 4133- auto prim = static_cast<schema::Primitive *>(primitive); 4134- auto value = prim->value_as_Sqrt(); 4135- if (value != nullptr) { 4136- Sqrt sqrt{}; 4137- OHOS::MessageParcel data; 4138- (void)SqrtBlockMarshalling(data, sqrt); 4139- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 4140- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 4141- return ret; 4142- } else { 4143- return {}; 4144- } 4145- } else { 4146- return {}; 4147- } 4148-} 4149-std::vector<int8_t> ConvertSquaredDifference_V2_0(PrimitivePtr primitive) { 4150- if (primitive != nullptr) { 4151- auto prim = static_cast<schema::Primitive *>(primitive); 4152- auto value = prim->value_as_SquaredDifference(); 4153- if (value != nullptr) { 4154- SquaredDifference squared_difference{}; 4155- OHOS::MessageParcel data; 4156- (void)SquaredDifferenceBlockMarshalling(data, squared_difference); 4157- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 4158- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 4159- return ret; 4160- } else { 4161- return {}; 4162- } 4163- } else { 4164- return {}; 4165- } 4166-} 4167-std::vector<int8_t> ConvertSqueeze_V2_0(PrimitivePtr primitive) { 4168- if (primitive != nullptr) { 4169- auto prim = static_cast<schema::Primitive *>(primitive); 4170- auto value = prim->value_as_Squeeze(); 4171- if (value != nullptr) { 4172- Squeeze squeeze{}; 4173- std::vector<int64_t> axis; 4174- if (value->axis() == nullptr) { 4175- axis = {}; 4176- } else { 4177- axis = std::vector<int64_t>(value->axis()->begin(), value->axis()->end()); 4178- } 4179- squeeze.axis = axis; 4180- OHOS::MessageParcel data; 4181- (void)SqueezeBlockMarshalling(data, squeeze); 4182- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 4183- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 4184- return ret; 4185- } else { 4186- return {}; 4187- } 4188- } else { 4189- return {}; 4190- } 4191-} 4192-std::vector<int8_t> ConvertStack_V2_0(PrimitivePtr primitive) { 4193- if (primitive != nullptr) { 4194- auto prim = static_cast<schema::Primitive *>(primitive); 4195- auto value = prim->value_as_Stack(); 4196- if (value != nullptr) { 4197- Stack stack{}; 4198- stack.axis = value->axis(); 4199- OHOS::MessageParcel data; 4200- (void)StackBlockMarshalling(data, stack); 4201- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 4202- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 4203- return ret; 4204- } else { 4205- return {}; 4206- } 4207- } else { 4208- return {}; 4209- } 4210-} 4211-std::vector<int8_t> ConvertStridedSlice_V2_0(PrimitivePtr primitive) { 4212- if (primitive != nullptr) { 4213- auto prim = static_cast<schema::Primitive *>(primitive); 4214- auto value = prim->value_as_StridedSlice(); 4215- if (value != nullptr) { 4216- StridedSlice strided_slice{}; 4217- strided_slice.beginMask = value->begin_mask(); 4218- strided_slice.endMask = value->end_mask(); 4219- strided_slice.ellipsisMask = value->ellipsis_mask(); 4220- strided_slice.newAxisMask = value->new_axis_mask(); 4221- strided_slice.shrinkAxisMask = value->shrink_axis_mask(); 4222- OHOS::MessageParcel data; 4223- (void)StridedSliceBlockMarshalling(data, strided_slice); 4224- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 4225- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 4226- return ret; 4227- } else { 4228- return {}; 4229- } 4230- } else { 4231- return {}; 4232- } 4233-} 4234-std::vector<int8_t> ConvertSubFusion_V2_0(PrimitivePtr primitive) { 4235- if (primitive != nullptr) { 4236- auto prim = static_cast<schema::Primitive *>(primitive); 4237- auto value = prim->value_as_SubFusion(); 4238- if (value != nullptr) { 4239- SubFusion sub_fusion{}; 4240- sub_fusion.activationType = static_cast<HDI::Nnrt::V2_0::ActivationType>(value->activation_type()); 4241- OHOS::MessageParcel data; 4242- (void)SubFusionBlockMarshalling(data, sub_fusion); 4243- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 4244- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 4245- return ret; 4246- } else { 4247- return {}; 4248- } 4249- } else { 4250- return {}; 4251- } 4252-} 4253-std::vector<int8_t> ConvertTileFusion_V2_0(PrimitivePtr primitive) { 4254- if (primitive != nullptr) { 4255- auto prim = static_cast<schema::Primitive *>(primitive); 4256- auto value = prim->value_as_TileFusion(); 4257- if (value != nullptr) { 4258- TileFusion tile_fusion{}; 4259- std::vector<int64_t> dims; 4260- dims.reserve(kNumEight); 4261- if (value->dims() == nullptr) { 4262- dims = {0, 0, 0, 0, 0, 0, 0, 0}; 4263- } else { 4264- dims = std::vector<int64_t>(value->dims()->begin(), value->dims()->end()); 4265- } 4266- tile_fusion.dims = dims; 4267- OHOS::MessageParcel data; 4268- (void)TileFusionBlockMarshalling(data, tile_fusion); 4269- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 4270- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 4271- return ret; 4272- } else { 4273- return {}; 4274- } 4275- } else { 4276- return {}; 4277- } 4278-} 4279-std::vector<int8_t> ConvertTopKFusion_V2_0(PrimitivePtr primitive) { 4280- if (primitive != nullptr) { 4281- auto prim = static_cast<schema::Primitive *>(primitive); 4282- auto value = prim->value_as_TopKFusion(); 4283- if (value != nullptr) { 4284- TopKFusion top_k_fusion{}; 4285- top_k_fusion.sorted = value->sorted(); 4286- top_k_fusion.axis = value->axis(); 4287- OHOS::MessageParcel data; 4288- (void)TopKFusionBlockMarshalling(data, top_k_fusion); 4289- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 4290- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 4291- return ret; 4292- } else { 4293- return {}; 4294- } 4295- } else { 4296- return {}; 4297- } 4298-} 4299-std::vector<int8_t> ConvertTranspose_V2_0(PrimitivePtr primitive) { 4300- if (primitive != nullptr) { 4301- auto prim = static_cast<schema::Primitive *>(primitive); 4302- auto value = prim->value_as_Transpose(); 4303- if (value != nullptr) { 4304- Transpose transpose{}; 4305- OHOS::MessageParcel data; 4306- (void)TransposeBlockMarshalling(data, transpose); 4307- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 4308- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 4309- return ret; 4310- } else { 4311- return {}; 4312- } 4313- } else { 4314- return {}; 4315- } 4316-} 4317-std::vector<int8_t> ConvertUnsqueeze_V2_0(PrimitivePtr primitive) { 4318- if (primitive != nullptr) { 4319- auto prim = static_cast<schema::Primitive *>(primitive); 4320- auto value = prim->value_as_Unsqueeze(); 4321- if (value != nullptr) { 4322- Unsqueeze unsqueeze{}; 4323- std::vector<int64_t> axis; 4324- axis.reserve(kNumEight); 4325- if (value->axis() == nullptr) { 4326- axis = {0, 0, 0, 0}; 4327- } else { 4328- axis = std::vector<int64_t>(value->axis()->begin(), value->axis()->end()); 4329- } 4330- unsqueeze.axis = axis; 4331- OHOS::MessageParcel data; 4332- (void)UnsqueezeBlockMarshalling(data, unsqueeze); 4333- std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 4334- reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 4335- return ret; 4336- } else { 4337- return {}; 4338- } 4339- } else { 4340- return {}; 4341- } 4342-} 4343- 4344-std::vector<int8_t> Convert_V2_0(NodeType type, PrimitivePtr primitive) { 4345- switch (type) { 4346- case NODE_TYPE_ACTIVATION: 4347- return ConvertActivation_V2_0(primitive); 4348- break; 4349- case NODE_TYPE_ADD_FUSION: 4350- return ConvertAddFusion_V2_0(primitive); 4351- break; 4352- case NODE_TYPE_ARGMAX_FUSION: 4353- return ConvertArgMaxFusion_V2_0(primitive); 4354- break; 4355- case NODE_TYPE_AVG_POOL_FUSION: 4356- return ConvertAvgPoolFusion_V2_0(primitive); 4357- break; 4358- case NODE_TYPE_BATCH_TO_SPACE_ND: 4359- return ConvertBatchToSpaceND_V2_0(primitive); 4360- break; 4361- case NODE_TYPE_BIAS_ADD: 4362- return ConvertBiasAdd_V2_0(primitive); 4363- break; 4364- case NODE_TYPE_CAST: 4365- return ConvertCast_V2_0(primitive); 4366- break; 4367- case NODE_TYPE_CONCAT: 4368- return ConvertConcat_V2_0(primitive); 4369- break; 4370- case NODE_TYPE_CONV2D_FUSION: 4371- return ConvertConv2DFusion_V2_0(primitive); 4372- break; 4373- case NODE_TYPE_CONV2D_TRANSPOSE_FUSION: 4374- return ConvertConv2dTransposeFusion_V2_0(primitive); 4375- break; 4376- case NODE_TYPE_DIV_FUSION: 4377- return ConvertDivFusion_V2_0(primitive); 4378- break; 4379- case NODE_TYPE_ELTWISE: 4380- return ConvertEltwise_V2_0(primitive); 4381- break; 4382- case NODE_TYPE_EXPAND_DIMS: 4383- return ConvertExpandDims_V2_0(primitive); 4384- break; 4385- case NODE_TYPE_FILL: 4386- return ConvertFill_V2_0(primitive); 4387- break; 4388- case NODE_TYPE_FULL_CONNECTION: 4389- return ConvertFullConnection_V2_0(primitive); 4390- break; 4391- case NODE_TYPE_FUSED_BATCH_NORM: 4392- return ConvertFusedBatchNorm_V2_0(primitive); 4393- break; 4394- case NODE_TYPE_GATHER: 4395- return ConvertGather_V2_0(primitive); 4396- break; 4397- case NODE_TYPE_LAYER_NORM_FUSION: 4398- return ConvertLayerNormFusion_V2_0(primitive); 4399- break; 4400- case NODE_TYPE_LESS_EQUAL: 4401- return ConvertLessEqual_V2_0(primitive); 4402- break; 4403- case NODE_TYPE_MATMUL_FUSION: 4404- return ConvertMatMulFusion_V2_0(primitive); 4405- break; 4406- case NODE_TYPE_MAXIMUM: 4407- return ConvertMaximum_V2_0(primitive); 4408- break; 4409- case NODE_TYPE_MAX_POOL_FUSION: 4410- return ConvertMaxPoolFusion_V2_0(primitive); 4411- break; 4412- case NODE_TYPE_MUL_FUSION: 4413- return ConvertMulFusion_V2_0(primitive); 4414- break; 4415- case NODE_TYPE_ONE_HOT: 4416- return ConvertOneHot_V2_0(primitive); 4417- break; 4418- case NODE_TYPE_PAD_FUSION: 4419- return ConvertPadFusion_V2_0(primitive); 4420- break; 4421- case NODE_TYPE_POW_FUSION: 4422- return ConvertPowFusion_V2_0(primitive); 4423- break; 4424- case NODE_TYPE_PRELU_FUSION: 4425- return ConvertPReLUFusion_V2_0(primitive); 4426- break; 4427- case NODE_TYPE_QUANT_DTYPE_CAST: 4428- return ConvertQuantDTypeCast_V2_0(primitive); 4429- break; 4430- case NODE_TYPE_REDUCE_FUSION: 4431- return ConvertReduceFusion_V2_0(primitive); 4432- break; 4433- case NODE_TYPE_RESHAPE: 4434- return ConvertReshape_V2_0(primitive); 4435- break; 4436- case NODE_TYPE_RESIZE: 4437- return ConvertResize_V2_0(primitive); 4438- break; 4439- case NODE_TYPE_RSQRT: 4440- return ConvertRsqrt_V2_0(primitive); 4441- break; 4442- case NODE_TYPE_SCALE_FUSION: 4443- return ConvertScaleFusion_V2_0(primitive); 4444- break; 4445- case NODE_TYPE_SHAPE: 4446- return ConvertShape_V2_0(primitive); 4447- break; 4448- case NODE_TYPE_SLICE_FUSION: 4449- return ConvertSliceFusion_V2_0(primitive); 4450- break; 4451- case NODE_TYPE_SOFTMAX: 4452- return ConvertSoftmax_V2_0(primitive); 4453- break; 4454- case NODE_TYPE_SPACE_TO_BATCH_ND: 4455- return ConvertSpaceToBatchND_V2_0(primitive); 4456- break; 4457- case NODE_TYPE_SPLIT: 4458- return ConvertSplit_V2_0(primitive); 4459- break; 4460- case NODE_TYPE_SQRT: 4461- return ConvertSqrt_V2_0(primitive); 4462- break; 4463- case NODE_TYPE_SQUARED_DIFFERENCE: 4464- return ConvertSquaredDifference_V2_0(primitive); 4465- break; 4466- case NODE_TYPE_SQUEEZE: 4467- return ConvertSqueeze_V2_0(primitive); 4468- break; 4469- case NODE_TYPE_STACK: 4470- return ConvertStack_V2_0(primitive); 4471- break; 4472- case NODE_TYPE_STRIDED_SLICE: 4473- return ConvertStridedSlice_V2_0(primitive); 4474- break; 4475- case NODE_TYPE_SUB_FUSION: 4476- return ConvertSubFusion_V2_0(primitive); 4477- break; 4478- case NODE_TYPE_TILE_FUSION: 4479- return ConvertTileFusion_V2_0(primitive); 4480- break; 4481- case NODE_TYPE_TOPK_FUSION: 4482- return ConvertTopKFusion_V2_0(primitive); 4483- break; 4484- case NODE_TYPE_TRANSPOSE: 4485- return ConvertTranspose_V2_0(primitive); 4486- break; 4487- case NODE_TYPE_UNSQUEEZE: 4488- return ConvertUnsqueeze_V2_0(primitive); 4489- break; 4490- default: 4491- return {}; 4492- } 4493-} 4494- 4495-OHOS::HDI::Nnrt::V2_0::Model *MindIR_LiteGraph_To_Model(const LiteGraph *lite_graph, const OHOS::HDI::Nnrt::V2_0::SharedBuffer &buffer) { 4496- if (lite_graph != nullptr) { 4497- MS_LOG(INFO) << "MindIR_LiteGraph_To_Model begin"; 4498- if (!lite_graph->name_.empty()) { 4499- MS_LOG(INFO) << "Start converting lite graph,name =" << lite_graph->name_; 4500- } else { 4501- MS_LOG(INFO) << "Start converting lite graph, but lite graph has no name."; 4502- } 4503- std::vector<uint32_t> inputIndex; 4504- std::vector<uint32_t> outputIndex; 4505- std::vector<OHOS::HDI::Nnrt::V2_0::Node> nodes; 4506- std::vector<OHOS::HDI::Nnrt::V2_0::Tensor> allTensors; 4507- std::vector<OHOS::HDI::Nnrt::V2_0::SubGraph> subGraph; 4508- // nodes 4509- MS_LOG(INFO) << "Start converting nodes, vector size = " << lite_graph->all_nodes_.size(); 4510- nodes.reserve(lite_graph->all_nodes_.size()); 4511- for (auto node : lite_graph->all_nodes_) { 4512- if (node == nullptr) { 4513- MS_LOG(ERROR) << "node is nullptr, convert fail."; 4514- return nullptr; 4515- } 4516- OHOS::HDI::Nnrt::V2_0::Node tmp; 4517- tmp.name = node->name_; 4518- if (node->primitive_ == nullptr) { 4519- MS_LOG(ERROR) << "node primitive is nullptr, convert fail."; 4520- return nullptr; 4521- } 4522- auto prim = static_cast<schema::Primitive *>(node->primitive_); 4523- auto value = prim->value_type(); 4524- tmp.nodeType = static_cast<HDI::Nnrt::V2_0::NodeType>(value); 4525- tmp.nodeAttr = Convert_V2_0(static_cast<NodeType>(value), node->primitive_); 4526- tmp.inputIndex = node->input_indices_; 4527- tmp.outputIndex = node->output_indices_; 4528- tmp.quantType = static_cast<HDI::Nnrt::V2_0::QuantType>(node->quant_type_); 4529- nodes.emplace_back(tmp); 4530- } 4531- 4532- MS_LOG(INFO) << "Start converting Tensor,Tensor size=" << lite_graph->all_tensors_.size(); 4533- // Tensor 4534- allTensors.reserve(lite_graph->all_tensors_.size()); 4535- unsigned int tensor_buffer_offset = 0; 4536- uint8_t *mmap_ptr = nullptr; 4537- if (buffer.fd != -1) { 4538- mmap_ptr = 4539- static_cast<uint8_t *>(mmap(nullptr, buffer.bufferSize, PROT_READ | PROT_WRITE, MAP_SHARED, buffer.fd, 0)); 4540- if (mmap_ptr == MAP_FAILED) { 4541- MS_LOG(ERROR) << "mmap failed"; 4542- return nullptr; 4543- } 4544- } 4545- MS_LOG(INFO) << "Start parsing tensor, mmap buffer size = " << buffer.bufferSize; 4546- for (auto tensor : lite_graph->all_tensors_) { 4547- OHOS::HDI::Nnrt::V2_0::Tensor tmp; 4548- tmp.name = MindIR_Tensor_GetName(tensor); 4549- tmp.dataType = static_cast<HDI::Nnrt::V2_0::HDI::Nnrt::V2_0::DataType>(MindIR_Tensor_GetDataType(tensor)); 4550- tmp.dims = MindIR_Tensor_GetDims(tensor); 4551- tmp.format = static_cast<HDI::Nnrt::V2_0::HDI::Nnrt::V2_0::Format>(MindIR_Tensor_GetFormat(tensor)); 4552- tmp.data = MindIR_Tensor_GetData_V2_0(tensor, buffer, mmap_ptr, tensor_buffer_offset); 4553- tmp.quantParams = MindIR_Tensor_GetQuantParams_OHOS_V2_0(tensor); 4554- allTensors.emplace_back(tmp); 4555- tensor_buffer_offset = tmp.data.offset + tmp.data.dataSize; 4556- } 4557- MS_LOG(INFO) << ("Parsing tensor finish."); 4558- if (buffer.fd != -1) { 4559- auto munmap_res = munmap(mmap_ptr, buffer.bufferSize); 4560- if (munmap_res != 0) { 4561- MS_LOG(ERROR) << "unmap failed."; 4562- return nullptr; 4563- } 4564- } 4565- 4566- MS_LOG(INFO) << "Start converting SubGraph,SubGraph size=" << lite_graph->sub_graphs_.size(); 4567- // SubGraph 4568- subGraph.reserve(lite_graph->sub_graphs_.size()); 4569- for (auto graph : lite_graph->sub_graphs_) { 4570- OHOS::HDI::Nnrt::V2_0::SubGraph tmp; 4571- tmp.name = graph->name_; 4572- tmp.inputIndices = std::vector<uint32_t>(graph->input_indices_); 4573- tmp.outputIndices = std::vector<uint32_t>(graph->output_indices_); 4574- tmp.nodeIndices = std::vector<uint32_t>(graph->node_indices_); 4575- subGraph.emplace_back(tmp); 4576- } 4577- 4578- MS_LOG(INFO) << "Start copying model"; 4579- auto *ret_model = new (std::nothrow) Model(); 4580- if (ret_model == nullptr) { 4581- MS_LOG(ERROR) << "new Model failed."; 4582- return nullptr; 4583- } 4584- ret_model->name = lite_graph->name_; 4585- ret_model->inputIndex = lite_graph->input_indices_; 4586- ret_model->outputIndex = lite_graph->output_indices_; 4587- ret_model->nodes = nodes; 4588- ret_model->allTensors = allTensors; 4589- ret_model->subGraph = subGraph; 4590- MS_LOG(INFO) << "MindIR_LiteGraph_To_Model success"; 4591- return ret_model; 4592- } else { 4593- MS_LOG(ERROR) << "lite graph is nullptr"; 4594- return nullptr; 4595- } 4596-} 4597- 4598-} // namespace lite 4599-} // namespace mindspore 4600\ No newline at end of file 4601diff --git a/mindspore/lite/mindir/src/mindir_tensor.cc b/mindspore/lite/mindir/src/mindir_tensor.cc 4602index 2db4ce8b..9575f8c2 100644 4603--- a/mindspore/lite/mindir/src/mindir_tensor.cc 4604+++ b/mindspore/lite/mindir/src/mindir_tensor.cc 4605@@ -18,10 +18,6 @@ 4606 #include "utils.h" 4607 #include "securec.h" 4608 #include "mindir_memory_manager.h" 4609-#include "nnrt/v1_0/nnrt_types.h" 4610-#include "nnrt/v2_0/nnrt_types.h" 4611- 4612-using namespace OHOS::HDI::Nnrt::V1_0; 4613 4614 namespace mindspore { 4615 namespace lite { 4616@@ -239,82 +235,6 @@ void MindIR_Tensor_SetFormat(TensorPtr *tensor, Format format) { 4617 } 4618 } 4619 4620-OHOS::HDI::Nnrt::V1_0::SharedBuffer MindIR_Tensor_GetData(ConstTensorPtr tensor, 4621- const OHOS::HDI::Nnrt::V1_0::SharedBuffer &buffer_templete, 4622- uint8_t *mmap_ptr, unsigned int offset) { 4623- if (tensor != nullptr) { 4624- auto value = static_cast<const schema::Tensor *>(tensor); 4625- if (value != nullptr) { 4626- OHOS::HDI::Nnrt::V1_0::SharedBuffer result{}; 4627- 4628- if (value->data() == nullptr || value->data()->size() == 0) { 4629- result.fd = -1; 4630- result.bufferSize = buffer_templete.bufferSize; 4631- result.offset = offset; 4632- result.dataSize = 0; 4633- return result; 4634- } 4635- if (mmap_ptr == nullptr) { 4636- MS_LOG(ERROR) << "Tensor GetData failed, mmap pointer should not be nullptr"; 4637- return {-1, 0, offset, 0}; 4638- } 4639- result.fd = buffer_templete.fd; 4640- result.bufferSize = buffer_templete.bufferSize; 4641- auto ret = memcpy_s(mmap_ptr + offset, value->data()->size(), value->data()->data(), value->data()->size()); 4642- if (ret != EOK) { 4643- MS_LOG(ERROR) << "Tensor memcpy failed, ret:" << ret; 4644- return {-1, 0, offset, 0}; 4645- } 4646- result.offset = offset; 4647- result.dataSize = value->data()->size(); 4648- return result; 4649- } else { 4650- MS_LOG(ERROR) << "Tensor GetData failed, mmap pointer should not be nullptr"; 4651- return {-1, 0, offset, 0}; 4652- } 4653- } else { 4654- return {-1, 0, offset, 0}; 4655- } 4656-} 4657- 4658-OHOS::HDI::Nnrt::V2_0::SharedBuffer MindIR_Tensor_GetData_V2_0(ConstTensorPtr tensor, 4659- const OHOS::HDI::Nnrt::V2_0::SharedBuffer &buffer_templete, 4660- uint8_t *mmap_ptr, unsigned int offset) { 4661- if (tensor != nullptr) { 4662- auto value = static_cast<const schema::Tensor *>(tensor); 4663- if (value != nullptr) { 4664- OHOS::HDI::Nnrt::V2_0::SharedBuffer result{}; 4665- 4666- if (value->data() == nullptr || value->data()->size() == 0) { 4667- result.fd = -1; 4668- result.bufferSize = buffer_templete.bufferSize; 4669- result.offset = offset; 4670- result.dataSize = 0; 4671- return result; 4672- } 4673- if (mmap_ptr == nullptr) { 4674- MS_LOG(ERROR) << "Tensor GetData failed, mmap pointer should not be nullptr"; 4675- return {-1, 0, offset, 0}; 4676- } 4677- result.fd = buffer_templete.fd; 4678- result.bufferSize = buffer_templete.bufferSize; 4679- auto ret = memcpy_s(mmap_ptr + offset, value->data()->size(), value->data()->data(), value->data()->size()); 4680- if (ret != EOK) { 4681- MS_LOG(ERROR) << "Tensor memcpy failed, ret:" << ret; 4682- return {-1, 0, offset, 0}; 4683- } 4684- result.offset = offset; 4685- result.dataSize = value->data()->size(); 4686- return result; 4687- } else { 4688- MS_LOG(WARNING) << "Tensor GetData failed, mmap pointer should not be nullptr"; 4689- return {-1, 0, offset, 0}; 4690- } 4691- } else { 4692- return {-1, 0, offset, 0}; 4693- } 4694-} 4695- 4696 std::vector<uint8_t> MindIR_Tensor_GetData(ConstTensorPtr tensor) { 4697 if (tensor != nullptr) { 4698 auto value = static_cast<const schema::Tensor *>(tensor); 4699diff --git a/mindspore/lite/src/litert/c_api/context_c.cc b/mindspore/lite/src/litert/c_api/context_c.cc 4700index c5f825aa..bde0460c 100644 4701--- a/mindspore/lite/src/litert/c_api/context_c.cc 4702+++ b/mindspore/lite/src/litert/c_api/context_c.cc 4703@@ -324,6 +324,10 @@ NNRTDeviceDesc *OH_AI_GetAllNNRTDeviceDescs(size_t *num) { 4704 4705 const char *name = nullptr; 4706 (void)OH_NNDevice_GetName(all_device_ids[i], &name); 4707+ if (name == nullptr) { 4708+ MS_LOG(ERROR) << "OH_NNDevice_GetName error."; 4709+ return nullptr; 4710+ } 4711 desc[i].device_name[127] = '\0'; 4712 strncpy(desc[i].device_name, name, 127); 4713 } 4714diff --git a/mindspore/lite/src/litert/kernel/cpu/fp32_grad/strided_slice_grad.cc b/mindspore/lite/src/litert/kernel/cpu/fp32_grad/strided_slice_grad.cc 4715index 91094658..91bbd39a 100644 4716--- a/mindspore/lite/src/litert/kernel/cpu/fp32_grad/strided_slice_grad.cc 4717+++ b/mindspore/lite/src/litert/kernel/cpu/fp32_grad/strided_slice_grad.cc 4718@@ -18,6 +18,7 @@ 4719 #include "src/litert/kernel/cpu/fp32_grad/strided_slice_grad.h" 4720 #include <vector> 4721 #include <algorithm> 4722+#include <utility> 4723 #include "schema/model_generated.h" 4724 #include "src/litert/kernel_registry.h" 4725 #include "nnacl/fp32_grad/strided_slice_grad.h" 4726@@ -55,7 +56,6 @@ void StridedSliceGradCPUKernel::FillEmptyDims() { 4727 int32_t begins[DIMENSION_8D]; 4728 int32_t ends[DIMENSION_8D]; 4729 int32_t strides[DIMENSION_8D]; 4730- int32_t input_shape[DIMENSION_8D]; 4731 int32_t i; 4732 4733 // invert the order of the dimension and fill defout outsize actual ranae 4734@@ -63,19 +63,10 @@ void StridedSliceGradCPUKernel::FillEmptyDims() { 4735 begins[i] = param_->begins_[i]; 4736 ends[i] = param_->ends_[i]; 4737 strides[i] = param_->strides_[i]; 4738- input_shape[i] = param_->in_shape_[i]; 4739 } 4740 4741- int32_t real_index = param_->in_shape_length_ - 1; 4742- for (i = DIMENSION_8D - 1; i >= 0; --i) { 4743- if (real_index >= 0) { 4744- param_->in_shape_[i] = input_shape[real_index--]; 4745- } else { 4746- param_->in_shape_[i] = 1; 4747- } 4748- } 4749 int out_shape_length = in_tensors_.at(1)->shape().at(0); 4750- real_index = out_shape_length - 1; 4751+ int32_t real_index = out_shape_length - 1; 4752 for (i = DIMENSION_8D - 1; i >= 0; --i) { 4753 if (real_index >= 0) { 4754 param_->begins_[i] = begins[real_index]; 4755@@ -87,17 +78,15 @@ void StridedSliceGradCPUKernel::FillEmptyDims() { 4756 param_->strides_[i] = 1; 4757 } 4758 } 4759- param_->num_axes_ = DIMENSION_8D; 4760- param_->in_shape_length_ = DIMENSION_8D; 4761- 4762 for (i = 0; i < DIMENSION_8D; ++i) { 4763- if (param_->begins_[i] < 0) { 4764- param_->begins_[i] += param_->in_shape_[i]; 4765- } 4766- if (param_->ends_[i] < 0) { 4767- param_->ends_[i] += param_->in_shape_[i]; 4768+ int ax = param_->ends_[i] - param_->begins_[i]; 4769+ if (ax < 0) { 4770+ ax = 0; 4771 } 4772+ param_->in_shape_[i] = ax; 4773 } 4774+ param_->num_axes_ = DIMENSION_8D; 4775+ param_->in_shape_length_ = DIMENSION_8D; 4776 } 4777 4778 void StridedSliceGradCPUKernel::FillOutputDim() { 4779@@ -115,6 +104,24 @@ void StridedSliceGradCPUKernel::FillOutputDim() { 4780 int StridedSliceGradCPUKernel::ReSize() { 4781 FillEmptyDims(); 4782 FillOutputDim(); 4783+ for (int32_t i = 0; i < DIMENSION_8D; ++i) { 4784+ if (param_->ends_[i] == 0 && param_->begins_[i] < 0) { 4785+ param_->ends_[i] += output_shape_[i]; 4786+ } 4787+ if (param_->ends_[i] < 0) { 4788+ param_->ends_[i] = (param_->ends_[i] + output_shape_[i]) < 0 ? 0 : param_->ends_[i] + output_shape_[i]; 4789+ } 4790+ if (param_->ends_[i] > output_shape_[i]) { 4791+ param_->ends_[i] = output_shape_[i]; 4792+ } 4793+ if (param_->begins_[i] < 0) { 4794+ auto k = param_->begins_[i] + output_shape_[i]; 4795+ param_->begins_[i] = k < 0 ? 0 : k; 4796+ } 4797+ if (param_->begins_[i] > output_shape_[i]) { 4798+ param_->begins_[i] = output_shape_[i]; 4799+ } 4800+ } 4801 return RET_OK; 4802 } 4803 4804@@ -142,20 +149,81 @@ int StridedSliceGradCPUKernel::DoExecute(int task_id) { 4805 auto input = in_tensors_.at(0); 4806 auto output = out_tensors_.at(0); 4807 4808- int *po = output_shape_.data(); 4809- auto dx = reinterpret_cast<float *>(output->MutableData()); 4810- auto dy = reinterpret_cast<float *>(input->MutableData()); 4811- CHECK_NULL_RETURN(po); 4812+ auto *dx = reinterpret_cast<float *>(output->MutableData()); 4813+ auto *dy = reinterpret_cast<float *>(input->MutableData()); 4814 CHECK_NULL_RETURN(dx); 4815 CHECK_NULL_RETURN(dy); 4816- std::fill(dx, dx + output->ElementsNum(), 0.f); 4817- auto ret = DoStridedSliceGrad(dy, dx, po, param_); 4818- if (ret != RET_OK) { 4819- MS_LOG(ERROR) << "StridedSliceGrad error error_code[" << ret << "]"; 4820- return RET_ERROR; 4821+ return CalStridedSliceGrad(dy, dx); 4822+} 4823+ 4824+int StridedSliceGradCPUKernel::CalStridedSliceGrad(float *input, float *output) { 4825+ int input_num = 1; 4826+ for (int le = 0; le < DIMENSION_8D; le++) { 4827+ input_num = input_num * param_->in_shape_[le]; 4828+ } 4829+ int output_num = 1; 4830+ for (int len = 0; len < DIMENSION_8D; len++) { 4831+ output_num = output_num * output_shape_[len]; 4832+ } 4833+ 4834+ if (input_num == 0) { 4835+ res_arr_ = reinterpret_cast<float *>(ms_context_->allocator->Malloc(sizeof(float) * output_num)); 4836+ for (int res_len = 0; res_len < output_num; res_len++) { 4837+ res_arr_[res_len] = static_cast<float>(0); 4838+ } 4839+ memcpy(output, res_arr_, output_num * sizeof(float)); 4840+ FreeRunBuffer(); 4841+ return RET_OK; 4842 } 4843+ 4844+ int temp_num = input_num; 4845+ int max_num = input_num; 4846+ int step = 1; 4847+ for (int i = DIMENSION_8D - 1; i >= 0; --i) { 4848+ temp_num = static_cast<int>(temp_num * output_shape_[i] / param_->in_shape_[i]); 4849+ max_num = MSMAX(max_num, temp_num); 4850+ } 4851+ temp_input_ = reinterpret_cast<float *>(ms_context_->allocator->Malloc(sizeof(float) * max_num)); 4852+ memset(temp_input_, 0, max_num * sizeof(float)); 4853+ memcpy(temp_input_, input, input_num * sizeof(float)); 4854+ temp_ = reinterpret_cast<float *>(ms_context_->allocator->Malloc(max_num * sizeof(float))); 4855+ temp_num = input_num; 4856+ for (int i = DIMENSION_8D - 1; i >= 0; --i) { 4857+ temp_num = static_cast<int>(temp_num * output_shape_[i] / param_->in_shape_[i]); 4858+ memset(temp_, 0, sizeof(float) * temp_num); 4859+ int start1 = 0; 4860+ int start2 = 0; 4861+ while (start1 < temp_num) { 4862+ int id = 0; 4863+ for (int k = param_->begins_[i]; param_->strides_[i] > 0 ? k < param_->ends_[i] : k > param_->ends_[i]; 4864+ k += param_->strides_[i], id++) { 4865+ memcpy(temp_ + start1 + k * step, temp_input_ + start2 + id * step, step * sizeof(float)); 4866+ } 4867+ start1 += output_shape_[i] * step; 4868+ start2 += param_->in_shape_[i] * step; 4869+ } 4870+ step *= output_shape_[i]; 4871+ std::swap(temp_input_, temp_); 4872+ } 4873+ memcpy(output, temp_input_, output_num * sizeof(float)); 4874+ FreeRunBuffer(); 4875 return RET_OK; 4876 } 4877 4878+void StridedSliceGradCPUKernel::FreeRunBuffer() { 4879+ if (res_arr_ != nullptr) { 4880+ ms_context_->allocator->Free(res_arr_); 4881+ res_arr_ = nullptr; 4882+ } 4883+ if (temp_input_ != nullptr) { 4884+ ms_context_->allocator->Free(temp_input_); 4885+ temp_input_ = nullptr; 4886+ } 4887+ if (temp_ != nullptr) { 4888+ ms_context_->allocator->Free(temp_); 4889+ temp_ = nullptr; 4890+ } 4891+} 4892+ 4893 REG_KERNEL(kCPU, kNumberTypeFloat32, PrimitiveType_StridedSliceGrad, LiteKernelCreator<StridedSliceGradCPUKernel>) 4894 } // namespace mindspore::kernel 4895diff --git a/mindspore/lite/src/litert/kernel/cpu/fp32_grad/strided_slice_grad.h b/mindspore/lite/src/litert/kernel/cpu/fp32_grad/strided_slice_grad.h 4896index 25d6f855..f34dd20d 100644 4897--- a/mindspore/lite/src/litert/kernel/cpu/fp32_grad/strided_slice_grad.h 4898+++ b/mindspore/lite/src/litert/kernel/cpu/fp32_grad/strided_slice_grad.h 4899@@ -40,9 +40,14 @@ class StridedSliceGradCPUKernel : public LiteKernel { 4900 void FillEmptyDims(); 4901 void FillOutputDim(); 4902 void ParseMasks(); 4903+ int CalStridedSliceGrad(float *input, float *output); 4904+ void FreeRunBuffer(); 4905 4906 StridedSliceParameter *param_; 4907 std::vector<int> output_shape_; 4908+ float *res_arr_ = nullptr; 4909+ float *temp_input_ = nullptr; 4910+ float *temp_ = nullptr; 4911 }; 4912 } // namespace mindspore::kernel 4913 4914diff --git a/mindspore/lite/src/litert/lite_model.cc b/mindspore/lite/src/litert/lite_model.cc 4915index bcb9cb70..af9b1f8d 100644 4916--- a/mindspore/lite/src/litert/lite_model.cc 4917+++ b/mindspore/lite/src/litert/lite_model.cc 4918@@ -66,7 +66,9 @@ void LiteModel::Free() { 4919 node_bufs_.resize(0); 4920 4921 for (auto *schema_tensor_wrapper : inner_all_tensors_) { 4922- delete schema_tensor_wrapper; 4923+ if (schema_tensor_wrapper != nullptr) { 4924+ delete schema_tensor_wrapper; 4925+ } 4926 } 4927 inner_all_tensors_.clear(); 4928 4929-- 49302.17.1 4931 4932