1diff --git a/mindspore/lite/mindir/BUILD.gn b/mindspore/lite/mindir/BUILD.gn 2index 2ef8225d..7bb190ae 100644 3--- a/mindspore/lite/mindir/BUILD.gn 4+++ b/mindspore/lite/mindir/BUILD.gn 5@@ -33,12 +33,14 @@ ohos_shared_library("mindir_lib") { 6 "src/mindir_memory_manager.cc", 7 "src/mindir_nnrt_lite_graph.cc", 8 "src/mindir_nnrt_lite_graph_to_model.cc", 9+ "src/mindir_nnrt_lite_graph_to_model_v2_0.cc", 10 "src/mindir_tensor.cc", 11 "src/utils.cc", 12 ] 13 external_deps = [ 14 "c_utils:utils", 15 "drivers_interface_nnrt:libnnrt_proxy_1.0", 16+ "drivers_interface_nnrt:libnnrt_proxy_2.0", 17 "hdf_core:libhdi", 18 "hilog_native:libhilog", 19 "ipc:ipc_core", 20diff --git a/mindspore/lite/mindir/include/mindir.h b/mindspore/lite/mindir/include/mindir.h 21index ae72cc9b..b73920ff 100644 22--- a/mindspore/lite/mindir/include/mindir.h 23+++ b/mindspore/lite/mindir/include/mindir.h 24@@ -29,6 +29,16 @@ struct Model; 25 } // namespace HDI 26 } // namespace OHOS 27 28+namespace OHOS { 29+namespace HDI { 30+namespace Nnrt { 31+namespace V2_0 { 32+struct Model; 33+} // namespace V2_0 34+} // namespace Nnrt 35+} // namespace HDI 36+} // namespace OHOS 37+ 38 namespace mindspore { 39 namespace schema { 40 struct Attribute; 41@@ -41,6 +51,10 @@ OHOS::HDI::Nnrt::V1_0::Model *MindIR_LiteGraph_To_Model(const LiteGraph *lite_gr 42 const OHOS::HDI::Nnrt::V1_0::SharedBuffer &buffer); 43 void MindIR_Model_Destroy(OHOS::HDI::Nnrt::V1_0::Model **model); 44 45+OHOS::HDI::Nnrt::V2_0::Model *MindIR_LiteGraph_To_Model(const LiteGraph *lite_graph, 46+ const OHOS::HDI::Nnrt::V2_0::SharedBuffer &buffer); 47+void MindIR_Model_Destroy(OHOS::HDI::Nnrt::V2_0::Model **model); 48+ 49 // ********** Activation ********** 50 PrimitivePtr MindIR_Activation_CreatePrimitive(ActivationType activation_type, float alpha, float min_val, 51 float max_val, bool approximate); 52diff --git a/mindspore/lite/mindir/include/mindir_tensor.h b/mindspore/lite/mindir/include/mindir_tensor.h 53index ce1b24dc..836bc8af 100644 54--- a/mindspore/lite/mindir/include/mindir_tensor.h 55+++ b/mindspore/lite/mindir/include/mindir_tensor.h 56@@ -13,6 +13,16 @@ struct SharedBuffer; 57 } // namespace HDI 58 } // namespace OHOS 59 60+namespace OHOS { 61+namespace HDI { 62+namespace Nnrt { 63+namespace V2_0 { 64+struct SharedBuffer; 65+} // namespace V2_0 66+} // namespace Nnrt 67+} // namespace HDI 68+} // namespace OHOS 69+ 70 namespace mindspore { 71 namespace lite { 72 73@@ -29,9 +39,15 @@ std::vector<int32_t> MindIR_Tensor_GetDims(ConstTensorPtr tensor); 74 void MindIR_Tensor_SetDims(TensorPtr *tensor, const std::vector<int32_t> &dims); 75 Format MindIR_Tensor_GetFormat(ConstTensorPtr tensor); 76 void MindIR_Tensor_SetFormat(TensorPtr *tensor, Format format); 77+ 78 OHOS::HDI::Nnrt::V1_0::SharedBuffer MindIR_Tensor_GetData(ConstTensorPtr tensor, 79- const OHOS::HDI::Nnrt::V1_0::SharedBuffer &buffer, 80+ const OHOS::HDI::Nnrt::V1_0::SharedBuffer &buffer_templete, 81 uint8_t *mmap_ptr, unsigned int offset); 82+ 83+OHOS::HDI::Nnrt::V2_0::SharedBuffer MindIR_Tensor_GetData_V2_0(ConstTensorPtr tensor, 84+ const OHOS::HDI::Nnrt::V2_0::SharedBuffer &buffer_templete, 85+ uint8_t *mmap_ptr, unsigned int offset); 86+ 87 void MindIR_Tensor_SetData(TensorPtr *tensor, const std::vector<uint8_t> &data); 88 std::vector<uint8_t> MindIR_Tensor_GetData(ConstTensorPtr tensor); 89 std::vector<QuantParam> MindIR_Tensor_GetQuantParams(ConstTensorPtr tensor); 90diff --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 91index dd9202e2..df39e04b 100644 92--- a/mindspore/lite/mindir/src/mindir_nnrt_lite_graph_to_model.cc 93+++ b/mindspore/lite/mindir/src/mindir_nnrt_lite_graph_to_model.cc 94@@ -72,7 +72,7 @@ void MindIR_Model_Destroy(OHOS::HDI::Nnrt::V1_0::Model **model) { 95 } 96 } 97 98-OHOS::HDI::Nnrt::V1_0::Model *MindIR_LiteGraph_To_Model(const LiteGraph *lite_graph, const SharedBuffer &buffer) { 99+OHOS::HDI::Nnrt::V1_0::Model *MindIR_LiteGraph_To_Model(const LiteGraph *lite_graph, const OHOS::HDI::Nnrt::V1_0::SharedBuffer &buffer) { 100 if (lite_graph != nullptr) { 101 MS_LOG(INFO) << "MindIR_LiteGraph_To_Model begin"; 102 if (!lite_graph->name_.empty()) { 103diff --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 104new file mode 100644 105index 00000000..11012492 106--- /dev/null 107+++ b/mindspore/lite/mindir/src/mindir_nnrt_lite_graph_to_model_v2_0.cc 108@@ -0,0 +1,1496 @@ 109+/** 110+ * Copyright 2021 Huawei Technologies Co., Ltd 111+ * 112+ * Licensed under the Apache License, Version 2.0 (the "License"); 113+ * you may not use this file except in compliance with the License. 114+ * You may obtain a copy of the License at 115+ * 116+ * http://www.apache.org/licenses/LICENSE-2.0 117+ * 118+ * Unless required by applicable law or agreed to in writing, software 119+ * distributed under the License is distributed on an "AS IS" BASIS, 120+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 121+ * See the License for the specific language governing permissions and 122+ * limitations under the License. 123+ */ 124+#include "mindir.h" 125+#include <vector> 126+#include <algorithm> 127+#include <sys/mman.h> 128+#include "src/common/log.h" 129+#include "lite_graph.h" 130+#include "schema/model_generated.h" 131+#include "mindir_types.h" 132+#include "message_parcel.h" 133+#include "nnrt/v2_0/nnrt_types.h" 134+#include "nnrt/v2_0/node_attr_types.h" 135+#include "nnrt/v2_0/model_types.h" 136+ 137+using namespace OHOS::HDI::Nnrt::V2_0; 138+namespace mindspore { 139+namespace lite { 140+ 141+constexpr size_t kNumTwo = 2; 142+constexpr size_t kNumFour = 4; 143+constexpr size_t kNumEight = 8; 144+ 145+inline std::vector<OHOS::HDI::Nnrt::V2_0::QuantParam> MindIR_Tensor_GetQuantParams_OHOS_V2_0(TensorPtr tensor) { 146+ if (tensor != nullptr) { 147+ auto value = static_cast<schema::Tensor *>(tensor); 148+ 149+ if (value != nullptr) { 150+ std::vector<OHOS::HDI::Nnrt::V2_0::QuantParam> result; 151+ auto src = value->quantParams(); 152+ if (src == nullptr) { 153+ return {}; 154+ } 155+ size_t size = src->size(); 156+ result.reserve(src->size()); 157+ for (size_t i = 0; i < size; i++) { 158+ auto tmp = src->Get(i); 159+ OHOS::HDI::Nnrt::V2_0::QuantParam quantParam{tmp->numBits(), tmp->zeroPoint(), tmp->scale()}; 160+ result.emplace_back(quantParam); 161+ } 162+ return result; 163+ } else { 164+ return {}; 165+ } 166+ } else { 167+ return {}; 168+ } 169+} 170+ 171+void MindIR_Model_Destroy(OHOS::HDI::Nnrt::V2_0::Model **model) { 172+ if (model != nullptr) { 173+ auto model_data = *model; 174+ if (model_data != nullptr) { 175+ delete (model_data); 176+ *model = nullptr; 177+ } else { 178+ MS_LOG(ERROR) << "*model is nullptr, desrtoy model fail."; 179+ } 180+ } 181+} 182+ 183+std::vector<int8_t> ConvertActivation_V2_0(PrimitivePtr primitive) { 184+ if (primitive != nullptr) { 185+ auto prim = static_cast<schema::Primitive *>(primitive); 186+ auto value = prim->value_as_Activation(); 187+ if (value != nullptr) { 188+ Activation activation{}; 189+ activation.activationType = 190+ static_cast<HDI::Nnrt::V2_0::HDI::Nnrt::V2_0::ActivationType>(value->activation_type()); 191+ activation.alpha = value->alpha(); 192+ activation.minVal = value->min_val(); 193+ activation.maxVal = value->max_val(); 194+ activation.approximate = value->approximate(); 195+ OHOS::MessageParcel data; 196+ (void)ActivationBlockMarshalling(data, activation); 197+ std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 198+ reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 199+ return ret; 200+ } else { 201+ return {}; 202+ } 203+ } else { 204+ return {}; 205+ } 206+} 207+std::vector<int8_t> ConvertAddFusion_V2_0(PrimitivePtr primitive) { 208+ if (primitive != nullptr) { 209+ auto prim = static_cast<schema::Primitive *>(primitive); 210+ auto value = prim->value_as_AddFusion(); 211+ if (value != nullptr) { 212+ AddFusion add_fusion{}; 213+ add_fusion.activationType = static_cast<HDI::Nnrt::V2_0::ActivationType>(value->activation_type()); 214+ OHOS::MessageParcel data; 215+ (void)AddFusionBlockMarshalling(data, add_fusion); 216+ std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 217+ reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 218+ return ret; 219+ } else { 220+ return {}; 221+ } 222+ } else { 223+ return {}; 224+ } 225+} 226+std::vector<int8_t> ConvertArgMaxFusion_V2_0(PrimitivePtr primitive) { 227+ if (primitive != nullptr) { 228+ auto prim = static_cast<schema::Primitive *>(primitive); 229+ auto value = prim->value_as_ArgMaxFusion(); 230+ if (value != nullptr) { 231+ ArgMaxFusion arg_max_fusion{}; 232+ arg_max_fusion.axis = value->axis(); 233+ arg_max_fusion.topK = value->top_k(); 234+ arg_max_fusion.keepDims = value->keep_dims(); 235+ arg_max_fusion.outMaxValue = value->out_max_value(); 236+ OHOS::MessageParcel data; 237+ (void)ArgMaxFusionBlockMarshalling(data, arg_max_fusion); 238+ std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 239+ reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 240+ return ret; 241+ } else { 242+ return {}; 243+ } 244+ } else { 245+ return {}; 246+ } 247+} 248+std::vector<int8_t> ConvertAvgPoolFusion_V2_0(PrimitivePtr primitive) { 249+ if (primitive != nullptr) { 250+ auto prim = static_cast<schema::Primitive *>(primitive); 251+ auto value = prim->value_as_AvgPoolFusion(); 252+ if (value != nullptr) { 253+ AvgPoolFusion avg_pool_fusion{}; 254+ std::vector<int64_t> kernel_size; 255+ kernel_size.reserve(kNumTwo); 256+ if (value->kernel_size() == nullptr || value->kernel_size()->size() < kNumTwo) { 257+ kernel_size = {}; 258+ } else { 259+ kernel_size = std::vector<int64_t>(value->kernel_size()->begin(), value->kernel_size()->end()); 260+ } 261+ std::vector<int64_t> strides; 262+ strides.reserve(kNumTwo); 263+ if (value->strides() == nullptr || value->strides()->size() < kNumTwo) { 264+ strides = {}; 265+ } else { 266+ strides = std::vector<int64_t>(value->strides()->begin(), value->strides()->end()); 267+ } 268+ std::vector<int64_t> padList; 269+ strides.reserve(kNumTwo); 270+ if (value->pad() == nullptr || value->pad()->size() < kNumFour) { 271+ padList = {}; 272+ } else { 273+ padList = std::vector<int64_t>(value->pad()->begin(), value->pad()->end()); 274+ } 275+ avg_pool_fusion.kernelSize = kernel_size; 276+ avg_pool_fusion.strides = strides; 277+ avg_pool_fusion.pad = padList; 278+ avg_pool_fusion.padMode = static_cast<HDI::Nnrt::V2_0::PadMode>(value->pad_mode()); 279+ avg_pool_fusion.roundMode = static_cast<HDI::Nnrt::V2_0::RoundMode>(value->round_mode()); 280+ avg_pool_fusion.format = static_cast<HDI::Nnrt::V2_0::Format>(value->format()); 281+ avg_pool_fusion.global = value->global(); 282+ avg_pool_fusion.activationType = static_cast<HDI::Nnrt::V2_0::ActivationType>(value->activation_type()); 283+ OHOS::MessageParcel data; 284+ (void)AvgPoolFusionBlockMarshalling(data, avg_pool_fusion); 285+ std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 286+ reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 287+ return ret; 288+ } else { 289+ return {}; 290+ } 291+ } else { 292+ return {}; 293+ } 294+} 295+std::vector<int8_t> ConvertBatchToSpaceND_V2_0(PrimitivePtr primitive) { 296+ if (primitive != nullptr) { 297+ auto prim = static_cast<schema::Primitive *>(primitive); 298+ auto value = prim->value_as_BatchToSpaceND(); 299+ if (value != nullptr) { 300+ BatchToSpaceND batch_to_space_n_d{}; 301+ std::vector<int64_t> blockShape; 302+ blockShape.reserve(kNumTwo); 303+ if (value->block_shape() == nullptr || value->block_shape()->size() < kNumTwo) { 304+ blockShape = {0, 0}; 305+ } else { 306+ blockShape = std::vector<int64_t>(value->block_shape()->begin(), value->block_shape()->end()); 307+ } 308+ batch_to_space_n_d.blockShape = blockShape; 309+ auto crops = value->crops(); 310+ std::vector<std::vector<int64_t>> crops_vec2d; 311+ if (crops->data() == nullptr) { 312+ MS_LOG(ERROR) << "crops_data is nullptr"; 313+ crops_vec2d = {{}}; 314+ } else { 315+ crops_vec2d.reserve(crops->data()->size()); 316+ for (size_t i = 0; i < crops->data()->size(); i++) { 317+ auto vet = crops->data()->Get(i); 318+ crops_vec2d.emplace_back(std::vector<int64_t>(vet->data()->begin(), vet->data()->end())); 319+ } 320+ } 321+ batch_to_space_n_d.crops = crops_vec2d; 322+ OHOS::MessageParcel data; 323+ (void)BatchToSpaceNDBlockMarshalling(data, batch_to_space_n_d); 324+ std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 325+ reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 326+ return ret; 327+ } else { 328+ return {}; 329+ } 330+ } else { 331+ return {}; 332+ } 333+} 334+std::vector<int8_t> ConvertBiasAdd_V2_0(PrimitivePtr primitive) { 335+ if (primitive != nullptr) { 336+ auto prim = static_cast<schema::Primitive *>(primitive); 337+ auto value = prim->value_as_BiasAdd(); 338+ if (value != nullptr) { 339+ BiasAdd bias_add{}; 340+ OHOS::MessageParcel data; 341+ (void)BiasAddBlockMarshalling(data, bias_add); 342+ std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 343+ reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 344+ return ret; 345+ } else { 346+ return {}; 347+ } 348+ } else { 349+ return {}; 350+ } 351+} 352+std::vector<int8_t> ConvertCast_V2_0(PrimitivePtr primitive) { 353+ if (primitive != nullptr) { 354+ auto prim = static_cast<schema::Primitive *>(primitive); 355+ auto value = prim->value_as_Cast(); 356+ if (value != nullptr) { 357+ Cast cast{}; 358+ OHOS::MessageParcel data; 359+ (void)CastBlockMarshalling(data, cast); 360+ std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 361+ reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 362+ return ret; 363+ } else { 364+ return {}; 365+ } 366+ } else { 367+ return {}; 368+ } 369+} 370+std::vector<int8_t> ConvertConcat_V2_0(PrimitivePtr primitive) { 371+ if (primitive != nullptr) { 372+ auto prim = static_cast<schema::Primitive *>(primitive); 373+ auto value = prim->value_as_Concat(); 374+ if (value != nullptr) { 375+ Concat concat{}; 376+ concat.axis = value->axis(); 377+ OHOS::MessageParcel data; 378+ (void)ConcatBlockMarshalling(data, concat); 379+ std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 380+ reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 381+ return ret; 382+ } else { 383+ return {}; 384+ } 385+ } else { 386+ return {}; 387+ } 388+} 389+std::vector<int8_t> ConvertConv2DFusion_V2_0(PrimitivePtr primitive) { 390+ if (primitive != nullptr) { 391+ auto prim = static_cast<schema::Primitive *>(primitive); 392+ auto value = prim->value_as_Conv2DFusion(); 393+ if (value != nullptr) { 394+ Conv2DFusion conv2_d_fusion{}; 395+ std::vector<int64_t> kernel_size; 396+ kernel_size.reserve(kNumTwo); 397+ if (value->kernel_size() == nullptr || value->kernel_size()->size() < kNumTwo) { 398+ kernel_size = {}; 399+ } else { 400+ kernel_size = std::vector<int64_t>(value->kernel_size()->begin(), value->kernel_size()->end()); 401+ } 402+ std::vector<int64_t> strides; 403+ strides.reserve(kNumTwo); 404+ if (value->stride() == nullptr || value->stride()->size() < kNumTwo) { 405+ strides = {}; 406+ } else { 407+ strides = std::vector<int64_t>(value->stride()->begin(), value->stride()->end()); 408+ } 409+ std::vector<int64_t> dilation; 410+ dilation.reserve(kNumTwo); 411+ if (value->dilation() == nullptr || value->dilation()->size() < kNumTwo) { 412+ dilation = {}; 413+ } else { 414+ dilation = std::vector<int64_t>(value->dilation()->begin(), value->dilation()->end()); 415+ } 416+ std::vector<int64_t> padList; 417+ strides.reserve(kNumTwo); 418+ if (value->pad_list() == nullptr || value->pad_list()->size() < kNumFour) { 419+ padList = {}; 420+ } else { 421+ padList = std::vector<int64_t>(value->pad_list()->begin(), value->pad_list()->end()); 422+ } 423+ conv2_d_fusion.kernelSize = kernel_size; 424+ conv2_d_fusion.stride = strides; 425+ conv2_d_fusion.dilation = dilation; 426+ conv2_d_fusion.padMode = static_cast<HDI::Nnrt::V2_0::PadMode>(value->pad_mode()); 427+ conv2_d_fusion.padList = padList; 428+ conv2_d_fusion.group = value->group(); 429+ conv2_d_fusion.inChannel = value->in_channel(); 430+ conv2_d_fusion.outChannel = value->out_channel(); 431+ conv2_d_fusion.activationType = static_cast<HDI::Nnrt::V2_0::ActivationType>(value->activation_type()); 432+ OHOS::MessageParcel data; 433+ (void)Conv2DFusionBlockMarshalling(data, conv2_d_fusion); 434+ std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 435+ reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 436+ return ret; 437+ } else { 438+ return {}; 439+ } 440+ } else { 441+ return {}; 442+ } 443+} 444+std::vector<int8_t> ConvertConv2dTransposeFusion_V2_0(PrimitivePtr primitive) { 445+ if (primitive != nullptr) { 446+ auto prim = static_cast<schema::Primitive *>(primitive); 447+ auto value = prim->value_as_Conv2dTransposeFusion(); 448+ if (value != nullptr) { 449+ Conv2dTransposeFusion conv2d_transpose_fusion{}; 450+ std::vector<int64_t> kernel_size; 451+ kernel_size.reserve(kNumTwo); 452+ if (value->kernel_size() == nullptr || value->kernel_size()->size() < kNumTwo) { 453+ kernel_size = {}; 454+ } else { 455+ kernel_size = std::vector<int64_t>(value->kernel_size()->begin(), value->kernel_size()->end()); 456+ } 457+ std::vector<int64_t> strides; 458+ strides.reserve(kNumTwo); 459+ if (value->stride() == nullptr || value->stride()->size() < kNumTwo) { 460+ strides = {}; 461+ } else { 462+ strides = std::vector<int64_t>(value->stride()->begin(), value->stride()->end()); 463+ } 464+ std::vector<int64_t> dilation; 465+ dilation.reserve(kNumTwo); 466+ if (value->dilation() == nullptr || value->dilation()->size() < kNumTwo) { 467+ dilation = {}; 468+ } else { 469+ dilation = std::vector<int64_t>(value->dilation()->begin(), value->dilation()->end()); 470+ } 471+ std::vector<int64_t> padList; 472+ strides.reserve(kNumTwo); 473+ if (value->pad_list() == nullptr || value->pad_list()->size() < kNumFour) { 474+ padList = {}; 475+ } else { 476+ padList = std::vector<int64_t>(value->pad_list()->begin(), value->pad_list()->end()); 477+ } 478+ std::vector<int64_t> output_paddings; 479+ output_paddings.reserve(kNumTwo); 480+ if (value->output_paddings() == nullptr || value->output_paddings()->size() < kNumTwo) { 481+ output_paddings = {}; 482+ } else { 483+ output_paddings = std::vector<int64_t>(value->output_paddings()->begin(), value->output_paddings()->end()); 484+ } 485+ conv2d_transpose_fusion.kernelSize = kernel_size; 486+ conv2d_transpose_fusion.stride = strides; 487+ conv2d_transpose_fusion.dilation = dilation; 488+ conv2d_transpose_fusion.padMode = static_cast<HDI::Nnrt::V2_0::PadMode>(value->pad_mode()); 489+ conv2d_transpose_fusion.padList = padList; 490+ conv2d_transpose_fusion.group = value->group(); 491+ conv2d_transpose_fusion.inChannel = value->in_channel(); 492+ conv2d_transpose_fusion.outChannel = value->out_channel(); 493+ conv2d_transpose_fusion.activationType = static_cast<HDI::Nnrt::V2_0::ActivationType>(value->activation_type()); 494+ conv2d_transpose_fusion.outputPaddings = output_paddings; 495+ OHOS::MessageParcel data; 496+ (void)Conv2dTransposeFusionBlockMarshalling(data, conv2d_transpose_fusion); 497+ std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 498+ reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 499+ return ret; 500+ } else { 501+ return {}; 502+ } 503+ } else { 504+ return {}; 505+ } 506+} 507+std::vector<int8_t> ConvertDivFusion_V2_0(PrimitivePtr primitive) { 508+ if (primitive != nullptr) { 509+ auto prim = static_cast<schema::Primitive *>(primitive); 510+ auto value = prim->value_as_DivFusion(); 511+ if (value != nullptr) { 512+ DivFusion div_fusion{}; 513+ div_fusion.activationType = static_cast<HDI::Nnrt::V2_0::ActivationType>(value->activation_type()); 514+ OHOS::MessageParcel data; 515+ (void)DivFusionBlockMarshalling(data, div_fusion); 516+ std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 517+ reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 518+ return ret; 519+ } else { 520+ return {}; 521+ } 522+ } else { 523+ return {}; 524+ } 525+} 526+std::vector<int8_t> ConvertEltwise_V2_0(PrimitivePtr primitive) { 527+ if (primitive != nullptr) { 528+ auto prim = static_cast<schema::Primitive *>(primitive); 529+ auto value = prim->value_as_Eltwise(); 530+ if (value != nullptr) { 531+ Eltwise eltwise{}; 532+ eltwise.mode = static_cast<HDI::Nnrt::V2_0::EltwiseMode>(value->mode()); 533+ OHOS::MessageParcel data; 534+ (void)EltwiseBlockMarshalling(data, eltwise); 535+ std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 536+ reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 537+ return ret; 538+ } else { 539+ return {}; 540+ } 541+ } else { 542+ return {}; 543+ } 544+} 545+std::vector<int8_t> ConvertExpandDims_V2_0(PrimitivePtr primitive) { 546+ if (primitive != nullptr) { 547+ auto prim = static_cast<schema::Primitive *>(primitive); 548+ auto value = prim->value_as_ExpandDims(); 549+ if (value != nullptr) { 550+ ExpandDims expand_dims{}; 551+ OHOS::MessageParcel data; 552+ (void)ExpandDimsBlockMarshalling(data, expand_dims); 553+ std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 554+ reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 555+ return ret; 556+ } else { 557+ return {}; 558+ } 559+ } else { 560+ return {}; 561+ } 562+} 563+std::vector<int8_t> ConvertFill_V2_0(PrimitivePtr primitive) { 564+ if (primitive != nullptr) { 565+ auto prim = static_cast<schema::Primitive *>(primitive); 566+ auto value = prim->value_as_Fill(); 567+ if (value != nullptr) { 568+ Fill fill{}; 569+ OHOS::MessageParcel data; 570+ (void)FillBlockMarshalling(data, fill); 571+ std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 572+ reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 573+ return ret; 574+ } else { 575+ return {}; 576+ } 577+ } else { 578+ return {}; 579+ } 580+} 581+std::vector<int8_t> ConvertFullConnection_V2_0(PrimitivePtr primitive) { 582+ if (primitive != nullptr) { 583+ auto prim = static_cast<schema::Primitive *>(primitive); 584+ auto value = prim->value_as_FullConnection(); 585+ if (value != nullptr) { 586+ FullConnection full_connection{}; 587+ full_connection.hasBias = value->has_bias(); 588+ full_connection.useAxis = value->use_axis(); 589+ full_connection.axis = value->axis(); 590+ full_connection.activationType = static_cast<HDI::Nnrt::V2_0::ActivationType>(value->activation_type()); 591+ OHOS::MessageParcel data; 592+ (void)FullConnectionBlockMarshalling(data, full_connection); 593+ std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 594+ reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 595+ return ret; 596+ } else { 597+ return {}; 598+ } 599+ } else { 600+ return {}; 601+ } 602+} 603+std::vector<int8_t> ConvertFusedBatchNorm_V2_0(PrimitivePtr primitive) { 604+ if (primitive != nullptr) { 605+ auto prim = static_cast<schema::Primitive *>(primitive); 606+ auto value = prim->value_as_FusedBatchNorm(); 607+ if (value != nullptr) { 608+ FusedBatchNorm fused_batch_norm{}; 609+ fused_batch_norm.epsilon = value->epsilon(); 610+ OHOS::MessageParcel data; 611+ (void)FusedBatchNormBlockMarshalling(data, fused_batch_norm); 612+ std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 613+ reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 614+ return ret; 615+ } else { 616+ return {}; 617+ } 618+ } else { 619+ return {}; 620+ } 621+} 622+std::vector<int8_t> ConvertGather_V2_0(PrimitivePtr primitive) { 623+ if (primitive != nullptr) { 624+ auto prim = static_cast<schema::Primitive *>(primitive); 625+ auto value = prim->value_as_Gather(); 626+ if (value != nullptr) { 627+ Gather gather{}; 628+ OHOS::MessageParcel data; 629+ (void)GatherBlockMarshalling(data, gather); 630+ std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 631+ reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 632+ return ret; 633+ } else { 634+ return {}; 635+ } 636+ } else { 637+ return {}; 638+ } 639+} 640+std::vector<int8_t> ConvertLayerNormFusion_V2_0(PrimitivePtr primitive) { 641+ if (primitive != nullptr) { 642+ auto prim = static_cast<schema::Primitive *>(primitive); 643+ auto value = prim->value_as_LayerNormFusion(); 644+ if (value != nullptr) { 645+ LayerNormFusion layer_norm_fusion{}; 646+ layer_norm_fusion.beginNormAxis = value->begin_norm_axis(); 647+ layer_norm_fusion.epsilon = value->epsilon(); 648+ layer_norm_fusion.elementwiseAffine = value->elementwise_affine(); 649+ layer_norm_fusion.beginParamsAxis = value->begin_params_axis(); 650+ OHOS::MessageParcel data; 651+ (void)LayerNormFusionBlockMarshalling(data, layer_norm_fusion); 652+ std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 653+ reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 654+ return ret; 655+ } else { 656+ return {}; 657+ } 658+ } else { 659+ return {}; 660+ } 661+} 662+std::vector<int8_t> ConvertLessEqual_V2_0(PrimitivePtr primitive) { 663+ if (primitive != nullptr) { 664+ auto prim = static_cast<schema::Primitive *>(primitive); 665+ auto value = prim->value_as_LessEqual(); 666+ if (value != nullptr) { 667+ LessEqual less_equal{}; 668+ OHOS::MessageParcel data; 669+ (void)LessEqualBlockMarshalling(data, less_equal); 670+ std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 671+ reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 672+ return ret; 673+ } else { 674+ return {}; 675+ } 676+ } else { 677+ return {}; 678+ } 679+} 680+std::vector<int8_t> ConvertMatMulFusion_V2_0(PrimitivePtr primitive) { 681+ if (primitive != nullptr) { 682+ auto prim = static_cast<schema::Primitive *>(primitive); 683+ auto value = prim->value_as_MatMulFusion(); 684+ if (value != nullptr) { 685+ MatMulFusion mat_mul_fusion{}; 686+ mat_mul_fusion.transposeA = value->transpose_a(); 687+ mat_mul_fusion.transposeB = value->transpose_b(); 688+ mat_mul_fusion.activationType = static_cast<HDI::Nnrt::V2_0::ActivationType>(value->activation_type()); 689+ OHOS::MessageParcel data; 690+ (void)MatMulFusionBlockMarshalling(data, mat_mul_fusion); 691+ std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 692+ reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 693+ return ret; 694+ } else { 695+ return {}; 696+ } 697+ } else { 698+ return {}; 699+ } 700+} 701+std::vector<int8_t> ConvertMaximum_V2_0(PrimitivePtr primitive) { 702+ if (primitive != nullptr) { 703+ auto prim = static_cast<schema::Primitive *>(primitive); 704+ auto value = prim->value_as_Maximum(); 705+ if (value != nullptr) { 706+ Maximum maximum{}; 707+ OHOS::MessageParcel data; 708+ (void)MaximumBlockMarshalling(data, maximum); 709+ std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 710+ reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 711+ return ret; 712+ } else { 713+ return {}; 714+ } 715+ } else { 716+ return {}; 717+ } 718+} 719+std::vector<int8_t> ConvertMaxPoolFusion_V2_0(PrimitivePtr primitive) { 720+ if (primitive != nullptr) { 721+ auto prim = static_cast<schema::Primitive *>(primitive); 722+ auto value = prim->value_as_MaxPoolFusion(); 723+ if (value != nullptr) { 724+ MaxPoolFusion max_pool_fusion{}; 725+ std::vector<int64_t> kernel_size; 726+ kernel_size.reserve(kNumTwo); 727+ if (value->kernel_size() == nullptr || value->kernel_size()->size() < kNumTwo) { 728+ kernel_size = {}; 729+ } else { 730+ kernel_size = std::vector<int64_t>(value->kernel_size()->begin(), value->kernel_size()->end()); 731+ } 732+ std::vector<int64_t> strides; 733+ strides.reserve(kNumTwo); 734+ if (value->strides() == nullptr || value->strides()->size() < kNumTwo) { 735+ strides = {}; 736+ } else { 737+ strides = std::vector<int64_t>(value->strides()->begin(), value->strides()->end()); 738+ } 739+ std::vector<int64_t> padList; 740+ padList.reserve(kNumFour); 741+ if (value->pad() == nullptr || value->pad()->size() < kNumFour) { 742+ padList = {}; 743+ } else { 744+ padList = std::vector<int64_t>(value->pad()->begin(), value->pad()->end()); 745+ } 746+ max_pool_fusion.kernelSize = kernel_size; 747+ max_pool_fusion.strides = strides; 748+ max_pool_fusion.pad = padList; 749+ max_pool_fusion.padMode = static_cast<HDI::Nnrt::V2_0::PadMode>(value->pad_mode()); 750+ max_pool_fusion.format = static_cast<HDI::Nnrt::V2_0::Format>(value->format()); 751+ max_pool_fusion.global = value->global(); 752+ max_pool_fusion.activationType = static_cast<HDI::Nnrt::V2_0::ActivationType>(value->activation_type()); 753+ OHOS::MessageParcel data; 754+ (void)MaxPoolFusionBlockMarshalling(data, max_pool_fusion); 755+ std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 756+ reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 757+ return ret; 758+ } else { 759+ return {}; 760+ } 761+ } else { 762+ return {}; 763+ } 764+} 765+std::vector<int8_t> ConvertMulFusion_V2_0(PrimitivePtr primitive) { 766+ if (primitive != nullptr) { 767+ auto prim = static_cast<schema::Primitive *>(primitive); 768+ auto value = prim->value_as_MulFusion(); 769+ if (value != nullptr) { 770+ MulFusion mul_fusion{}; 771+ mul_fusion.activationType = static_cast<HDI::Nnrt::V2_0::ActivationType>(value->activation_type()); 772+ OHOS::MessageParcel data; 773+ (void)MulFusionBlockMarshalling(data, mul_fusion); 774+ std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 775+ reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 776+ return ret; 777+ } else { 778+ return {}; 779+ } 780+ } else { 781+ return {}; 782+ } 783+} 784+std::vector<int8_t> ConvertOneHot_V2_0(PrimitivePtr primitive) { 785+ if (primitive != nullptr) { 786+ auto prim = static_cast<schema::Primitive *>(primitive); 787+ auto value = prim->value_as_OneHot(); 788+ if (value != nullptr) { 789+ OneHot one_hot{}; 790+ one_hot.axis = value->axis(); 791+ OHOS::MessageParcel data; 792+ (void)OneHotBlockMarshalling(data, one_hot); 793+ std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 794+ reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 795+ return ret; 796+ } else { 797+ return {}; 798+ } 799+ } else { 800+ return {}; 801+ } 802+} 803+std::vector<int8_t> ConvertPadFusion_V2_0(PrimitivePtr primitive) { 804+ if (primitive != nullptr) { 805+ auto prim = static_cast<schema::Primitive *>(primitive); 806+ auto value = prim->value_as_PadFusion(); 807+ if (value != nullptr) { 808+ PadFusion pad_fusion{}; 809+ auto paddings = value->paddings(); 810+ std::vector<std::vector<int64_t>> paddings_vec2d; 811+ if (paddings == nullptr || paddings->data()->size() < kNumTwo) { 812+ paddings_vec2d = {{0}, {0}, {0}, {0}}; 813+ } else { 814+ paddings_vec2d.reserve(paddings->data()->size()); 815+ for (size_t i = 0; i < paddings->data()->size(); i++) { 816+ auto vet = paddings->data()->Get(i); 817+ paddings_vec2d.emplace_back(std::vector<int64_t>(vet->data()->begin(), vet->data()->end())); 818+ } 819+ } 820+ pad_fusion.paddings = paddings_vec2d; 821+ pad_fusion.paddingMode = static_cast<HDI::Nnrt::V2_0::PaddingMode>(value->padding_mode()); 822+ pad_fusion.constantValue = value->constant_value(); 823+ OHOS::MessageParcel data; 824+ (void)PadFusionBlockMarshalling(data, pad_fusion); 825+ std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 826+ reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 827+ return ret; 828+ } else { 829+ return {}; 830+ } 831+ } else { 832+ return {}; 833+ } 834+} 835+std::vector<int8_t> ConvertPowFusion_V2_0(PrimitivePtr primitive) { 836+ if (primitive != nullptr) { 837+ auto prim = static_cast<schema::Primitive *>(primitive); 838+ auto value = prim->value_as_PowFusion(); 839+ if (value != nullptr) { 840+ PowFusion pow_fusion{}; 841+ pow_fusion.scale = value->scale(); 842+ pow_fusion.shift = value->shift(); 843+ OHOS::MessageParcel data; 844+ (void)PowFusionBlockMarshalling(data, pow_fusion); 845+ std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 846+ reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 847+ return ret; 848+ } else { 849+ return {}; 850+ } 851+ } else { 852+ return {}; 853+ } 854+} 855+std::vector<int8_t> ConvertPReLUFusion_V2_0(PrimitivePtr primitive) { 856+ if (primitive != nullptr) { 857+ auto prim = static_cast<schema::Primitive *>(primitive); 858+ auto value = prim->value_as_PReLUFusion(); 859+ if (value != nullptr) { 860+ PReLUFusion p_re_l_u_fusion{}; 861+ p_re_l_u_fusion.channelShared = value->channel_shared(); 862+ OHOS::MessageParcel data; 863+ (void)PReLUFusionBlockMarshalling(data, p_re_l_u_fusion); 864+ std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 865+ reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 866+ return ret; 867+ } else { 868+ return {}; 869+ } 870+ } else { 871+ return {}; 872+ } 873+} 874+std::vector<int8_t> ConvertQuantDTypeCast_V2_0(PrimitivePtr primitive) { 875+ if (primitive != nullptr) { 876+ auto prim = static_cast<schema::Primitive *>(primitive); 877+ auto value = prim->value_as_QuantDTypeCast(); 878+ if (value != nullptr) { 879+ QuantDTypeCast quant_d_type_cast{}; 880+ quant_d_type_cast.srcT = value->src_t(); 881+ quant_d_type_cast.dstT = value->dst_t(); 882+ OHOS::MessageParcel data; 883+ (void)QuantDTypeCastBlockMarshalling(data, quant_d_type_cast); 884+ std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 885+ reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 886+ return ret; 887+ } else { 888+ return {}; 889+ } 890+ } else { 891+ return {}; 892+ } 893+} 894+std::vector<int8_t> ConvertReduceFusion_V2_0(PrimitivePtr primitive) { 895+ if (primitive != nullptr) { 896+ auto prim = static_cast<schema::Primitive *>(primitive); 897+ auto value = prim->value_as_ReduceFusion(); 898+ if (value != nullptr) { 899+ ReduceFusion reduce_fusion{}; 900+ reduce_fusion.keepDims = value->keep_dims(); 901+ reduce_fusion.mode = static_cast<HDI::Nnrt::V2_0::ReduceMode>(value->mode()); 902+ reduce_fusion.reduceToEnd = value->reduce_to_end(); 903+ reduce_fusion.coeff = value->coeff(); 904+ OHOS::MessageParcel data; 905+ (void)ReduceFusionBlockMarshalling(data, reduce_fusion); 906+ std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 907+ reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 908+ return ret; 909+ } else { 910+ return {}; 911+ } 912+ } else { 913+ return {}; 914+ } 915+} 916+std::vector<int8_t> ConvertReshape_V2_0(PrimitivePtr primitive) { 917+ if (primitive != nullptr) { 918+ auto prim = static_cast<schema::Primitive *>(primitive); 919+ auto value = prim->value_as_Reshape(); 920+ if (value != nullptr) { 921+ Reshape reshape{}; 922+ OHOS::MessageParcel data; 923+ (void)ReshapeBlockMarshalling(data, reshape); 924+ std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 925+ reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 926+ return ret; 927+ } else { 928+ return {}; 929+ } 930+ } else { 931+ return {}; 932+ } 933+} 934+ 935+std::vector<int8_t> ConvertResize_V2_0(PrimitivePtr primitive) { 936+ if (primitive != nullptr) { 937+ auto prim = static_cast<schema::Primitive *>(primitive); 938+ auto value = prim->value_as_Resize(); 939+ if (value != nullptr) { 940+ Resize resize{}; 941+ resize.method = static_cast<HDI::Nnrt::V2_0::ResizeMethod>(value->method()); 942+ resize.newHeight = value->new_height(); 943+ resize.newWidth = value->new_width(); 944+ resize.preserveAspectRatio = value->preserve_aspect_ratio(); 945+ resize.coordinateTransformMode = 946+ static_cast<HDI::Nnrt::V2_0::CoordinateTransformMode>(value->coordinate_transform_mode()); 947+ resize.cubicCoeff = value->cubic_coeff(); 948+ resize.excludeOutside = value->exclude_outside(); 949+ resize.extrapolationValue = value->extrapolation_value(); 950+ resize.nearestMode = static_cast<HDI::Nnrt::V2_0::NearestMode>(value->nearest_mode()); 951+ OHOS::MessageParcel data; 952+ (void)ResizeBlockMarshalling(data, resize); 953+ std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 954+ reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 955+ return ret; 956+ } else { 957+ return {}; 958+ } 959+ } else { 960+ return {}; 961+ } 962+} 963+std::vector<int8_t> ConvertRsqrt_V2_0(PrimitivePtr primitive) { 964+ if (primitive != nullptr) { 965+ auto prim = static_cast<schema::Primitive *>(primitive); 966+ auto value = prim->value_as_Rsqrt(); 967+ if (value != nullptr) { 968+ Rsqrt rsqrt{}; 969+ OHOS::MessageParcel data; 970+ (void)RsqrtBlockMarshalling(data, rsqrt); 971+ std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 972+ reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 973+ return ret; 974+ } else { 975+ return {}; 976+ } 977+ } else { 978+ return {}; 979+ } 980+} 981+std::vector<int8_t> ConvertScaleFusion_V2_0(PrimitivePtr primitive) { 982+ if (primitive != nullptr) { 983+ auto prim = static_cast<schema::Primitive *>(primitive); 984+ auto value = prim->value_as_ScaleFusion(); 985+ if (value != nullptr) { 986+ ScaleFusion scale_fusion{}; 987+ scale_fusion.axis = value->axis(); 988+ scale_fusion.activationType = static_cast<HDI::Nnrt::V2_0::ActivationType>(value->activation_type()); 989+ OHOS::MessageParcel data; 990+ (void)ScaleFusionBlockMarshalling(data, scale_fusion); 991+ std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 992+ reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 993+ return ret; 994+ } else { 995+ return {}; 996+ } 997+ } else { 998+ return {}; 999+ } 1000+} 1001+std::vector<int8_t> ConvertShape_V2_0(PrimitivePtr primitive) { 1002+ if (primitive != nullptr) { 1003+ auto prim = static_cast<schema::Primitive *>(primitive); 1004+ auto value = prim->value_as_Shape(); 1005+ if (value != nullptr) { 1006+ Shape shape{}; 1007+ OHOS::MessageParcel data; 1008+ (void)ShapeBlockMarshalling(data, shape); 1009+ std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 1010+ reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 1011+ return ret; 1012+ } else { 1013+ return {}; 1014+ } 1015+ } else { 1016+ return {}; 1017+ } 1018+} 1019+std::vector<int8_t> ConvertSliceFusion_V2_0(PrimitivePtr primitive) { 1020+ if (primitive != nullptr) { 1021+ auto prim = static_cast<schema::Primitive *>(primitive); 1022+ auto value = prim->value_as_SliceFusion(); 1023+ if (value != nullptr) { 1024+ SliceFusion slice_fusion{}; 1025+ std::vector<int64_t> axes; 1026+ if (value->axes() == nullptr) { 1027+ axes = {1, 2, 3, 4, 5, 6, 7}; 1028+ } else { 1029+ axes = std::vector<int64_t>(value->axes()->begin(), value->axes()->end()); 1030+ } 1031+ slice_fusion.axes = axes; 1032+ OHOS::MessageParcel data; 1033+ (void)SliceFusionBlockMarshalling(data, slice_fusion); 1034+ std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 1035+ reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 1036+ return ret; 1037+ } else { 1038+ return {}; 1039+ } 1040+ } else { 1041+ return {}; 1042+ } 1043+} 1044+std::vector<int8_t> ConvertSoftmax_V2_0(PrimitivePtr primitive) { 1045+ if (primitive != nullptr) { 1046+ auto prim = static_cast<schema::Primitive *>(primitive); 1047+ auto value = prim->value_as_Softmax(); 1048+ if (value != nullptr) { 1049+ Softmax softmax{}; 1050+ std::vector<int64_t> axis; 1051+ if (value->axis() == nullptr) { 1052+ axis = {}; 1053+ } else { 1054+ axis = std::vector<int64_t>(value->axis()->begin(), value->axis()->end()); 1055+ } 1056+ softmax.axis = axis; 1057+ OHOS::MessageParcel data; 1058+ (void)SoftmaxBlockMarshalling(data, softmax); 1059+ std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 1060+ reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 1061+ return ret; 1062+ } else { 1063+ return {}; 1064+ } 1065+ } else { 1066+ return {}; 1067+ } 1068+} 1069+std::vector<int8_t> ConvertSpaceToBatchND_V2_0(PrimitivePtr primitive) { 1070+ if (primitive != nullptr) { 1071+ auto prim = static_cast<schema::Primitive *>(primitive); 1072+ auto value = prim->value_as_SpaceToBatchND(); 1073+ if (value != nullptr) { 1074+ SpaceToBatchND space_to_batch_n_d{}; 1075+ std::vector<int64_t> blockShape; 1076+ blockShape.reserve(kNumTwo); 1077+ if (value->block_shape() == nullptr || value->block_shape()->size() < kNumTwo) { 1078+ blockShape = {0, 0}; 1079+ } else { 1080+ blockShape = std::vector<int64_t>(value->block_shape()->begin(), value->block_shape()->end()); 1081+ } 1082+ space_to_batch_n_d.blockShape = blockShape; 1083+ auto paddings = value->paddings(); 1084+ std::vector<std::vector<int64_t>> paddings_vec2d; 1085+ if (paddings == nullptr || paddings->data()->size() == 0 || *(paddings->data()->begin()) == nullptr || 1086+ (*(paddings->data()->begin()))->data() == nullptr) { 1087+ paddings_vec2d = {}; 1088+ } else { 1089+ paddings_vec2d.reserve(paddings->data()->size()); 1090+ for (size_t i = 0; i < paddings->data()->size(); i++) { 1091+ auto vet = paddings->data()->Get(i); 1092+ paddings_vec2d.emplace_back(std::vector<int64_t>(vet->data()->begin(), vet->data()->end())); 1093+ } 1094+ } 1095+ space_to_batch_n_d.paddings = paddings_vec2d; 1096+ OHOS::MessageParcel data; 1097+ (void)SpaceToBatchNDBlockMarshalling(data, space_to_batch_n_d); 1098+ std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 1099+ reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 1100+ return ret; 1101+ } else { 1102+ return {}; 1103+ } 1104+ } else { 1105+ return {}; 1106+ } 1107+} 1108+std::vector<int8_t> ConvertSplit_V2_0(PrimitivePtr primitive) { 1109+ if (primitive != nullptr) { 1110+ auto prim = static_cast<schema::Primitive *>(primitive); 1111+ auto value = prim->value_as_Split(); 1112+ if (value != nullptr) { 1113+ Split split{}; 1114+ split.outputNum = value->output_num(); 1115+ std::vector<int64_t> sizeSplits; 1116+ sizeSplits.reserve(split.outputNum); 1117+ if (value->size_splits() == nullptr || value->size_splits()->size() <= static_cast<uint32_t>(split.outputNum)) { 1118+ sizeSplits = {}; 1119+ } else { 1120+ sizeSplits = std::vector<int64_t>(value->size_splits()->begin(), value->size_splits()->end()); 1121+ } 1122+ split.sizeSplits = sizeSplits; 1123+ split.axis = value->axis(); 1124+ OHOS::MessageParcel data; 1125+ (void)SplitBlockMarshalling(data, split); 1126+ std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 1127+ reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 1128+ return ret; 1129+ } else { 1130+ return {}; 1131+ } 1132+ } else { 1133+ return {}; 1134+ } 1135+} 1136+std::vector<int8_t> ConvertSqrt_V2_0(PrimitivePtr primitive) { 1137+ if (primitive != nullptr) { 1138+ auto prim = static_cast<schema::Primitive *>(primitive); 1139+ auto value = prim->value_as_Sqrt(); 1140+ if (value != nullptr) { 1141+ Sqrt sqrt{}; 1142+ OHOS::MessageParcel data; 1143+ (void)SqrtBlockMarshalling(data, sqrt); 1144+ std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 1145+ reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 1146+ return ret; 1147+ } else { 1148+ return {}; 1149+ } 1150+ } else { 1151+ return {}; 1152+ } 1153+} 1154+std::vector<int8_t> ConvertSquaredDifference_V2_0(PrimitivePtr primitive) { 1155+ if (primitive != nullptr) { 1156+ auto prim = static_cast<schema::Primitive *>(primitive); 1157+ auto value = prim->value_as_SquaredDifference(); 1158+ if (value != nullptr) { 1159+ SquaredDifference squared_difference{}; 1160+ OHOS::MessageParcel data; 1161+ (void)SquaredDifferenceBlockMarshalling(data, squared_difference); 1162+ std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 1163+ reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 1164+ return ret; 1165+ } else { 1166+ return {}; 1167+ } 1168+ } else { 1169+ return {}; 1170+ } 1171+} 1172+std::vector<int8_t> ConvertSqueeze_V2_0(PrimitivePtr primitive) { 1173+ if (primitive != nullptr) { 1174+ auto prim = static_cast<schema::Primitive *>(primitive); 1175+ auto value = prim->value_as_Squeeze(); 1176+ if (value != nullptr) { 1177+ Squeeze squeeze{}; 1178+ std::vector<int64_t> axis; 1179+ if (value->axis() == nullptr) { 1180+ axis = {}; 1181+ } else { 1182+ axis = std::vector<int64_t>(value->axis()->begin(), value->axis()->end()); 1183+ } 1184+ squeeze.axis = axis; 1185+ OHOS::MessageParcel data; 1186+ (void)SqueezeBlockMarshalling(data, squeeze); 1187+ std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 1188+ reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 1189+ return ret; 1190+ } else { 1191+ return {}; 1192+ } 1193+ } else { 1194+ return {}; 1195+ } 1196+} 1197+std::vector<int8_t> ConvertStack_V2_0(PrimitivePtr primitive) { 1198+ if (primitive != nullptr) { 1199+ auto prim = static_cast<schema::Primitive *>(primitive); 1200+ auto value = prim->value_as_Stack(); 1201+ if (value != nullptr) { 1202+ Stack stack{}; 1203+ stack.axis = value->axis(); 1204+ OHOS::MessageParcel data; 1205+ (void)StackBlockMarshalling(data, stack); 1206+ std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 1207+ reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 1208+ return ret; 1209+ } else { 1210+ return {}; 1211+ } 1212+ } else { 1213+ return {}; 1214+ } 1215+} 1216+std::vector<int8_t> ConvertStridedSlice_V2_0(PrimitivePtr primitive) { 1217+ if (primitive != nullptr) { 1218+ auto prim = static_cast<schema::Primitive *>(primitive); 1219+ auto value = prim->value_as_StridedSlice(); 1220+ if (value != nullptr) { 1221+ StridedSlice strided_slice{}; 1222+ strided_slice.beginMask = value->begin_mask(); 1223+ strided_slice.endMask = value->end_mask(); 1224+ strided_slice.ellipsisMask = value->ellipsis_mask(); 1225+ strided_slice.newAxisMask = value->new_axis_mask(); 1226+ strided_slice.shrinkAxisMask = value->shrink_axis_mask(); 1227+ OHOS::MessageParcel data; 1228+ (void)StridedSliceBlockMarshalling(data, strided_slice); 1229+ std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 1230+ reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 1231+ return ret; 1232+ } else { 1233+ return {}; 1234+ } 1235+ } else { 1236+ return {}; 1237+ } 1238+} 1239+std::vector<int8_t> ConvertSubFusion_V2_0(PrimitivePtr primitive) { 1240+ if (primitive != nullptr) { 1241+ auto prim = static_cast<schema::Primitive *>(primitive); 1242+ auto value = prim->value_as_SubFusion(); 1243+ if (value != nullptr) { 1244+ SubFusion sub_fusion{}; 1245+ sub_fusion.activationType = static_cast<HDI::Nnrt::V2_0::ActivationType>(value->activation_type()); 1246+ OHOS::MessageParcel data; 1247+ (void)SubFusionBlockMarshalling(data, sub_fusion); 1248+ std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 1249+ reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 1250+ return ret; 1251+ } else { 1252+ return {}; 1253+ } 1254+ } else { 1255+ return {}; 1256+ } 1257+} 1258+std::vector<int8_t> ConvertTileFusion_V2_0(PrimitivePtr primitive) { 1259+ if (primitive != nullptr) { 1260+ auto prim = static_cast<schema::Primitive *>(primitive); 1261+ auto value = prim->value_as_TileFusion(); 1262+ if (value != nullptr) { 1263+ TileFusion tile_fusion{}; 1264+ std::vector<int64_t> dims; 1265+ dims.reserve(kNumEight); 1266+ if (value->dims() == nullptr) { 1267+ dims = {0, 0, 0, 0, 0, 0, 0, 0}; 1268+ } else { 1269+ dims = std::vector<int64_t>(value->dims()->begin(), value->dims()->end()); 1270+ } 1271+ tile_fusion.dims = dims; 1272+ OHOS::MessageParcel data; 1273+ (void)TileFusionBlockMarshalling(data, tile_fusion); 1274+ std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 1275+ reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 1276+ return ret; 1277+ } else { 1278+ return {}; 1279+ } 1280+ } else { 1281+ return {}; 1282+ } 1283+} 1284+std::vector<int8_t> ConvertTopKFusion_V2_0(PrimitivePtr primitive) { 1285+ if (primitive != nullptr) { 1286+ auto prim = static_cast<schema::Primitive *>(primitive); 1287+ auto value = prim->value_as_TopKFusion(); 1288+ if (value != nullptr) { 1289+ TopKFusion top_k_fusion{}; 1290+ top_k_fusion.sorted = value->sorted(); 1291+ top_k_fusion.axis = value->axis(); 1292+ OHOS::MessageParcel data; 1293+ (void)TopKFusionBlockMarshalling(data, top_k_fusion); 1294+ std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 1295+ reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 1296+ return ret; 1297+ } else { 1298+ return {}; 1299+ } 1300+ } else { 1301+ return {}; 1302+ } 1303+} 1304+std::vector<int8_t> ConvertTranspose_V2_0(PrimitivePtr primitive) { 1305+ if (primitive != nullptr) { 1306+ auto prim = static_cast<schema::Primitive *>(primitive); 1307+ auto value = prim->value_as_Transpose(); 1308+ if (value != nullptr) { 1309+ Transpose transpose{}; 1310+ OHOS::MessageParcel data; 1311+ (void)TransposeBlockMarshalling(data, transpose); 1312+ std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 1313+ reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 1314+ return ret; 1315+ } else { 1316+ return {}; 1317+ } 1318+ } else { 1319+ return {}; 1320+ } 1321+} 1322+std::vector<int8_t> ConvertUnsqueeze_V2_0(PrimitivePtr primitive) { 1323+ if (primitive != nullptr) { 1324+ auto prim = static_cast<schema::Primitive *>(primitive); 1325+ auto value = prim->value_as_Unsqueeze(); 1326+ if (value != nullptr) { 1327+ Unsqueeze unsqueeze{}; 1328+ std::vector<int64_t> axis; 1329+ axis.reserve(kNumEight); 1330+ if (value->axis() == nullptr) { 1331+ axis = {0, 0, 0, 0}; 1332+ } else { 1333+ axis = std::vector<int64_t>(value->axis()->begin(), value->axis()->end()); 1334+ } 1335+ unsqueeze.axis = axis; 1336+ OHOS::MessageParcel data; 1337+ (void)UnsqueezeBlockMarshalling(data, unsqueeze); 1338+ std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()), 1339+ reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize()); 1340+ return ret; 1341+ } else { 1342+ return {}; 1343+ } 1344+ } else { 1345+ return {}; 1346+ } 1347+} 1348+ 1349+std::vector<int8_t> Convert_V2_0(NodeType type, PrimitivePtr primitive) { 1350+ switch (type) { 1351+ case NODE_TYPE_ACTIVATION: 1352+ return ConvertActivation_V2_0(primitive); 1353+ break; 1354+ case NODE_TYPE_ADD_FUSION: 1355+ return ConvertAddFusion_V2_0(primitive); 1356+ break; 1357+ case NODE_TYPE_ARGMAX_FUSION: 1358+ return ConvertArgMaxFusion_V2_0(primitive); 1359+ break; 1360+ case NODE_TYPE_AVG_POOL_FUSION: 1361+ return ConvertAvgPoolFusion_V2_0(primitive); 1362+ break; 1363+ case NODE_TYPE_BATCH_TO_SPACE_ND: 1364+ return ConvertBatchToSpaceND_V2_0(primitive); 1365+ break; 1366+ case NODE_TYPE_BIAS_ADD: 1367+ return ConvertBiasAdd_V2_0(primitive); 1368+ break; 1369+ case NODE_TYPE_CAST: 1370+ return ConvertCast_V2_0(primitive); 1371+ break; 1372+ case NODE_TYPE_CONCAT: 1373+ return ConvertConcat_V2_0(primitive); 1374+ break; 1375+ case NODE_TYPE_CONV2D_FUSION: 1376+ return ConvertConv2DFusion_V2_0(primitive); 1377+ break; 1378+ case NODE_TYPE_CONV2D_TRANSPOSE_FUSION: 1379+ return ConvertConv2dTransposeFusion_V2_0(primitive); 1380+ break; 1381+ case NODE_TYPE_DIV_FUSION: 1382+ return ConvertDivFusion_V2_0(primitive); 1383+ break; 1384+ case NODE_TYPE_ELTWISE: 1385+ return ConvertEltwise_V2_0(primitive); 1386+ break; 1387+ case NODE_TYPE_EXPAND_DIMS: 1388+ return ConvertExpandDims_V2_0(primitive); 1389+ break; 1390+ case NODE_TYPE_FILL: 1391+ return ConvertFill_V2_0(primitive); 1392+ break; 1393+ case NODE_TYPE_FULL_CONNECTION: 1394+ return ConvertFullConnection_V2_0(primitive); 1395+ break; 1396+ case NODE_TYPE_FUSED_BATCH_NORM: 1397+ return ConvertFusedBatchNorm_V2_0(primitive); 1398+ break; 1399+ case NODE_TYPE_GATHER: 1400+ return ConvertGather_V2_0(primitive); 1401+ break; 1402+ case NODE_TYPE_LAYER_NORM_FUSION: 1403+ return ConvertLayerNormFusion_V2_0(primitive); 1404+ break; 1405+ case NODE_TYPE_LESS_EQUAL: 1406+ return ConvertLessEqual_V2_0(primitive); 1407+ break; 1408+ case NODE_TYPE_MATMUL_FUSION: 1409+ return ConvertMatMulFusion_V2_0(primitive); 1410+ break; 1411+ case NODE_TYPE_MAXIMUM: 1412+ return ConvertMaximum_V2_0(primitive); 1413+ break; 1414+ case NODE_TYPE_MAX_POOL_FUSION: 1415+ return ConvertMaxPoolFusion_V2_0(primitive); 1416+ break; 1417+ case NODE_TYPE_MUL_FUSION: 1418+ return ConvertMulFusion_V2_0(primitive); 1419+ break; 1420+ case NODE_TYPE_ONE_HOT: 1421+ return ConvertOneHot_V2_0(primitive); 1422+ break; 1423+ case NODE_TYPE_PAD_FUSION: 1424+ return ConvertPadFusion_V2_0(primitive); 1425+ break; 1426+ case NODE_TYPE_POW_FUSION: 1427+ return ConvertPowFusion_V2_0(primitive); 1428+ break; 1429+ case NODE_TYPE_PRELU_FUSION: 1430+ return ConvertPReLUFusion_V2_0(primitive); 1431+ break; 1432+ case NODE_TYPE_QUANT_DTYPE_CAST: 1433+ return ConvertQuantDTypeCast_V2_0(primitive); 1434+ break; 1435+ case NODE_TYPE_REDUCE_FUSION: 1436+ return ConvertReduceFusion_V2_0(primitive); 1437+ break; 1438+ case NODE_TYPE_RESHAPE: 1439+ return ConvertReshape_V2_0(primitive); 1440+ break; 1441+ case NODE_TYPE_RESIZE: 1442+ return ConvertResize_V2_0(primitive); 1443+ break; 1444+ case NODE_TYPE_RSQRT: 1445+ return ConvertRsqrt_V2_0(primitive); 1446+ break; 1447+ case NODE_TYPE_SCALE_FUSION: 1448+ return ConvertScaleFusion_V2_0(primitive); 1449+ break; 1450+ case NODE_TYPE_SHAPE: 1451+ return ConvertShape_V2_0(primitive); 1452+ break; 1453+ case NODE_TYPE_SLICE_FUSION: 1454+ return ConvertSliceFusion_V2_0(primitive); 1455+ break; 1456+ case NODE_TYPE_SOFTMAX: 1457+ return ConvertSoftmax_V2_0(primitive); 1458+ break; 1459+ case NODE_TYPE_SPACE_TO_BATCH_ND: 1460+ return ConvertSpaceToBatchND_V2_0(primitive); 1461+ break; 1462+ case NODE_TYPE_SPLIT: 1463+ return ConvertSplit_V2_0(primitive); 1464+ break; 1465+ case NODE_TYPE_SQRT: 1466+ return ConvertSqrt_V2_0(primitive); 1467+ break; 1468+ case NODE_TYPE_SQUARED_DIFFERENCE: 1469+ return ConvertSquaredDifference_V2_0(primitive); 1470+ break; 1471+ case NODE_TYPE_SQUEEZE: 1472+ return ConvertSqueeze_V2_0(primitive); 1473+ break; 1474+ case NODE_TYPE_STACK: 1475+ return ConvertStack_V2_0(primitive); 1476+ break; 1477+ case NODE_TYPE_STRIDED_SLICE: 1478+ return ConvertStridedSlice_V2_0(primitive); 1479+ break; 1480+ case NODE_TYPE_SUB_FUSION: 1481+ return ConvertSubFusion_V2_0(primitive); 1482+ break; 1483+ case NODE_TYPE_TILE_FUSION: 1484+ return ConvertTileFusion_V2_0(primitive); 1485+ break; 1486+ case NODE_TYPE_TOPK_FUSION: 1487+ return ConvertTopKFusion_V2_0(primitive); 1488+ break; 1489+ case NODE_TYPE_TRANSPOSE: 1490+ return ConvertTranspose_V2_0(primitive); 1491+ break; 1492+ case NODE_TYPE_UNSQUEEZE: 1493+ return ConvertUnsqueeze_V2_0(primitive); 1494+ break; 1495+ default: 1496+ return {}; 1497+ } 1498+} 1499+ 1500+OHOS::HDI::Nnrt::V2_0::Model *MindIR_LiteGraph_To_Model(const LiteGraph *lite_graph, const OHOS::HDI::Nnrt::V2_0::SharedBuffer &buffer) { 1501+ if (lite_graph != nullptr) { 1502+ MS_LOG(INFO) << "MindIR_LiteGraph_To_Model begin"; 1503+ if (!lite_graph->name_.empty()) { 1504+ MS_LOG(INFO) << "Start converting lite graph,name =" << lite_graph->name_; 1505+ } else { 1506+ MS_LOG(INFO) << "Start converting lite graph, but lite graph has no name."; 1507+ } 1508+ std::vector<uint32_t> inputIndex; 1509+ std::vector<uint32_t> outputIndex; 1510+ std::vector<OHOS::HDI::Nnrt::V2_0::Node> nodes; 1511+ std::vector<OHOS::HDI::Nnrt::V2_0::Tensor> allTensors; 1512+ std::vector<OHOS::HDI::Nnrt::V2_0::SubGraph> subGraph; 1513+ // nodes 1514+ MS_LOG(INFO) << "Start converting nodes, vector size = " << lite_graph->all_nodes_.size(); 1515+ nodes.reserve(lite_graph->all_nodes_.size()); 1516+ for (auto node : lite_graph->all_nodes_) { 1517+ if (node == nullptr) { 1518+ MS_LOG(ERROR) << "node is nullptr, convert fail."; 1519+ return nullptr; 1520+ } 1521+ OHOS::HDI::Nnrt::V2_0::Node tmp; 1522+ tmp.name = node->name_; 1523+ if (node->primitive_ == nullptr) { 1524+ MS_LOG(ERROR) << "node primitive is nullptr, convert fail."; 1525+ return nullptr; 1526+ } 1527+ auto prim = static_cast<schema::Primitive *>(node->primitive_); 1528+ auto value = prim->value_type(); 1529+ tmp.nodeType = static_cast<HDI::Nnrt::V2_0::NodeType>(value); 1530+ tmp.nodeAttr = Convert_V2_0(static_cast<NodeType>(value), node->primitive_); 1531+ tmp.inputIndex = node->input_indices_; 1532+ tmp.outputIndex = node->output_indices_; 1533+ tmp.quantType = static_cast<HDI::Nnrt::V2_0::QuantType>(node->quant_type_); 1534+ nodes.emplace_back(tmp); 1535+ } 1536+ 1537+ MS_LOG(INFO) << "Start converting Tensor,Tensor size=" << lite_graph->all_tensors_.size(); 1538+ // Tensor 1539+ allTensors.reserve(lite_graph->all_tensors_.size()); 1540+ unsigned int tensor_buffer_offset = 0; 1541+ uint8_t *mmap_ptr = nullptr; 1542+ if (buffer.fd != -1) { 1543+ mmap_ptr = 1544+ static_cast<uint8_t *>(mmap(nullptr, buffer.bufferSize, PROT_READ | PROT_WRITE, MAP_SHARED, buffer.fd, 0)); 1545+ if (mmap_ptr == MAP_FAILED) { 1546+ MS_LOG(ERROR) << "mmap failed"; 1547+ return nullptr; 1548+ } 1549+ } 1550+ MS_LOG(INFO) << "Start parsing tensor, mmap buffer size = " << buffer.bufferSize; 1551+ for (auto tensor : lite_graph->all_tensors_) { 1552+ OHOS::HDI::Nnrt::V2_0::Tensor tmp; 1553+ tmp.name = MindIR_Tensor_GetName(tensor); 1554+ tmp.dataType = static_cast<HDI::Nnrt::V2_0::HDI::Nnrt::V2_0::DataType>(MindIR_Tensor_GetDataType(tensor)); 1555+ tmp.dims = MindIR_Tensor_GetDims(tensor); 1556+ tmp.format = static_cast<HDI::Nnrt::V2_0::HDI::Nnrt::V2_0::Format>(MindIR_Tensor_GetFormat(tensor)); 1557+ tmp.data = MindIR_Tensor_GetData_V2_0(tensor, buffer, mmap_ptr, tensor_buffer_offset); 1558+ tmp.quantParams = MindIR_Tensor_GetQuantParams_OHOS_V2_0(tensor); 1559+ allTensors.emplace_back(tmp); 1560+ tensor_buffer_offset = tmp.data.offset + tmp.data.dataSize; 1561+ } 1562+ MS_LOG(INFO) << ("Parsing tensor finish."); 1563+ if (buffer.fd != -1) { 1564+ auto munmap_res = munmap(mmap_ptr, buffer.bufferSize); 1565+ if (munmap_res != 0) { 1566+ MS_LOG(ERROR) << "unmap failed."; 1567+ return nullptr; 1568+ } 1569+ } 1570+ 1571+ MS_LOG(INFO) << "Start converting SubGraph,SubGraph size=" << lite_graph->sub_graphs_.size(); 1572+ // SubGraph 1573+ subGraph.reserve(lite_graph->sub_graphs_.size()); 1574+ for (auto graph : lite_graph->sub_graphs_) { 1575+ OHOS::HDI::Nnrt::V2_0::SubGraph tmp; 1576+ tmp.name = graph->name_; 1577+ tmp.inputIndices = std::vector<uint32_t>(graph->input_indices_); 1578+ tmp.outputIndices = std::vector<uint32_t>(graph->output_indices_); 1579+ tmp.nodeIndices = std::vector<uint32_t>(graph->node_indices_); 1580+ subGraph.emplace_back(tmp); 1581+ } 1582+ 1583+ MS_LOG(INFO) << "Start copying model"; 1584+ auto *ret_model = new (std::nothrow) Model(); 1585+ if (ret_model == nullptr) { 1586+ MS_LOG(ERROR) << "new Model failed."; 1587+ return nullptr; 1588+ } 1589+ ret_model->name = lite_graph->name_; 1590+ ret_model->inputIndex = lite_graph->input_indices_; 1591+ ret_model->outputIndex = lite_graph->output_indices_; 1592+ ret_model->nodes = nodes; 1593+ ret_model->allTensors = allTensors; 1594+ ret_model->subGraph = subGraph; 1595+ MS_LOG(INFO) << "MindIR_LiteGraph_To_Model success"; 1596+ return ret_model; 1597+ } else { 1598+ MS_LOG(ERROR) << "lite graph is nullptr"; 1599+ return nullptr; 1600+ } 1601+} 1602+ 1603+} // namespace lite 1604+} // namespace mindspore 1605\ No newline at end of file 1606diff --git a/mindspore/lite/mindir/src/mindir_tensor.cc b/mindspore/lite/mindir/src/mindir_tensor.cc 1607index a62ec257..2e453438 100644 1608--- a/mindspore/lite/mindir/src/mindir_tensor.cc 1609+++ b/mindspore/lite/mindir/src/mindir_tensor.cc 1610@@ -18,6 +18,7 @@ 1611 #include "utils.h" 1612 #include "mindir_memory_manager.h" 1613 #include "nnrt/v1_0/nnrt_types.h" 1614+#include "nnrt/v2_0/nnrt_types.h" 1615 1616 using namespace OHOS::HDI::Nnrt::V1_0; 1617 1618@@ -237,12 +238,48 @@ void MindIR_Tensor_SetFormat(TensorPtr *tensor, Format format) { 1619 } 1620 } 1621 1622-SharedBuffer MindIR_Tensor_GetData(ConstTensorPtr tensor, const SharedBuffer &buffer_templete, uint8_t *mmap_ptr, 1623- unsigned int offset) { 1624+OHOS::HDI::Nnrt::V1_0::SharedBuffer MindIR_Tensor_GetData(ConstTensorPtr tensor, 1625+ const OHOS::HDI::Nnrt::V1_0::SharedBuffer &buffer_templete, 1626+ uint8_t *mmap_ptr, unsigned int offset) { 1627 if (tensor != nullptr) { 1628 auto value = static_cast<const schema::Tensor *>(tensor); 1629 if (value != nullptr) { 1630- SharedBuffer result{}; 1631+ OHOS::HDI::Nnrt::V1_0::SharedBuffer result{}; 1632+ 1633+ if (value->data() == nullptr || value->data()->size() == 0) { 1634+ result.fd = -1; 1635+ result.bufferSize = buffer_templete.bufferSize; 1636+ result.offset = offset; 1637+ result.dataSize = 0; 1638+ return result; 1639+ } 1640+ if (mmap_ptr == nullptr) { 1641+ MS_LOG(ERROR) << "Tensor GetData failed, mmap pointer should not be nullptr"; 1642+ return {-1, 0, offset, 0}; 1643+ } 1644+ result.fd = buffer_templete.fd; 1645+ result.bufferSize = buffer_templete.bufferSize; 1646+ // MS_LOG(ERROR) << "offset:" << offset << ",src->size():" << value->data()->size(); 1647+ memcpy(mmap_ptr + offset, value->data()->data(), value->data()->size()); 1648+ result.offset = offset; 1649+ result.dataSize = value->data()->size(); 1650+ return result; 1651+ } else { 1652+ MS_LOG(WARNING) << "Tensor GetData failed, mmap pointer should not be nullptr"; 1653+ return {-1, 0, offset, 0}; 1654+ } 1655+ } else { 1656+ return {-1, 0, offset, 0}; 1657+ } 1658+} 1659+ 1660+OHOS::HDI::Nnrt::V2_0::SharedBuffer MindIR_Tensor_GetData_V2_0(ConstTensorPtr tensor, 1661+ const OHOS::HDI::Nnrt::V2_0::SharedBuffer &buffer_templete, 1662+ uint8_t *mmap_ptr, unsigned int offset) { 1663+ if (tensor != nullptr) { 1664+ auto value = static_cast<const schema::Tensor *>(tensor); 1665+ if (value != nullptr) { 1666+ OHOS::HDI::Nnrt::V2_0::SharedBuffer result{}; 1667 1668 if (value->data() == nullptr || value->data()->size() == 0) { 1669 result.fd = -1; 1670