[ascend] fix memory leak (#247)

Author: tangzhiyi11

dlinfer/graph/dicp/vendor/AtbGraph/codegen/runtime/model.cpp

@@ -273,6 +273,8 @@ atb::Status Model::Execute(atb::Context* context, std::vector<atb::Tensor>& inTe
         DICP_LOG_IF(st != atb::NO_ERROR, FATAL) << modelId_ << " execute node[" << nodeId << "] failed, error code: " << st;
     }
 
+    nodeHostTensorMap_.clear();
+
     DICP_LOG(INFO) << modelId_ << " execute finshed!";
     return atb::NO_ERROR;
 }

dlinfer/graph/dicp/vendor/AtbGraph/codegen/runtime/ops/aclnn_ops/acl_nn_operation.cpp

@@ -67,6 +67,7 @@ atb::Status AclNnOperation::Setup(const atb::VariantPack& variantPack, uint64_t&
         return atb::ERROR_INVALID_PARAM;
     }
 
+    ClearAclTensors();
     DICP_CHECK_RET(CreateAclTensors(variantPack));
 
     for (size_t i = 0; i < aclInTensors_.size(); ++i) {
@@ -104,6 +105,21 @@ int AclNnOperation::CreateAclTensors(const atb::VariantPack& variantPack) {
     return 0;
 }
 
+void AclNnOperation::ClearAclTensors() {
+    for (size_t i = 0; i < aclInTensors_.size(); ++i) {
+        if (aclInTensors_[i].tensor != nullptr) {
+            aclDestroyTensor(aclInTensors_[i].tensor);
+            aclInTensors_[i].tensor = nullptr;
+        }
+    }
+    for (size_t i = 0; i < aclOutTensors_.size(); ++i) {
+        if (aclOutTensors_[i].tensor != nullptr) {
+            aclDestroyTensor(aclOutTensors_[i].tensor);
+            aclOutTensors_[i].tensor = nullptr;
+        }
+    }
+}
+
 atb::Status AclNnOperation::Execute(const atb::VariantPack& variantPack, uint8_t* workspace, uint64_t workspaceSize, atb::Context* context) {
     DICP_LOG(INFO) << opName_ << " execute start";
     if (!context) {

dlinfer/graph/dicp/vendor/AtbGraph/codegen/runtime/ops/aclnn_ops/acl_nn_operation.h

@@ -33,6 +33,7 @@ class AclNnOperation : public atb::Operation {
     atb::Status UpdateAclTensorDataPtr(const atb::VariantPack& variantPack);
     AclNnTensor CreateTensor(atb::Tensor atbTensor);
     int CreateAclTensors(const atb::VariantPack& variantPack);
+    void ClearAclTensors();
     std::string opName_;
     atb::SVector<AclNnTensor> aclInTensors_;
     atb::SVector<AclNnTensor> aclOutTensors_;

dlinfer/graph/dicp/vendor/AtbGraph/codegen/runtime/ops/aclnn_ops/incre_flash_attention_operation.cpp

@@ -55,11 +55,13 @@ int AclNnIncreFlashAttentionOperation::SetAclNnWorkspaceExecutor(uint64_t& works
 
     aclTensor* tensorsOfValue[kvTensorNum];
     tensorsOfValue[0] = aclInTensors_.at(2).tensor;
-
     auto tensorValueList = aclCreateTensorList(tensorsOfValue, kvTensorNum);
 
+    if (actualSeqLengths_ != nullptr) {
+        aclDestroyIntArray(actualSeqLengths_);
+    }
     std::vector<int64_t> actualSeqlenVector = {sequenceLengthkv};
-    auto actualSeqLengths = aclCreateIntArray(actualSeqlenVector.data(), actualSeqlenVector.size());
+    actualSeqLengths_ = aclCreateIntArray(actualSeqlenVector.data(), actualSeqlenVector.size());
 
     char layerOut[this->inputLayout.length()];
     strcpy(layerOut, this->inputLayout.c_str());
@@ -72,7 +74,7 @@ int AclNnIncreFlashAttentionOperation::SetAclNnWorkspaceExecutor(uint64_t& works
                                                          tensorValueList,
                                                          nullptr,
                                                          nullptr,
-                                                         actualSeqLengths,
+                                                         actualSeqLengths_,
                                                          nullptr,
                                                          nullptr,
                                                          nullptr,

dlinfer/graph/dicp/vendor/AtbGraph/codegen/runtime/ops/aclnn_ops/incre_flash_attention_operation.h

@@ -13,6 +13,7 @@ class AclNnIncreFlashAttentionOperation : public AclNnOperation {
 private:
     std::string inputLayout;
     float scaleValue;
+    aclIntArray* actualSeqLengths_ = nullptr;
     int SetAclNnWorkspaceExecutor(uint64_t& workspaceSize) override;
     int CallAclExecute(uint8_t* workspace, uint64_t workspaceSize, aclOpExecutor* aclExecutor, aclrtStream stream) override;
 };

dlinfer/graph/dicp/vendor/AtbGraph/codegen/runtime/ops/aclnn_ops/permute_operation.cpp

@@ -22,9 +22,15 @@ const int NUM2 = 2;
 const int NUM3 = 3;
 const int NUM4 = 4;
 
-AclNnPermuteOperation::AclNnPermuteOperation(const std::string& name, std::vector<int64_t> dims) : AclNnOperation(name), dims_(std::move(dims)) {}
+AclNnPermuteOperation::AclNnPermuteOperation(const std::string& name, std::vector<int64_t> dims) : AclNnOperation(name), dims_(std::move(dims)) {
+    aclDims_ = aclCreateIntArray(dims_.data(), dims_.size());
+}
 
-AclNnPermuteOperation::~AclNnPermuteOperation() {}
+AclNnPermuteOperation::~AclNnPermuteOperation() {
+    if (aclDims_ != nullptr) {
+        aclDestroyIntArray(aclDims_);
+    }
+}
 
 atb::Status AclNnPermuteOperation::InferShape(const atb::SVector<atb::TensorDesc>& inTensorDescs, atb::SVector<atb::TensorDesc>& outTensorDescs) const {
     DICP_LOG(INFO) << opName_ << " infer shape start";
@@ -45,8 +51,7 @@ uint32_t AclNnPermuteOperation::GetOutputNum() const { return NUM1; }
 
 int AclNnPermuteOperation::SetAclNnWorkspaceExecutor(uint64_t& workspaceSize) {
     DICP_LOG(INFO) << opName_ << " aclnnPermuteGetWorkspaceSize start";
-    aclIntArray* dims = aclCreateIntArray(dims_.data(), dims_.size());
-    int ret = aclnnPermuteGetWorkspaceSize(aclInTensors_.at(0).tensor, dims, aclOutTensors_.at(0).tensor, &workspaceSize, &aclExecutor_);
+    int ret = aclnnPermuteGetWorkspaceSize(aclInTensors_.at(0).tensor, aclDims_, aclOutTensors_.at(0).tensor, &workspaceSize, &aclExecutor_);
     DICP_LOG(INFO) << opName_ << " aclnnPermuteGetWorkspaceSize end, ret:" << ret << ", workspaceSize:" << workspaceSize << ", aclExecutor:" << aclExecutor_;
 
     return ret;

dlinfer/graph/dicp/vendor/AtbGraph/codegen/runtime/ops/aclnn_ops/permute_operation.h

@@ -14,6 +14,7 @@ class AclNnPermuteOperation : public AclNnOperation {
 
 private:
     std::vector<int64_t> dims_;
+    aclIntArray* aclDims_ = nullptr;
     int SetAclNnWorkspaceExecutor(uint64_t& workspaceSize) override;
     int CallAclExecute(uint8_t* workspace, uint64_t workspaceSize, aclOpExecutor* aclExecutor, aclrtStream stream) override;
 };

dlinfer/graph/dicp/vendor/AtbGraph/codegen/runtime/ops/aclnn_ops/split_with_size_operation.cpp

@@ -19,9 +19,15 @@ namespace dicp {
 const int NUM1 = 1;
 
 AclNnSplitWithSizeOperation::AclNnSplitWithSizeOperation(const std::string& name, int64_t splitDim, std::vector<int64_t> splitSizes)
-    : AclNnOperation(name), splitDim_(splitDim), splitSizes_(std::move(splitSizes)) {}
+    : AclNnOperation(name), splitDim_(splitDim), splitSizes_(std::move(splitSizes)) {
+    sizes_ = aclCreateIntArray(splitSizes_.data(), splitSizes_.size());
+}
 
-AclNnSplitWithSizeOperation::~AclNnSplitWithSizeOperation() {}
+AclNnSplitWithSizeOperation::~AclNnSplitWithSizeOperation() {
+    if (sizes_ != nullptr) {
+        aclDestroyIntArray(sizes_);
+    }
+}
 
 atb::Status AclNnSplitWithSizeOperation::InferShape(const atb::SVector<atb::TensorDesc>& inTensorDescs, atb::SVector<atb::TensorDesc>& outTensorDescs) const {
     DICP_LOG(INFO) << opName_ << " infer shape start";
@@ -62,11 +68,9 @@ int AclNnSplitWithSizeOperation::SetAclNnWorkspaceExecutor(uint64_t& workspaceSi
         tmp[i] = aclOutTensors_.at(i).tensor;
     }
     aclTensorList* tensorList = aclCreateTensorList(tmp.data(), tmp.size());
-    aclIntArray* sizes = aclCreateIntArray(splitSizes_.data(), splitSizes_.size());
-    int ret = aclnnSplitWithSizeGetWorkspaceSize(aclInTensors_.at(0).tensor, sizes, splitDim_, tensorList, &workspaceSize, &aclExecutor_);
+    int ret = aclnnSplitWithSizeGetWorkspaceSize(aclInTensors_.at(0).tensor, sizes_, splitDim_, tensorList, &workspaceSize, &aclExecutor_);
     DICP_LOG(INFO) << opName_ << " aclnnSplitWithSizeGetWorkspaceSize end, ret:" << ret << ", workspaceSize:" << workspaceSize
                    << ", aclExecutor:" << aclExecutor_;
-
     return ret;
 }
 

dlinfer/graph/dicp/vendor/AtbGraph/codegen/runtime/ops/aclnn_ops/split_with_size_operation.h

@@ -15,6 +15,7 @@ class AclNnSplitWithSizeOperation : public AclNnOperation {
 private:
     int64_t splitDim_;
     std::vector<int64_t> splitSizes_;
+    aclIntArray* sizes_ = nullptr;
     int SetAclNnWorkspaceExecutor(uint64_t& workspaceSize) override;
     int CallAclExecute(uint8_t* workspace, uint64_t workspaceSize, aclOpExecutor* aclExecutor, aclrtStream stream) override;
 };

dlinfer/graph/dicp/vendor/AtbGraph/codegen/runtime/ops/custom_ops/masked_fill_scalar_operation.cpp

@@ -57,6 +57,7 @@ atb::Status MaskedFillScalarOperation::Setup(const atb::VariantPack& variantPack
         return atb::ERROR_INVALID_PARAM;
     }
 
+    ClearAclTensors();
     DICP_CHECK_RET(CreateAclTensors(variantPack));
 
     DICP_CHECK_RET(aclInTensors_.at(0).CreateTensor(opName_));
@@ -131,6 +132,21 @@ int MaskedFillScalarOperation::CreateAclTensors(const atb::VariantPack& variantP
     return 0;
 }
 
+void MaskedFillScalarOperation::ClearAclTensors() {
+    for (size_t i = 0; i < aclInTensors_.size(); ++i) {
+        if (aclInTensors_[i].tensor != nullptr) {
+            aclDestroyTensor(aclInTensors_[i].tensor);
+            aclInTensors_[i].tensor = nullptr;
+        }
+    }
+    for (size_t i = 0; i < aclOutTensors_.size(); ++i) {
+        if (aclOutTensors_[i].tensor != nullptr) {
+            aclDestroyTensor(aclOutTensors_[i].tensor);
+            aclOutTensors_[i].tensor = nullptr;
+        }
+    }
+}
+
 AclNnTensor MaskedFillScalarOperation::CreateTensor(atb::Tensor atbTensor) {
     AclNnTensor aclNnTensor;
     aclNnTensor.atbTensor = atbTensor;