[CANN]Fix issue with negative dynamic tensor shape

onnxruntime/core/providers/cann/cann_execution_provider.cc

@@ -1385,8 +1385,7 @@ Status CANNExecutionProvider::Compile(const std::vector<FusedNodeAndGraph>& fuse
       HashValue hash;
       cann::GenerateHashValue(input_shape, hash);
       std::string filename = cann_state->node_name + "_" + std::to_string(hash);
-      std::string filename_with_suffix = filename + ".om";
-
+      bool dynamic_shape = false;
       // TODO(FFFrog): Resource Management
       // It is very necessary to provide a new mechanism for memory reclamation to avoid inference failure caused by
       // device memory exhaustion
@@ -1395,8 +1394,8 @@ Status CANNExecutionProvider::Compile(const std::vector<FusedNodeAndGraph>& fuse
         modelID = modelIDs_[filename];
       } else {
         std::lock_guard<std::mutex> lock(g_mutex);
-
-        if (cann::FileExist(filename_with_suffix)) {
+        auto filename_with_suffix = cann::RegexMatchFile(filename);
+        if (!filename_with_suffix.empty()) {
           CANN_RETURN_IF_ERROR(aclmdlLoadFromFile(filename_with_suffix.c_str(), &modelID));
         } else {
           ge::Graph graph{cann_state->node_name.c_str()};
@@ -1424,20 +1423,46 @@ Status CANNExecutionProvider::Compile(const std::vector<FusedNodeAndGraph>& fuse
         for (size_t i = 0; i < aclmdlGetNumOutputs(prepare.modelDesc_); i++) {
           aclmdlIODims dims;
           CANN_CALL_THROW(aclmdlGetOutputDims(prepare.modelDesc_, i, &dims));
-          std::vector<int64_t> vec{dims.dims, dims.dims + dims.dimCount};
-          auto output = ctx.GetOutput(i, vec);
-          CANN_MODEL_PREPARE_OUTPUTBUFFER(prepare,
-                                          const_cast<void*>(output.GetTensorRawData()),
-                                          aclmdlGetOutputSizeByIndex(prepare.modelDesc_, i));
+
+          if (cann::is_dynamic_shape(dims)) {
+            CANN_MODEL_PREPARE_OUTPUTBUFFER(prepare, nullptr, 0);
+            dynamic_shape = true;
+          } else {
+            std::vector<int64_t> vec{dims.dims, dims.dims + dims.dimCount};
+            auto output = ctx.GetOutput(i, vec);
+            CANN_MODEL_PREPARE_OUTPUTBUFFER(prepare,
+                                            const_cast<void*>(output.GetTensorRawData()),
+                                            aclmdlGetOutputSizeByIndex(prepare.modelDesc_, i));
+          }
         }
       }
       ORT_CATCH(const std::exception& e) {
         return ORT_MAKE_STATUS(ONNXRUNTIME, FAIL, e.what());
       }
 
       aclrtStream stream = static_cast<aclrtStream>(ctx.GetGPUComputeStream());
-      CANN_RETURN_IF_ERROR(aclmdlExecuteAsync(modelID, prepare.inputSet_, prepare.outputSet_, stream));
-
+      if (dynamic_shape) {
+        aclrtSynchronizeStream(stream);
+        CANN_RETURN_IF_ERROR(aclmdlExecute(modelID, prepare.inputSet_, prepare.outputSet_));
+        for (size_t i = 0; i < aclmdlGetNumOutputs(prepare.modelDesc_); i++) {
+          std::vector<int64_t> shape;
+          aclTensorDesc* desc = aclmdlGetDatasetTensorDesc(prepare.outputSet_, i);
+          size_t num_dims = aclGetTensorDescNumDims(desc);
+          shape.reserve(num_dims);
+          for (size_t j = 0; j < num_dims; j++) {
+            int64_t dim;
+            CANN_RETURN_IF_ERROR(aclGetTensorDescDimV2(desc, j, &dim));
+            shape.push_back(dim);
+          }
+          aclDataBuffer* dataBuffer = aclmdlGetDatasetBuffer(prepare.outputSet_, i);
+          void* src_data = aclGetDataBufferAddr(dataBuffer);
+          void* dst_data = const_cast<void*>(ctx.GetOutput(i, shape).GetTensorRawData());
+          size_t count = aclGetTensorDescSize(desc);
+          CANN_CALL_THROW(aclrtMemcpyAsync(dst_data, count, src_data, count, ACL_MEMCPY_DEVICE_TO_DEVICE, stream));
+        }
+      } else {
+        CANN_RETURN_IF_ERROR(aclmdlExecuteAsync(modelID, prepare.inputSet_, prepare.outputSet_, stream));
+      }
       return Status::OK();
     };
 

onnxruntime/core/providers/cann/cann_utils.cc

@@ -224,5 +224,23 @@
   hash_value = hash[0] | (uint64_t(hash[1]) << 32);
 }
 
+bool is_dynamic_shape(const aclmdlIODims& dims) {
+  return std::find(dims.dims, dims.dims + dims.dimCount, -1) != dims.dims + dims.dimCount;
+}
+
+namespace fs = std::filesystem;
+std::string RegexMatchFile(const std::string& file_name) {
+  fs::path current_dir = fs::current_path();
+  std::regex pattern(file_name);
+  for (const auto& entry : fs::directory_iterator(current_dir)) {
+    if (entry.is_regular_file()) {
+      std::string name = entry.path().filename().string();
+      if (std::regex_search(name, pattern)) {
+        return name;
+      }
+    }
+  }
+  return "";
+}
 }  // namespace cann
 }  // namespace onnxruntime

onnxruntime/core/providers/cann/cann_utils.h

@@ -9,6 +9,8 @@
 #include <iomanip>
 #include <string>
 #include <memory>
+#include <filesystem>
+#include <regex>
 
 #include "core/framework/murmurhash3.h"
 #include "core/providers/cann/cann_common.h"
@@ -124,7 +126,8 @@
 
 bool FileExist(const std::string& file_name);
 void GenerateHashValue(const std::string string, HashValue& hash_value);
-
+bool is_dynamic_shape(const aclmdlIODims& dims);
+std::string RegexMatchFile(const std::string& file_name);
 std::unique_ptr<Model> CreateModel(const GraphViewer& graph_viewer, const logging::Logger& logger);
 
 }  // namespace cann