!12610 fix npu mem leak

From: @zhaozhenlong
Reviewed-by: @zhanghaibo5,@zhang_xue_tong
Signed-off-by: @zhanghaibo5

mindspore/lite/src/runtime/agent/npu/npu_manager.cc

@@ -63,11 +63,7 @@ void NPUManager::Reset() {
     auto model = model_map.second;
     if (!model->is_freed_) {
       ir_build.ReleaseModelBuff(*model->model_buffer_data_);
-      model->model_buffer_data_ = nullptr;
       model->is_freed_ = true;
-      model->desc_.reset();
-      model->desc_ = nullptr;
-      model->client_.reset();
     }
   }
   models_.clear();
@@ -141,8 +137,9 @@ bool NPUManager::IsKirinChip() {
   return false;
 }
 
-int NPUManager::AddModel(domi::ModelBufferData *model_buffer_data, const std::string &model_name, int frequency) {
-  auto model = new SubGraphModel(index_, model_name, model_buffer_data);
+int NPUManager::AddModel(std::shared_ptr<domi::ModelBufferData> model_buffer_data, const std::string &model_name,
+                         int frequency) {
+  auto model = std::make_shared<SubGraphModel>(index_, model_name, model_buffer_data);
   auto desc = std::make_shared<hiai::AiModelDescription>(model_name, frequency, 0, 0, 0);
   model->desc_ = desc;
   models_.insert({model_name, model});
@@ -168,6 +165,7 @@ int NPUManager::LoadOMModel() {
   std::vector<std::shared_ptr<hiai::AiModelDescription>> models_desc;
   std::shared_ptr<hiai::AiModelMngerClient> client = nullptr;
   std::shared_ptr<hiai::AiModelBuilder> mc_builder = nullptr;
+  std::unordered_map<std::shared_ptr<hiai::AiModelBuilder>, hiai::MemBuffer *> builder_buffer_map;
   int total = 0;
   for (const auto &model_map : models_) {
     if (total % MAX_MODEL_NUM == 0) {
@@ -194,7 +192,8 @@ int NPUManager::LoadOMModel() {
       MS_LOG(ERROR) << "NPU input memory buffer create failed.";
       return RET_ERROR;
     }
-    model->desc_->SetModelBuffer(model->model_buffer_data_->data, model->model_buffer_data_->length);
+    builder_buffer_map.insert({mc_builder, buffer});
+    model->desc_->SetModelBuffer(buffer->GetMemBufferData(), buffer->GetMemBufferSize());
     if (models_desc.size() == MAX_MODEL_NUM) {
       auto ret = LoadModel(client, models_desc);
       if (ret != RET_ERROR) {
@@ -214,6 +213,9 @@ int NPUManager::LoadOMModel() {
     models_desc.clear();
   }
 
+  for (auto it : builder_buffer_map) {
+    it.first->MemBufferDestroy(it.second);
+  }
   return RET_OK;
 }
 

mindspore/lite/src/runtime/agent/npu/npu_manager.h

@@ -33,7 +33,7 @@ static std::set<mindspore::schema::PrimitiveType> npu_trans_nodes = {
   schema::PrimitiveType_Resize,          schema::PrimitiveType_Pooling};
 struct SubGraphModel {
  public:
-  SubGraphModel(int index, std::string model_name, domi::ModelBufferData *model_buffer_data)
+  SubGraphModel(int index, std::string model_name, std::shared_ptr<domi::ModelBufferData> model_buffer_data)
       : index_(index), model_name_(std::move(model_name)), model_buffer_data_(model_buffer_data) {}
 
   bool is_freed_ = false;
@@ -56,7 +56,7 @@ class NPUManager {
   bool IsSupportNPU();
 
   // provide to subgraph to add model.
-  int AddModel(domi::ModelBufferData *model_buffer_data, const std::string &model_name, int frequency);
+  int AddModel(std::shared_ptr<domi::ModelBufferData> model_buffer_data, const std::string &model_name, int frequency);
 
   // scheduler to load om model.
   int LoadOMModel();
@@ -86,7 +86,7 @@ class NPUManager {
   int index_ = 0;
   bool is_check_version_ = false;
   bool is_support_ = false;
-  std::unordered_map<std::string, SubGraphModel *> models_;
+  std::unordered_map<std::string, std::shared_ptr<SubGraphModel>> models_;
   std::vector<std::shared_ptr<hiai::AiModelMngerClient>> clients_;
 };
 

mindspore/lite/src/runtime/agent/npu/subgraph_npu_kernel.cc

@@ -36,12 +36,15 @@ using mindspore::lite::RET_OK;
 SubGraphNpuKernel::~SubGraphNpuKernel() {
   subgraph_input_op_.clear();
   subgraph_output_op_.clear();
+  for (auto op : op_buffer_) {
+    delete op;
+  }
   if (executor_ != nullptr) {
     delete executor_;
   }
 }
 
-domi::ModelBufferData *SubGraphNpuKernel::BuildIRModel() {
+std::shared_ptr<domi::ModelBufferData> SubGraphNpuKernel::BuildIRModel() {
   ge::Graph graph("NPUGraph");
 
   auto ret = BuildNPUInputOp();
@@ -58,20 +61,18 @@ domi::ModelBufferData *SubGraphNpuKernel::BuildIRModel() {
   ge::Model model(GetOMModelName(), mindspore::lite::Version());
   model.SetGraph(graph);
   domi::HiaiIrBuild ir_build;
-  auto om_model_buff = new (std::nothrow) domi::ModelBufferData;
+  auto om_model_buff = std::make_shared<domi::ModelBufferData>();
   if (om_model_buff == nullptr) {
     MS_LOG(ERROR) << "OM model buffer is nullptr.";
     return nullptr;
   }
   if (!ir_build.CreateModelBuff(model, *om_model_buff)) {
     MS_LOG(ERROR) << "Create model buffer failed.";
-    delete om_model_buff;
     return nullptr;
   }
   if (!ir_build.BuildIRModel(model, *om_model_buff)) {
     MS_LOG(ERROR) << "Build IR model failed.";
     ir_build.ReleaseModelBuff(*om_model_buff);
-    delete om_model_buff;
     return nullptr;
   }
   return om_model_buff;
@@ -85,6 +86,7 @@ int SubGraphNpuKernel::Run() {
 int SubGraphNpuKernel::BuildNPUInputOp() {
   int count = 0;
   subgraph_input_op_.clear();
+  op_buffer_.clear();
   for (auto node : this->nodes_) {
     std::vector<ge::Operator *> node_input_op;
     for (auto in_tensor : node->in_tensors()) {
@@ -94,6 +96,7 @@ int SubGraphNpuKernel::BuildNPUInputOp() {
         data = mindspore::lite::ConverterToNPUData(in_tensor, tensor_name);
         subgraph_input_op_.push_back(*data);
         node_input_op.push_back(data);
+        op_buffer_.push_back(data);
         continue;
       }
 
@@ -130,6 +133,7 @@ int SubGraphNpuKernel::BuildNPUInputOp() {
           auto weight_tensor = mindspore::lite::ConverterToNPUTensor(in_tensor);
           weight_const->set_attr_value(weight_tensor);
           node_input_op.push_back(weight_const);
+          op_buffer_.push_back(weight_const);
         }
       }
     }
@@ -140,6 +144,7 @@ int SubGraphNpuKernel::BuildNPUInputOp() {
       return RET_ERROR;
     }
   }
+
   return RET_OK;
 }
 

mindspore/lite/src/runtime/agent/npu/subgraph_npu_kernel.h

@@ -18,6 +18,7 @@
 #define MINDSPORE_LITE_SRC_RUNTIME_AGENT_SUBGRAPH_NPU_KERNEL_H_
 #include <vector>
 #include <string>
+#include <memory>
 #include "include/hiai_ir_build.h"
 #include "src/sub_graph_kernel.h"
 #include "src/runtime/agent/npu/npu_executor.h"
@@ -56,7 +57,7 @@ class SubGraphNpuKernel : public SubGraphKernel {
   }
 
  private:
-  domi::ModelBufferData *BuildIRModel();
+  std::shared_ptr<domi::ModelBufferData> BuildIRModel();
 
   int BuildNPUInputOp();
 
@@ -76,6 +77,8 @@ class SubGraphNpuKernel : public SubGraphKernel {
   std::vector<ge::Operator> subgraph_output_op_;
 
   std::vector<lite::Tensor *> out_tensor_sorted_;
+
+  std::vector<ge::Operator *> op_buffer_;
 };
 }  // namespace mindspore::kernel
 #endif  // MINDSPORE_LITE_SRC_RUNTIME_AGENT_SUBGRAPH_NPU_KERNEL_H_

mindspore/lite/src/runtime/kernel/npu/fullconnection_npu.cc

@@ -42,13 +42,13 @@ int FullconnectionNPUKernel::SetNPUInputs(const std::vector<lite::Tensor *> &inp
   for (int i = 1; i < input_shape.size(); i++) {
     col *= input_shape[i];
   }
-  auto reshape_op = new (std::nothrow) hiai::op::Const(name_ + "_reshape_data");
+  reshape_op_ = new (std::nothrow) hiai::op::Const(name_ + "_reshape_data");
   vector<int> reshape_data = {input_shape[0], col};
   ge::TensorDesc reshape_tensor_desc(ge::Shape({2}), ge::FORMAT_NCHW, ge::DT_FLOAT);
   ge::TensorPtr reshape_tensor = std::make_shared<hiai::Tensor>(reshape_tensor_desc);
   reshape_tensor->SetData(reinterpret_cast<uint8_t *>(reshape_data.data()), 2 * sizeof(float));
-  reshape_op->set_attr_value(reshape_tensor);
-  reshape_->set_input_shape(*reshape_op);
+  reshape_op_->set_attr_value(reshape_tensor);
+  reshape_->set_input_shape(*reshape_op_);
 
   fc_ = new (std::nothrow) hiai::op::MatMul(name_);
   if (fc_ == nullptr) {
@@ -117,6 +117,10 @@ FullconnectionNPUKernel::~FullconnectionNPUKernel() {
     delete biasadd_;
     biasadd_ = nullptr;
   }
+  if (reshape_op_ != nullptr) {
+    delete reshape_op_;
+    reshape_op_ = nullptr;
+  }
 }
 REG_KERNEL(kNPU, kNumberTypeFloat32, PrimitiveType_FullConnection, NPUKernelCreator<FullconnectionNPUKernel>)
 }  // namespace mindspore::kernel

mindspore/lite/src/runtime/kernel/npu/fullconnection_npu.h

@@ -41,6 +41,7 @@ class FullconnectionNPUKernel : public ConvolutionBaseNPUKernel {
   hiai::op::Reshape *reshape_ = nullptr;
   hiai::op::MatMul *fc_ = nullptr;
   hiai::op::BiasAdd *biasadd_ = nullptr;
+  hiai::op::Const *reshape_op_ = nullptr;
   MatMulParameter *fc_param_;
 };
 }  // namespace mindspore::kernel

mindspore/lite/src/runtime/kernel/npu/instance_norm_npu.cc

@@ -39,11 +39,6 @@ int InstanceNormNPUKernel::SetNPUInputs(const std::vector<lite::Tensor *> &input
   }
   op_->set_input_x(*npu_inputs[0]);
 
-  auto gamma = new (std::nothrow) hiai::op::Const(name_ + "_gamma");
-  if (gamma == nullptr) {
-    MS_LOG(ERROR) << "New gamma const failed.";
-    return RET_ERROR;
-  }
   auto gamma_shape = inputs[1]->shape();
   std::shared_ptr<ge::Tensor> gamma_tensor = std::shared_ptr<ge::Tensor>(new (std::nothrow) ge::Tensor());
   if (gamma_tensor == nullptr) {
@@ -54,14 +49,14 @@ int InstanceNormNPUKernel::SetNPUInputs(const std::vector<lite::Tensor *> &input
                                    lite::ConverterToNPUDataType(inputs[1]->data_type()));
   gamma_tensor->SetTensorDesc(gamma_tensor_desc);
   gamma_tensor->SetData(reinterpret_cast<const uint8_t *>(inputs[1]->data_c()), inputs[1]->Size());
-  gamma->set_attr_value(gamma_tensor);
-  op_->set_input_gamma(*gamma);
-
-  auto beta = new (std::nothrow) hiai::op::Const(name_ + "_beta");
-  if (beta == nullptr) {
-    MS_LOG(ERROR) << "New beta const failed.";
+  gamma_ = new (std::nothrow) hiai::op::Const(name_ + "_gamma");
+  if (gamma_ == nullptr) {
+    MS_LOG(ERROR) << "New gamma_ const failed.";
     return RET_ERROR;
   }
+  gamma_->set_attr_value(gamma_tensor);
+  op_->set_input_gamma(*gamma_);
+
   auto beta_shape = inputs[2]->shape();
   std::shared_ptr<ge::Tensor> beta_tensor = std::shared_ptr<ge::Tensor>(new (std::nothrow) ge::Tensor());
   if (beta_tensor == nullptr) {
@@ -72,8 +67,13 @@ int InstanceNormNPUKernel::SetNPUInputs(const std::vector<lite::Tensor *> &input
                                   lite::ConverterToNPUDataType(inputs[2]->data_type()));
   beta_tensor->SetTensorDesc(beta_tensor_desc);
   beta_tensor->SetData(reinterpret_cast<const uint8_t *>(inputs[2]->data_c()), inputs[2]->Size());
-  beta->set_attr_value(beta_tensor);
-  op_->set_input_beta(*beta);
+  beta_ = new (std::nothrow) hiai::op::Const(name_ + "_beta");
+  if (beta_ == nullptr) {
+    MS_LOG(ERROR) << "New beta_ const failed.";
+    return RET_ERROR;
+  }
+  beta_->set_attr_value(beta_tensor);
+  op_->set_input_beta(*beta_);
   op_->set_attr_epsilon(instance_norm_param_->epsilon_);
   return RET_OK;
 }
@@ -85,6 +85,14 @@ InstanceNormNPUKernel::~InstanceNormNPUKernel() {
     delete op_;
     op_ = nullptr;
   }
+  if (gamma_ != nullptr) {
+    delete gamma_;
+    gamma_ = nullptr;
+  }
+  if (beta_ != nullptr) {
+    delete beta_;
+    beta_ = nullptr;
+  }
 }
 
 REG_KERNEL(kNPU, kNumberTypeFloat32, PrimitiveType_InstanceNorm, NPUKernelCreator<InstanceNormNPUKernel>)

mindspore/lite/src/runtime/kernel/npu/instance_norm_npu.h

@@ -39,6 +39,8 @@ class InstanceNormNPUKernel : public NPUKernel {
 
  private:
   hiai::op::InstanceNorm *op_ = nullptr;
+  hiai::op::Const *gamma_ = nullptr;
+  hiai::op::Const *beta_ = nullptr;
   InstanceNormParameter *instance_norm_param_;
 };
 }  // namespace mindspore::kernel

mindspore/lite/src/runtime/kernel/npu/pad_npu.cc

@@ -43,19 +43,19 @@ int PadNPUKernel::SetNPUInputs(const std::vector<lite::Tensor *> &inputs, const
   ge::TensorDesc padding_tensor_desc(ge::Shape({size, 2}), ge::FORMAT_NCHW, ge::DT_INT32);
   ge::TensorPtr padding_tensor = std::make_shared<hiai::Tensor>(padding_tensor_desc);
   padding_tensor->SetData(reinterpret_cast<uint8_t *>(pad_->GetPaddings().data()), 2 * size * sizeof(int));
-  auto paddings = new hiai::op::Const(name_ + "paddings");
-  paddings->set_attr_value(padding_tensor);
+  paddings_ = new hiai::op::Const(name_ + "paddings");
+  paddings_->set_attr_value(padding_tensor);
 
   ge::TensorDesc constant_values_tensor_desc(ge::Shape({1}), ge::FORMAT_NCHW, ge::DT_FLOAT);
   ge::TensorPtr constant_values_tensor = std::make_shared<hiai::Tensor>(constant_values_tensor_desc);
   vector<float> constant_values_data_value = {pad_->GetConstantValue()};
   constant_values_tensor->SetData(reinterpret_cast<uint8_t *>(constant_values_data_value.data()), 1 * sizeof(float));
-  auto constant = new hiai::op::Const(name_ + "constant");
-  constant->set_attr_value(constant_values_tensor);
+  constant_ = new hiai::op::Const(name_ + "constant");
+  constant_->set_attr_value(constant_values_tensor);
 
   op_->set_input_x(*npu_inputs[0]);
-  op_->set_input_constant_values(*constant);
-  op_->set_input_paddings(*paddings);
+  op_->set_input_constant_values(*constant_);
+  op_->set_input_paddings(*paddings_);
 
   return RET_OK;
 }
@@ -67,6 +67,14 @@ PadNPUKernel::~PadNPUKernel() {
     delete op_;
     op_ = nullptr;
   }
+  if (paddings_ != nullptr) {
+    delete paddings_;
+    paddings_ = nullptr;
+  }
+  if (constant_ != nullptr) {
+    delete constant_;
+    constant_ = nullptr;
+  }
 }
 
 REG_KERNEL(kNPU, kNumberTypeFloat32, PrimitiveType_Pad, NPUKernelCreator<PadNPUKernel>)

mindspore/lite/src/runtime/kernel/npu/pad_npu.h

@@ -40,6 +40,8 @@ class PadNPUKernel : public NPUKernel {
 
  private:
   hiai::op::PadV2 *op_ = nullptr;
+  hiai::op::Const *paddings_ = nullptr;
+  hiai::op::Const *constant_ = nullptr;
   const mindspore::lite::Pad *pad_;
 };
 }  // namespace mindspore::kernel

mindspore/lite/src/runtime/kernel/npu/reduce_npu.cc

@@ -41,18 +41,18 @@ int ReduceNPUKernel::SetNPUInputs(const std::vector<lite::Tensor *> &inputs, con
   for (int i = 0; i < reduce_param_->num_axes_; i++) {
     axes.push_back(reduce_param_->axes_[i]);
   }
-  auto axes_op = new (std::nothrow) hiai::op::Const(name_ + "_reduce_axes");
+  axes_op_ = new (std::nothrow) hiai::op::Const(name_ + "_reduce_axes");
   ge::TensorDesc axes_tensor_desc(ge::Shape({reduce_param_->num_axes_}), ge::FORMAT_NCHW, ge::DT_INT32);
   ge::TensorPtr axes_tensor = std::make_shared<hiai::Tensor>(axes_tensor_desc);
   axes_tensor->SetData(reinterpret_cast<uint8_t *>(axes.data()), reduce_param_->num_axes_ * sizeof(int32_t));
-  axes_op->set_attr_value(axes_tensor);
+  axes_op_->set_attr_value(axes_tensor);
 
   auto reduce_mean_ = new (std::nothrow) hiai::op::ReduceMean(name_);
   if (reduce_mean_ == nullptr) {
     MS_LOG(ERROR) << "New reduce operator for op " << name_ << " failed.";
     return RET_ERROR;
   }
-  reduce_mean_->set_input_x(*npu_inputs[0]).set_input_axes(*axes_op).set_attr_keep_dims(reduce_param_->keep_dims_);
+  reduce_mean_->set_input_x(*npu_inputs[0]).set_input_axes(*axes_op_).set_attr_keep_dims(reduce_param_->keep_dims_);
   reduce_ = reduce_mean_;
   return RET_OK;
 }
@@ -64,6 +64,10 @@ ReduceNPUKernel::~ReduceNPUKernel() {
     delete reduce_;
     reduce_ = nullptr;
   }
+  if (axes_op_ != nullptr) {
+    delete axes_op_;
+    axes_op_ = nullptr;
+  }
 }
 
 REG_KERNEL(kNPU, kNumberTypeFloat32, PrimitiveType_Reduce, NPUKernelCreator<ReduceNPUKernel>)

mindspore/lite/src/runtime/kernel/npu/reduce_npu.h

@@ -40,6 +40,7 @@ class ReduceNPUKernel : public NPUKernel {
  private:
   ReduceParameter *reduce_param_;
   hiai::Operator *reduce_ = nullptr;
+  hiai::op::Const *axes_op_ = nullptr;
 };
 }  // namespace mindspore::kernel
 #endif  // MINDSPORE_LITE_SRC_RUNTIME_KERNEL_NPU_REDUCE_NPU_H_

mindspore/lite/src/runtime/kernel/npu/reshape_npu.cc

@@ -41,7 +41,7 @@ int ReshapeNPUKernel::SetNPUInputs(const std::vector<lite::Tensor *> &inputs,
   }
   op_->set_input_x(*npu_inputs[0]);
 
-  auto shape_op = new (std::nothrow) hiai::op::Const(name_ + "_shape");
+  shape_op_ = new (std::nothrow) hiai::op::Const(name_ + "_shape");
   std::vector<int> shape;
   for (int i = 0; i < reshape_param_->shape_dim_; i++) {
     shape.push_back(reshape_param_->shape_[i]);
@@ -49,8 +49,8 @@ int ReshapeNPUKernel::SetNPUInputs(const std::vector<lite::Tensor *> &inputs,
   ge::TensorDesc shape_tensor_desc(ge::Shape({reshape_param_->shape_dim_}), ge::FORMAT_NCHW, ge::DT_INT32);
   ge::TensorPtr ai_shape_tensor = std::make_shared<hiai::Tensor>(shape_tensor_desc);
   ai_shape_tensor->SetData(reinterpret_cast<uint8_t *>(shape.data()), reshape_param_->shape_dim_ * sizeof(int32_t));
-  shape_op->set_attr_value(ai_shape_tensor);
-  op_->set_input_shape(*shape_op);
+  shape_op_->set_attr_value(ai_shape_tensor);
+  op_->set_input_shape(*shape_op_);
   return RET_OK;
 }
 
@@ -61,6 +61,10 @@ ReshapeNPUKernel::~ReshapeNPUKernel() {
     delete op_;
     op_ = nullptr;
   }
+  if (shape_op_ != nullptr) {
+    delete shape_op_;
+    shape_op_ = nullptr;
+  }
 }
 
 REG_KERNEL(kNPU, kNumberTypeFloat32, PrimitiveType_Reshape, NPUKernelCreator<ReshapeNPUKernel>)

mindspore/lite/src/runtime/kernel/npu/reshape_npu.h

@@ -39,6 +39,7 @@ class ReshapeNPUKernel : public NPUKernel {
 
  private:
   hiai::op::Reshape *op_ = nullptr;
+  hiai::op::Const *shape_op_ = nullptr;
   ReshapeParameter *reshape_param_;
 };
 }  // namespace mindspore::kernel

mindspore/lite/src/runtime/kernel/npu/resize_npu.cc

@@ -41,8 +41,8 @@ int ResizeNPUKernel::SetNPUInputs(const std::vector<lite::Tensor *> &inputs, con
   vector<int32_t> dataValue = {static_cast<int32_t>(resize_parameter_->new_height_),
                                static_cast<int32_t>(resize_parameter_->new_width_)};
   sizeTensor->SetData(reinterpret_cast<uint8_t *>(dataValue.data()), 2 * sizeof(int32_t));
-  auto out_size = new (std::nothrow) hiai::op::Const(name_ + "_size");
-  out_size->set_attr_value(sizeTensor);
+  out_size_ = new (std::nothrow) hiai::op::Const(name_ + "_size");
+  out_size_->set_attr_value(sizeTensor);
   if (resize_parameter_->method_ == schema::ResizeMethod_LINEAR) {
     auto op = new (std::nothrow) hiai::op::ResizeBilinearV2(name_);
     if (op == nullptr) {
@@ -52,7 +52,7 @@ int ResizeNPUKernel::SetNPUInputs(const std::vector<lite::Tensor *> &inputs, con
     op->set_attr_align_corners(resize_parameter_->coordinate_transform_mode_ ==
                                schema::CoordinateTransformMode_ALIGN_CORNERS);
     op->set_input_x(*npu_inputs[0]);
-    op->set_input_size(*out_size);
+    op->set_input_size(*out_size_);
     op->set_attr_half_pixel_centers(resize_parameter_->preserve_aspect_ratio_);
     op_ = op;
   } else {
@@ -64,7 +64,7 @@ int ResizeNPUKernel::SetNPUInputs(const std::vector<lite::Tensor *> &inputs, con
     op->set_attr_align_corners(resize_parameter_->coordinate_transform_mode_ ==
                                schema::CoordinateTransformMode_ALIGN_CORNERS);
     op->set_input_x(*npu_inputs[0]);
-    op->set_input_size(*out_size);
+    op->set_input_size(*out_size_);
     op_ = op;
   }
   return RET_OK;
@@ -77,6 +77,10 @@ ResizeNPUKernel::~ResizeNPUKernel() {
     delete op_;
     op_ = nullptr;
   }
+  if (out_size_ != nullptr) {
+    delete out_size_;
+    out_size_ = nullptr;
+  }
 }
 REG_KERNEL(kNPU, kNumberTypeFloat32, PrimitiveType_Resize, NPUKernelCreator<ResizeNPUKernel>)
 }  // namespace mindspore::kernel

mindspore/lite/src/runtime/kernel/npu/resize_npu.h

@@ -41,6 +41,7 @@ class ResizeNPUKernel : public NPUKernel {
 
  private:
   ge::Operator *op_ = nullptr;
+  hiai::op::Const *out_size_ = nullptr;
   ResizeParameter *resize_parameter_;
 };
 }  // namespace mindspore::kernel

mindspore/lite/src/runtime/kernel/npu/split_npu.cc

@@ -39,20 +39,20 @@ int SplitNPUKernel::SetNPUInputs(const std::vector<lite::Tensor *> &inputs, cons
   ge::TensorDesc size_splits_tensor_desc(ge::Shape({size}), ge::FORMAT_NCHW, ge::DT_INT32);
   ge::TensorPtr size_splits_tensor = std::make_shared<hiai::Tensor>(size_splits_tensor_desc);
   size_splits_tensor->SetData(reinterpret_cast<uint8_t *>(split_->size_splits().data()), size * sizeof(int));
-  auto size_splits = new hiai::op::Const(name_ + "_size");
-  size_splits->set_attr_value(size_splits_tensor);
+  size_splits_ = new hiai::op::Const(name_ + "_size");
+  size_splits_->set_attr_value(size_splits_tensor);
 
   ge::TensorDesc split_dim_tensor_desc(ge::Shape({1}), ge::FORMAT_NCHW, ge::DT_INT32);
   ge::TensorPtr split_dim_tensor = std::make_shared<hiai::Tensor>(split_dim_tensor_desc);
   vector<int32_t> split_dim_data_value = {split_->GetSplitDim()};
   split_dim_tensor->SetData(reinterpret_cast<uint8_t *>(split_dim_data_value.data()), 1 * sizeof(int));
-  auto split_dim = new hiai::op::Const(name_ + "_dim");
-  split_dim->set_attr_value(split_dim_tensor);
+  split_dim_ = new hiai::op::Const(name_ + "_dim");
+  split_dim_->set_attr_value(split_dim_tensor);
 
   op_->set_input_x(*npu_inputs[0]);
   op_->set_attr_num_split(split_->GetNumberSplit());
-  op_->set_input_split_dim(*split_dim);
-  op_->set_input_size_splits(*size_splits);
+  op_->set_input_split_dim(*split_dim_);
+  op_->set_input_size_splits(*size_splits_);
   op_->create_dynamic_output_y(split_->GetNumberSplit());
   return RET_OK;
 }
@@ -64,6 +64,14 @@ SplitNPUKernel::~SplitNPUKernel() {
     delete op_;
     op_ = nullptr;
   }
+  if (size_splits_ != nullptr) {
+    delete size_splits_;
+    size_splits_ = nullptr;
+  }
+  if (split_dim_ != nullptr) {
+    delete split_dim_;
+    split_dim_ = nullptr;
+  }
 }
 
 REG_KERNEL(kNPU, kNumberTypeFloat32, PrimitiveType_Split, NPUKernelCreator<SplitNPUKernel>)

mindspore/lite/src/runtime/kernel/npu/split_npu.h

@@ -39,6 +39,8 @@ class SplitNPUKernel : public NPUKernel {
 
  private:
   hiai::op::SplitV *op_ = nullptr;
+  hiai::op::Const *size_splits_ = nullptr;
+  hiai::op::Const *split_dim_ = nullptr;
   const mindspore::lite::Split *split_;
 };
 }  // namespace mindspore::kernel

mindspore/lite/src/runtime/kernel/npu/unsqueeze_npu.cc

@@ -43,11 +43,11 @@ int UnsqueezeNPUKernel::SetNPUInputs(const std::vector<lite::Tensor *> &inputs,
   ge::TensorDesc desc(ge::Shape({size}), ge::FORMAT_NCHW, ge::DT_INT32);
   ge::TensorPtr tensor = std::make_shared<hiai::Tensor>(desc);
   tensor->SetData(reinterpret_cast<uint8_t *>(axis_.data()), size * sizeof(int));
-  auto axis = new hiai::op::Const(name_ + "_axis");
-  axis->set_attr_value(tensor);
+  axis_const_ = new hiai::op::Const(name_ + "_axis");
+  axis_const_->set_attr_value(tensor);
 
   op_->set_input_x(*npu_inputs[0]);
-  op_->set_input_axis(*axis);
+  op_->set_input_axis(*axis_const_);
 
   return RET_OK;
 }
@@ -59,6 +59,10 @@ UnsqueezeNPUKernel::~UnsqueezeNPUKernel() {
     delete op_;
     op_ = nullptr;
   }
+  if (axis_const_ != nullptr) {
+    delete axis_const_;
+    axis_const_ = nullptr;
+  }
 }
 
 REG_KERNEL(kNPU, kNumberTypeFloat32, PrimitiveType_Unsqueeze, NPUKernelCreator<UnsqueezeNPUKernel>)

mindspore/lite/src/runtime/kernel/npu/unsqueeze_npu.h

@@ -40,6 +40,7 @@ class UnsqueezeNPUKernel : public NPUKernel {
 
  private:
   hiai::op::ExpandDims *op_ = nullptr;
+  hiai::op::Const *axis_const_ = nullptr;
   vector<int> axis_;
 };
 }  // namespace mindspore::kernel