mindspore 2.6.0rc1__cp39-none-any.whl → 2.7.0__cp39-none-any.whl

mindspore/include/mindspore/ops/kernel/ascend/acl_ir/op_api_cache.h

@@ -58,6 +58,7 @@ inline int32_t SetExecutorRepeatable(const std::string &workspace_api_name, aclO
     repeat_ret = aclSetAclOpExecutorRepeatable(executor);
     if (repeat_ret != 0) {
       MS_LOG(INFO) << workspace_api_name << " don't support cache, repeat_ret is " << repeat_ret;
+      MS_VLOG(VL_ACLNN_OP) << workspace_api_name << " don't support cache, repeat_ret is " << repeat_ret;
     }
   }
   return repeat_ret;
@@ -67,6 +68,10 @@ inline void MemcpyToBuf(const void *data_expression, size_t size_expression) {
   if (size_expression == 0) {
     return;
   }
+  if (MS_UNLIKELY(static_cast<uint64_t>(g_hash_offset) > SIZE_MAX - size_expression)) {
+    MS_LOG(ERROR) << "Hash buf is overflow.";
+    return;
+  }
   if (g_hash_offset + size_expression >= g_hash_buf_size) {
     g_hash_offset = g_hash_buf_max_size;
     return;
@@ -82,11 +87,13 @@ inline void MemcpyToBuf(const void *data_expression, size_t size_expression) {
 BACKEND_EXPORT void GatherInfo(mindspore::kernel::KernelTensor *);
 BACKEND_EXPORT void GatherInfo(const std::pair<mindspore::kernel::KernelTensor *, bool> &);
 BACKEND_EXPORT void GatherInfo(const std::vector<mindspore::kernel::KernelTensor *> &);
+BACKEND_EXPORT void GatherInfo(const device::DeviceAddressPtr &);
+BACKEND_EXPORT void GatherInfo(device::DeviceAddress *);
 
 BACKEND_EXPORT void GatherInfo(const device::DeviceAddressPtr &);
-BACKEND_EXPORT void GatherInfo(const mindspore::tensor::BaseTensorPtr &);
-BACKEND_EXPORT void GatherInfo(const std::optional<tensor::BaseTensorPtr> &);
-BACKEND_EXPORT void GatherInfo(const std::vector<tensor::BaseTensorPtr> &);
+BACKEND_EXPORT void GatherInfo(const mindspore::tensor::TensorPtr &);
+BACKEND_EXPORT void GatherInfo(const std::optional<tensor::TensorPtr> &);
+BACKEND_EXPORT void GatherInfo(const std::vector<tensor::TensorPtr> &);
 BACKEND_EXPORT void GatherInfo(const mindspore::tensor::TensorPtr &);
 BACKEND_EXPORT void GatherInfo(const std::optional<tensor::TensorPtr> &);
 BACKEND_EXPORT void GatherInfo(const std::vector<tensor::TensorPtr> &);
@@ -132,6 +139,9 @@ inline void RefreshAddr(const std::pair<mindspore::kernel::KernelTensor *, bool>
   RefreshAddr(tensor_and_trans.first);
 }
 
+void RefreshAddr(const std::pair<mindspore::kernel::KernelTensor *, bool> &);
+void RefreshAddr(device::DeviceAddress *device_address);
+
 inline void RefreshAddr(const std::vector<mindspore::kernel::KernelTensor *> &tensor_list) {
   for (auto tensor : tensor_list) {
     RefreshAddr(tensor);
@@ -139,7 +149,7 @@ inline void RefreshAddr(const std::vector<mindspore::kernel::KernelTensor *> &te
 }
 
 void RefreshAddr(const device::DeviceAddressPtr &device_address);
-void RefreshAddr(const mindspore::tensor::BaseTensorPtr &tensor);
+void RefreshAddr(const mindspore::tensor::TensorPtr &tensor);
 
 template <typename Args>
 void RefreshAddr(const Args &values) {}
@@ -225,11 +235,11 @@ bool HitCacheSingle(const char *aclnn_api, aclOpExecutor **executor, uint64_t *w
 BACKEND_EXPORT void GatherHash(mindspore::kernel::KernelTensor *);
 BACKEND_EXPORT void GatherHash(const std::pair<mindspore::kernel::KernelTensor *, bool> &);
 BACKEND_EXPORT void GatherHash(const std::vector<mindspore::kernel::KernelTensor *> &);
-
+BACKEND_EXPORT void GatherHash(device::DeviceAddress *);
 BACKEND_EXPORT void GatherHash(const device::DeviceAddressPtr &);
-BACKEND_EXPORT void GatherHash(const mindspore::tensor::BaseTensorPtr &);
-BACKEND_EXPORT void GatherHash(const std::optional<tensor::BaseTensorPtr> &);
-BACKEND_EXPORT void GatherHash(const std::vector<tensor::BaseTensorPtr> &);
+BACKEND_EXPORT void GatherHash(const mindspore::tensor::TensorPtr &);
+BACKEND_EXPORT void GatherHash(const std::optional<tensor::TensorPtr> &);
+BACKEND_EXPORT void GatherHash(const std::vector<tensor::TensorPtr> &);
 BACKEND_EXPORT void GatherHash(const mindspore::tensor::TensorPtr &);
 BACKEND_EXPORT void GatherHash(const std::optional<tensor::TensorPtr> &);
 BACKEND_EXPORT void GatherHash(const std::vector<tensor::TensorPtr> &);

mindspore/include/mindspore/ops/kernel/ascend/acl_ir/op_api_convert.h

@@ -18,6 +18,7 @@
 #define MINDSPORE_CCSRC_TRANSFORM_ACL_IR_OP_API_CONVERT_H_
 
 #include <dlfcn.h>
+#include <numeric>
 #include <vector>
 #include <string>
 #include <unordered_map>
@@ -228,7 +229,7 @@ inline aclTensor *ConvertType(const mindspore::kernel::KernelTensor *tensor) {
 
   aclTensor *acl_tensor = nullptr;
   const auto &storage_info = tensor->tensor_storage_info();
-  if (storage_info == nullptr || (storage_info != nullptr && storage_info->is_contiguous)) {
+  if (storage_info == nullptr) {
     // Create strides.
     auto strides = shape;
     if (!strides.empty()) {
@@ -251,7 +252,7 @@ inline aclTensor *ConvertType(const mindspore::kernel::KernelTensor *tensor) {
   return acl_tensor;
 }
 
-inline aclTensor *ConvertType(const device::DeviceAddressPtr &device_address) {
+inline aclTensor *ConvertType(device::DeviceAddress *device_address) {
   static const auto aclCreateTensor = GET_OP_API_FUNC(aclCreateTensor);
   if (aclCreateTensor == nullptr) {
     return nullptr;
@@ -303,6 +304,10 @@ inline aclTensor *ConvertType(const device::DeviceAddressPtr &device_address) {
   return acl_tensor;
 }
 
+inline aclTensor *ConvertType(const device::DeviceAddressPtr &device_address) {
+  return ConvertType(device_address.get());
+}
+
 inline aclTensor *ConvertType(mindspore::kernel::KernelTensor *tensor) {
   return ConvertType(reinterpret_cast<const mindspore::kernel::KernelTensor *>(tensor));
 }
@@ -333,7 +338,7 @@ inline aclTensor *ConvertType(std::pair<mindspore::kernel::KernelTensor *, bool>
   }
   aclTensor *acl_tensor = nullptr;
   const auto &storage_info = tensor->tensor_storage_info();
-  if (storage_info == nullptr || (storage_info != nullptr && storage_info->is_contiguous)) {
+  if (storage_info == nullptr) {
     // Create strides.
     auto strides = shape;
     if (!strides.empty()) {
@@ -365,50 +370,14 @@ inline aclTensor *ConvertType(std::pair<mindspore::kernel::KernelTensor *, bool>
   return acl_tensor;
 }
 
-inline std::tuple<std::vector<int64_t>, std::vector<int64_t>, int64_t, std::vector<int64_t>> GetViewShapeAndStride(
-  const tensor::BaseTensorPtr &tensor, const device::DeviceAddressPtr &device_address) {
-  MS_EXCEPTION_IF_NULL(tensor);
-  MS_EXCEPTION_IF_NULL(device_address);
-
-  const auto &storage_info = tensor->storage_info();
-  // Get dev shape
-  auto get_dev_shape = [device_address, tensor](const std::string &tensor_format, const auto &tensor_shape) {
-    if (device::ascend::AclHelper::CheckDefaultSupportFormat(tensor_format)) {
-      return tensor_shape;
-    }
-    int64_t groups = 1;
-    auto node_idx = device_address->GetNodeIndex();
-    if (node_idx.first != nullptr) {
-      groups = common::AnfAlgo::GetAttrGroups(node_idx.first, node_idx.second);
-    }
-    return trans::TransShapeToDevice(tensor_shape, tensor_format, tensor->data_type(), groups);
-  };
-
-  const auto &tensor_shape = tensor->shape();
-  const auto &tensor_format = device_address->format();
-  if (storage_info == nullptr) {
-    const auto &dev_shape = get_dev_shape(tensor_format, tensor_shape);
-
-    // Get contiguous strides
-    std::vector<int64_t> strides(tensor_shape.size(), 1);
-    for (int i = static_cast<int>(strides.size()) - 2; i >= 0; i--) {
-      strides[i] = tensor_shape[i + 1] * strides[i + 1];
-    }
-
-    return std::make_tuple(tensor_shape, strides, 0, dev_shape);
-  } else {
-    const auto &dev_shape = get_dev_shape(tensor_format, storage_info->ori_shape);
-    return std::make_tuple(tensor_shape, storage_info->strides, storage_info->storage_offset, dev_shape);
-  }
-}
-
-inline aclTensor *ConvertType(const tensor::BaseTensorPtr &tensor) {
+inline aclTensor *ConvertType(const tensor::TensorPtr &tensor) {
   MS_EXCEPTION_IF_NULL(tensor);
   static const auto aclCreateTensor = GET_OP_API_FUNC(aclCreateTensor);
   if (aclCreateTensor == nullptr) {
     return nullptr;
   }
-  auto shape = tensor->shape();
+
+  const auto &shape = tensor->shape();
   const auto shape_size = shape.size();
   aclFormat format = ACL_FORMAT_ND;
   switch (shape_size) {
@@ -426,28 +395,29 @@ inline aclTensor *ConvertType(const tensor::BaseTensorPtr &tensor) {
   }
   auto acl_data_type = AclConverter::ConvertType(tensor->data_type());
   auto device_address = std::dynamic_pointer_cast<device::DeviceAddress>(tensor->device_address());
-  if (device_address->GetMutablePtr() == nullptr) {
+  if (device_address->size() != 0 && device_address->GetMutablePtr() == nullptr) {
     MS_LOG(EXCEPTION) << "The device memory is null, please allocate the device memory for tensor "
                       << tensor->ToString();
   }
-  auto [view_shape, strides, offset, ori_dev_shape] = GetViewShapeAndStride(tensor, device_address);
-  auto acl_tensor = aclCreateTensor(view_shape.data(), view_shape.size(), acl_data_type, strides.data(), offset, format,
-                                    ori_dev_shape.data(), ori_dev_shape.size(), device_address->GetMutablePtr());
-  return acl_tensor;
-}
 
-inline aclTensor *ConvertType(const std::optional<tensor::BaseTensorPtr> &value) {
-  if (value.has_value()) {
-    return ConvertType(value.value());
+  static const auto GetTensorNum = [](const std::vector<int64_t> &shape) {
+    auto num = std::accumulate(shape.begin(), shape.end(), int64_t(1), std::multiplies<int64_t>());
+    return num;
+  };
+  const auto &strides = tensor->stride();
+  std::vector<int64_t> storage_shape;
+  const auto &storage_info = tensor->storage_info();
+  if (storage_info) {
+    storage_shape = std::vector<int64_t>{GetTensorNum(storage_info->ori_shape)};
+  } else {
+    storage_shape = std::vector<int64_t>{GetTensorNum(shape)};
   }
-  return nullptr;
-}
 
-inline aclIntArray *ConvertType(const std::optional<std::vector<int64_t>> &int_array_opt) {
-  if (int_array_opt.has_value()) {
-    return ConvertType(int_array_opt.value());
-  }
-  return nullptr;
+  auto acl_tensor =
+    aclCreateTensor(shape.data(), shape.size(), acl_data_type, strides.data(), tensor->storage_offset(), format,
+                    storage_shape.data(), storage_shape.size(), device_address->GetMutablePtr());
+
+  return acl_tensor;
 }
 
 inline aclIntArray *ConvertType(const std::vector<int64_t> &int_array) {
@@ -458,6 +428,13 @@ inline aclIntArray *ConvertType(const std::vector<int64_t> &int_array) {
   return converter.CreateIntArray(int_array);
 }
 
+inline aclIntArray *ConvertType(const std::optional<std::vector<int64_t>> &int_array_opt) {
+  if (int_array_opt.has_value()) {
+    return ConvertType(int_array_opt.value());
+  }
+  return nullptr;
+}
+
 inline aclIntArray *ConvertType(const std::pair<std::vector<int64_t>, bool> &int_array_pair) {
   return ConvertType(int_array_pair.first);
 }
@@ -478,22 +455,6 @@ inline aclBoolArray *ConvertType(const std::vector<uint8_t> &bool_array) {
   return converter.CreateBoolArray(bool_array);
 }
 
-inline aclTensorList *ConvertType(const std::vector<tensor::BaseTensorPtr> &tensor_list) {
-  if (tensor_list.empty()) {
-    MS_LOG(DEBUG) << "tensor list is empty!";
-  }
-  static const auto aclCreateTensorList = GET_OP_API_FUNC(aclCreateTensorList);
-  std::vector<aclTensor *> tmp;
-  std::transform(tensor_list.begin(), tensor_list.end(), std::back_inserter(tmp),
-                 [](const tensor::BaseTensorPtr &tensor) { return ConvertType(tensor); });
-  return aclCreateTensorList(tmp.data(), tmp.size());
-}
-
-inline aclTensor *ConvertType(const tensor::TensorPtr &tensor) {
-  MS_EXCEPTION_IF_NULL(tensor);
-  return ConvertType(tensor->cast<tensor::BaseTensorPtr>());
-}
-
 inline aclTensor *ConvertType(const std::optional<tensor::TensorPtr> &value) {
   if (value.has_value()) {
     return ConvertType(value.value());
@@ -583,8 +544,8 @@ inline void *ConvertType(const ValueTuplePtr &value) {
   } else if (elements[0]->isa<Int64Imm>()) {
     auto int_vector = GetValue<std::vector<int64_t>>(value);
     return ConvertType(int_vector);
-  } else if (elements[0]->isa<tensor::BaseTensor>()) {
-    auto tensor_vector = GetValue<std::vector<tensor::BaseTensorPtr>>(value);
+  } else if (elements[0]->isa<tensor::Tensor>()) {
+    auto tensor_vector = GetValue<std::vector<tensor::TensorPtr>>(value);
     return ConvertType(tensor_vector);
   } else {
     MS_LOG(EXCEPTION) << "Unsupported type: " << value->ToString();
@@ -596,8 +557,8 @@ inline void *ConvertType(const ValuePtr &value) {
     MS_LOG(DEBUG) << "Convert value is null";
     // optional input;
     return nullptr;
-  } else if (value->isa<tensor::BaseTensor>()) {
-    const auto &base_tensor = dyn_cast<tensor::BaseTensor>(value);
+  } else if (value->isa<tensor::Tensor>()) {
+    const auto &base_tensor = dyn_cast<tensor::Tensor>(value);
     return ConvertType(base_tensor);
   } else if (value->isa<Scalar>()) {
     const auto &scalar = dyn_cast<Scalar>(value);
@@ -635,54 +596,19 @@ inline std::vector<void *> GetAddr(const std::vector<KernelTensor *> tensor_list
 
 inline std::vector<void *> GetAddr(KernelTensor *tensor) {
   MS_EXCEPTION_IF_NULL(tensor);
-  if (tensor->tensor_storage_info() && tensor->tensor_storage_info()->is_contiguous) {
-    auto offset = tensor->tensor_storage_info()->storage_offset;
-    auto type_size = GetTypeByte(TypeIdToType(tensor->dtype_id()));
-    return {reinterpret_cast<void *>(reinterpret_cast<uint8_t *>(tensor->device_ptr()) + offset * type_size)};
-  }
   return {tensor->device_ptr()};
 }
 
 inline std::vector<void *> GetAddr(const std::pair<KernelTensor *, bool> &tensor_pair) {
   MS_EXCEPTION_IF_NULL(tensor_pair.first);
-  if (tensor_pair.first->tensor_storage_info() && tensor_pair.first->tensor_storage_info()->is_contiguous) {
-    auto offset = tensor_pair.first->tensor_storage_info()->storage_offset;
-    auto type_size = GetTypeByte(TypeIdToType(tensor_pair.first->dtype_id()));
-    return {
-      reinterpret_cast<void *>(reinterpret_cast<uint8_t *>(tensor_pair.first->device_ptr()) + offset * type_size)};
-  }
   return {tensor_pair.first->device_ptr()};
 }
 
-inline std::vector<void *> GetAddr(const std::vector<tensor::BaseTensorPtr> &tensor_list) {
-  std::vector<void *> addr_list;
-  for (const auto &tensor : tensor_list) {
-    MS_EXCEPTION_IF_NULL(tensor);
-    (void)addr_list.emplace_back(tensor->device_address()->GetMutablePtr());
-  }
-  return addr_list;
-}
-
-inline std::vector<void *> GetAddr(const tensor::BaseTensorPtr &tensor) {
-  MS_EXCEPTION_IF_NULL(tensor);
-  return {tensor->device_address()->GetMutablePtr()};
-}
-
 inline std::vector<void *> GetAddr(const device::DeviceAddressPtr &device_address) {
   return {device_address->GetMutablePtr()};
 }
 
-inline std::vector<void *> GetAddr(const std::pair<tensor::BaseTensorPtr, bool> &tensor_pair) {
-  MS_EXCEPTION_IF_NULL(tensor_pair.first);
-  return {tensor_pair.first->device_address()->GetMutablePtr()};
-}
-
-inline std::vector<void *> GetAddr(const std::optional<tensor::BaseTensorPtr> &tensor) {
-  if (tensor.has_value()) {
-    return {tensor.value()->device_address()->GetMutablePtr()};
-  }
-  return {nullptr};
-}
+inline std::vector<void *> GetAddr(device::DeviceAddress *device_address) { return {device_address->GetMutablePtr()}; }
 
 inline std::vector<void *> GetAddr(const std::vector<tensor::TensorPtr> &tensor_list) {
   std::vector<void *> addr_list;

mindspore/include/mindspore/ops/kernel/ascend/acl_ir/op_api_exec.h

@@ -32,6 +32,7 @@
 #include "plugin/res_manager/ascend/symbol_interface/acl_rt_symbol.h"
 #include "plugin/res_manager/ascend/symbol_interface/acl_symbol.h"
 #include "plugin/res_manager/ascend/symbol_interface/symbol_utils.h"
+#include "kernel/ascend/visible.h"
 
 namespace mindspore::device::ascend {
 enum class ProcessCacheType {
@@ -50,6 +51,15 @@ using ProcessCache = std::function<std::vector<ShapeVector>(const device::ascend
                                                             const std::vector<std::vector<void *>> &)>;
 using RunApiFunc = int (*)(void *, uint64_t, device::ascend::aclOpExecutor *, const aclrtStream);
 
+extern std::set<std::string> sync_launch_api;
+
+#define REGISTER_SYNC_OP(op_api)                              \
+  do {                                                        \
+    if (device::ascend::sync_launch_api.count(op_api) == 0) { \
+      device::ascend::sync_launch_api.insert(op_api);         \
+    }                                                         \
+  } while (false)
+
 class OPS_ASCEND_API OpApiDefaultResource {
  public:
   static OpApiDefaultResource &GetInstance();
@@ -218,9 +228,9 @@ class ApiCachePool {
 };
 
 // check and throw only when enable uce.
-#define CHECK_AND_THROW_UCE_ERROR(aclnn_api)                                                                     \
+#define CHECK_AND_THROW_RECOVERABLE_ERROR(aclnn_api)                                                             \
   do {                                                                                                           \
-    if (UCEException::IsEnableUCE() && aclrt_get_last_error != nullptr) {                                        \
+    if ((UCEException::IsEnableUCE() || UCEException::IsEnableHCCE()) && aclrt_get_last_error != nullptr) {      \
       auto error_code = aclrt_get_last_error(thread_level);                                                      \
       auto error_type = GetErrorType(error_code);                                                                \
       UCEException::GetInstance().ProcessApiUceError(                                                            \
@@ -243,9 +253,10 @@ class ApiCachePool {
     std::function<void()> release_func = nullptr;                                                                      \
     uint64_t *workspace_size_addr = &workspace_size;                                                                   \
     device::ascend::aclOpExecutor **executor_addr = &executor;                                                         \
+    auto process_cache = device::ascend::ProcessCache(nullptr);                                                        \
     if (HitCache(api_name, executor_addr, workspace_size_addr, args...)) {                                             \
       MS_LOG(DEBUG) << "gen executor aclnn cache hit.";                                                                \
-      return std::make_tuple(workspace_size, executor, release_func);                                                  \
+      return std::make_tuple(workspace_size, executor, process_cache, release_func);                                   \
     }                                                                                                                  \
     MS_LOG(DEBUG) << "gen executor aclnn cache miss.";                                                                 \
     auto init_mem_func = device::ascend::OpApiDefaultResource::GetInstance().init_mem_func();                          \
@@ -260,12 +271,14 @@ class ApiCachePool {
     }                                                                                                                  \
     auto releas_call = device::ascend::ReleaseCall(std::move(converted_params));                                       \
     release_func = std::function<void()>(releas_call);                                                                 \
+    auto graph_cache = device::ascend::GraphCache(executor, std::move(converted_params));                              \
+    process_cache = device::ascend::ProcessCache(graph_cache);                                                         \
     auto uninit_mem_func = device::ascend::OpApiDefaultResource::GetInstance().uninit_mem_func();                      \
     if (uninit_mem_func) {                                                                                             \
       uninit_mem_func(nullptr, false);                                                                                 \
     }                                                                                                                  \
     device::ascend::UninitCacheThreadLocal();                                                                          \
-    return std::make_tuple(workspace_size, executor, release_func);                                                    \
+    return std::make_tuple(workspace_size, executor, process_cache, release_func);                                     \
   }                                                                                                                    \
   (aclnn_api, aclnn_api + "GetWorkspaceSize", __VA_ARGS__)
 
@@ -273,8 +286,6 @@ class ApiCachePool {
 #define GEN_EXECUTOR(aclnn_api, ...)                                                                                   \
   [](const std::string &api_str, const std::string &workspace_api_name, const auto &... args) -> auto {                \
     static device::ascend::ApiCachePool api_cache_pool;                                                                \
-    static const std::set<std::string> sync_launch_api = {"aclnnNonzeroV2", "aclnnMaskedSelect", "aclnnNonzero",       \
-                                                          "aclnnUniqueDim", "aclnnUnique2"};                           \
     const char *api_name = api_cache_pool.get(api_str);                                                                \
     static const auto get_workspace_size_func_ptr = device::ascend::GetOpApiFunc(workspace_api_name.c_str());          \
     if (get_workspace_size_func_ptr == nullptr) {                                                                      \
@@ -286,12 +297,12 @@ class ApiCachePool {
     uint64_t *workspace_size_addr = &workspace_size;                                                                   \
     device::ascend::aclOpExecutor **executor_addr = &executor;                                                         \
     auto process_cache = device::ascend::ProcessCache(nullptr);                                                        \
-    if (sync_launch_api.find(std::string(api_name)) == sync_launch_api.end() &&                                        \
+    if (device::ascend::sync_launch_api.count(std::string(api_name)) == 0 &&                                           \
         HitCache(api_name, executor_addr, workspace_size_addr, args...)) {                                             \
-      MS_LOG(DEBUG) << "gen executor aclnn cache hit.";                                                                \
+      MS_VLOG(VL_ACLNN_OP) << api_name << " gen executor hit cache.";                                                  \
       return std::make_tuple(workspace_size, executor, process_cache, release_func);                                   \
     }                                                                                                                  \
-    MS_LOG(DEBUG) << "gen executor aclnn cache miss.";                                                                 \
+    MS_VLOG(VL_ACLNN_OP) << api_name << " gen executor miss cache.";                                                   \
     auto init_mem_func = device::ascend::OpApiDefaultResource::GetInstance().init_mem_func();                          \
     if (init_mem_func) {                                                                                               \
       init_mem_func(nullptr, false);                                                                                   \
@@ -356,8 +367,10 @@ class ApiCachePool {
     device::ascend::aclOpExecutor **executor_addr = &executor;                                                         \
     uint64_t new_hash_id = hash_id;                                                                                    \
     if (HitCacheSingle(api_name, executor_addr, workspace_size_addr, &new_hash_id, args...)) {                         \
+      MS_VLOG(VL_ACLNN_OP) << api_name << " gen executor hit cache, hash id: " << new_hash_id;                         \
       return std::make_tuple(workspace_size, executor, release_func, new_hash_id, true);                               \
     }                                                                                                                  \
+    MS_VLOG(VL_ACLNN_OP) << api_name << " gen executor miss cache, hash id: " << new_hash_id;                          \
     auto init_mem_func = device::ascend::OpApiDefaultResource::GetInstance().init_mem_func();                          \
     if (init_mem_func) {                                                                                               \
       init_mem_func(nullptr, false);                                                                                   \
@@ -408,7 +421,7 @@ class ApiCachePool {
       device::ascend::ConvertToOpApiFunc(converted_params, get_workspace_size_func_ptr);                               \
     auto workspace_status = device::ascend::call(get_workspace_size_func, converted_params);                           \
     if (workspace_status != 0) {                                                                                       \
-      CHECK_AND_THROW_UCE_ERROR(workspace_api_name);                                                                   \
+      CHECK_AND_THROW_RECOVERABLE_ERROR(workspace_api_name);                                                           \
       MS_LOG(EXCEPTION) << workspace_api_name << " call failed, please check!";                                        \
     }                                                                                                                  \
     int32_t repeat_ret = device::ascend::SetExecutorRepeatable(workspace_api_name, executor);                          \
@@ -432,7 +445,7 @@ class ApiCachePool {
     auto get_workspace_size_func = device::ascend::ConvertToOpApiFunc(converted_params, get_workspace_size_func_ptr);  \
     auto workspace_status = device::ascend::call(get_workspace_size_func, converted_params);                           \
     if (workspace_status != 0) {                                                                                       \
-      CHECK_AND_THROW_UCE_ERROR(workspace_api_name);                                                                   \
+      CHECK_AND_THROW_RECOVERABLE_ERROR(workspace_api_name);                                                           \
       MS_LOG(EXCEPTION) << workspace_api_name << " call failed, please check!";                                        \
     }                                                                                                                  \
     int32_t repeat_ret = device::ascend::SetExecutorRepeatable(workspace_api_name, executor);                          \
@@ -459,7 +472,7 @@ class ApiCachePool {
     auto run_api_func = reinterpret_cast<device::ascend::RunApiFunc>(op_api_func);                            \
     auto api_ret = run_api_func(workspace_addr, workspace_size, executor, acl_stream);                        \
     if (api_ret != 0) {                                                                                       \
-      CHECK_AND_THROW_UCE_ERROR(aclnn_api);                                                                   \
+      CHECK_AND_THROW_RECOVERABLE_ERROR(aclnn_api);                                                           \
       MS_LOG(EXCEPTION) << "Call " << aclnn_api << " failed, detail:" << CALL_ASCEND_API(aclGetRecentErrMsg); \
     }                                                                                                         \
     if (release_func != nullptr) {                                                                            \
@@ -471,13 +484,13 @@ class ApiCachePool {
 #define RUN_CUSTOM_OP_API_ASYNC(aclnn_api, workspace_addr, workspace_size, executor, acl_stream, release_func) \
   do {                                                                                                         \
     const auto op_api_func = device::ascend::GetOpApiFunc(aclnn_api.c_str());                                  \
-    if (op_api_func == nullptr) {                                                                              \
+    if (MS_UNLIKELY(op_api_func == nullptr)) {                                                                 \
       MS_LOG(EXCEPTION) << aclnn_api << " not in " << device::ascend::GetOpApiLibName() << ", please check!";  \
     }                                                                                                          \
-    auto run_api_func = reinterpret_cast<device::ascend::RunApiFunc>(op_api_func);                             \
+    static auto run_api_func = reinterpret_cast<device::ascend::RunApiFunc>(op_api_func);                      \
     auto api_ret = run_api_func(workspace_addr, workspace_size, executor, acl_stream);                         \
-    if (api_ret != 0) {                                                                                        \
-      CHECK_AND_THROW_UCE_ERROR(aclnn_api);                                                                    \
+    if (MS_UNLIKELY(api_ret != 0)) {                                                                           \
+      CHECK_AND_THROW_RECOVERABLE_ERROR(aclnn_api);                                                            \
       MS_LOG(EXCEPTION) << "Call " << aclnn_api << " failed, detail:" << CALL_ASCEND_API(aclGetRecentErrMsg);  \
     }                                                                                                          \
     if (release_func != nullptr) {                                                                             \
@@ -486,22 +499,18 @@ class ApiCachePool {
   } while (false)
 
 // Sync run op.
-#define RUN_OP_API_SYNC(aclnn_api, workspace_addr, workspace_size, executor, acl_stream)                             \
-  do {                                                                                                               \
-    static const auto op_api_func = device::ascend::GetOpApiFunc(aclnn_api.c_str());                                 \
-    if (op_api_func == nullptr) {                                                                                    \
-      MS_LOG(EXCEPTION) << aclnn_api << " not in " << device::ascend::GetOpApiLibName() << ", please check!";        \
-    }                                                                                                                \
-    auto run_api_func = reinterpret_cast<device::ascend::RunApiFunc>(op_api_func);                                   \
-    auto api_ret = run_api_func(workspace_addr, workspace_size, executor, acl_stream);                               \
-    if (api_ret != 0) {                                                                                              \
-      CHECK_AND_THROW_UCE_ERROR(aclnn_api);                                                                          \
-      MS_LOG(EXCEPTION) << "Call " << aclnn_api << " failed, detail:" << CALL_ASCEND_API(aclGetRecentErrMsg);        \
-    }                                                                                                                \
-    auto ret = CALL_ASCEND_API(aclrtSynchronizeStream, acl_stream);                                                  \
-    if (ret != 0) {                                                                                                  \
-      MS_LOG(EXCEPTION) << "Sync stream " << aclnn_api << " failed, detail:" << CALL_ASCEND_API(aclGetRecentErrMsg); \
-    }                                                                                                                \
+#define RUN_OP_API_SYNC(aclnn_api, workspace_addr, workspace_size, executor, acl_stream)                      \
+  do {                                                                                                        \
+    static const auto op_api_func = device::ascend::GetOpApiFunc(aclnn_api.c_str());                          \
+    if (MS_UNLIKELY(op_api_func == nullptr)) {                                                                \
+      MS_LOG(EXCEPTION) << aclnn_api << " not in " << device::ascend::GetOpApiLibName() << ", please check!"; \
+    }                                                                                                         \
+    static auto run_api_func = reinterpret_cast<device::ascend::RunApiFunc>(op_api_func);                     \
+    auto api_ret = run_api_func(workspace_addr, workspace_size, executor, acl_stream);                        \
+    if (MS_UNLIKELY(api_ret != 0)) {                                                                          \
+      CHECK_AND_THROW_RECOVERABLE_ERROR(aclnn_api);                                                           \
+      MS_LOG(EXCEPTION) << "Call " << aclnn_api << " failed, detail:" << CALL_ASCEND_API(aclGetRecentErrMsg); \
+    }                                                                                                         \
   } while (false)
 }  // namespace  mindspore::device::ascend
 

mindspore/include/mindspore/ops/kernel/ascend/acl_ir/op_api_util.h

@@ -31,6 +31,7 @@
 #include "kernel/ascend/visible.h"
 
 namespace mindspore::device::ascend {
+
 typedef enum : int8_t {
   KEEP_DTYPE = 0,
   ALLOW_FP32_DOWN_PRECISION = 1,
@@ -73,6 +74,11 @@ class OPS_ASCEND_API AclUtil {
   static aclError SetPrecisionMode(const std::string &mode);
 
   static void SetOpPrecisionMode();
+
+  // lock runtime
+  static std::lock_guard<std::mutex> LockRuntime(const void *stream);
 };
+
+OPS_ASCEND_API int64_t GetCacheCapaticy();
 }  // namespace  mindspore::device::ascend
 #endif  // MINDSPORE_CCSRC_TRANSFORM_ACL_IR_OP_API_UTIL_H_

mindspore/include/mindspore/ops/kernel/ascend/aicpu/aicpu_ops/common/kernel_base.h

@@ -22,7 +22,7 @@
 
 #include "common/kernel_util.h"
 #include "aicpu/common/aicpu_task_struct.h"
-#include "securec/include/securec.h"
+#include "include/securec.h"
 #include "common/tensor.h"
 #include "cce/fwk_adpt_struct.h"
 #include "common/kernel_log.h"

mindspore/include/mindspore/ops/kernel/ascend/aicpu/aicpu_ops/common/kernel_log.h

@@ -34,19 +34,19 @@ namespace aicpu {
 
 #define AICPU_LOGD(fmt, ...)                                                                                  \
   dlog_debug(AICPU_MODULE_NAME, "[%s][%s:%d][tid:%lu]:" fmt, KERNEL_MODULE, __FUNCTION__, __LINE__, GetTid(), \
-             ##__VA_ARGS__);
+             ##__VA_ARGS__)
 #define AICPU_LOGI(fmt, ...)                                                                                 \
   dlog_info(AICPU_MODULE_NAME, "[%s][%s:%d][tid:%lu]:" fmt, KERNEL_MODULE, __FUNCTION__, __LINE__, GetTid(), \
-            ##__VA_ARGS__);
+            ##__VA_ARGS__)
 #define AICPU_LOGW(fmt, ...)                                                                                 \
   dlog_warn(AICPU_MODULE_NAME, "[%s][%s:%d][tid:%lu]:" fmt, KERNEL_MODULE, __FUNCTION__, __LINE__, GetTid(), \
-            ##__VA_ARGS__);
+            ##__VA_ARGS__)
 #define AICPU_LOGE(fmt, ...)                                                                                  \
   dlog_error(AICPU_MODULE_NAME, "[%s][%s:%d][tid:%lu]:" fmt, KERNEL_MODULE, __FUNCTION__, __LINE__, GetTid(), \
-             ##__VA_ARGS__);
+             ##__VA_ARGS__)
 #define AICPU_LOGEVENT(fmt, ...)                                                                              \
   dlog_event(AICPU_MODULE_NAME, "[%s][%s:%d][tid:%lu]:" fmt, KERNEL_MODULE, __FUNCTION__, __LINE__, GetTid(), \
-             ##__VA_ARGS__);
+             ##__VA_ARGS__)
 
 #define AICPU_CHK_STATUS_RET(expr...)        \
   do {                                       \
@@ -54,7 +54,7 @@ namespace aicpu {
     if (status != kAicpuKernelStateSucess) { \
       return status;                         \
     }                                        \
-  } while (0);
+  } while (0)
 
 #define AICPU_CHECK_NULLPTR_VOID(value, logText...) \
   if (value == nullptr) {                           \
@@ -76,19 +76,19 @@ namespace aicpu {
 
 #define KERNEL_LOG_DEBUG(fmt, ...)                                                                            \
   dlog_debug(AICPU_MODULE_NAME, "[%s][%s:%d][tid:%lu]:" fmt, KERNEL_MODULE, __FUNCTION__, __LINE__, GetTid(), \
-             ##__VA_ARGS__);
+             ##__VA_ARGS__)
 #define KERNEL_LOG_INFO(fmt, ...)                                                                            \
   dlog_info(AICPU_MODULE_NAME, "[%s][%s:%d][tid:%lu]:" fmt, KERNEL_MODULE, __FUNCTION__, __LINE__, GetTid(), \
-            ##__VA_ARGS__);
+            ##__VA_ARGS__)
 #define KERNEL_LOG_WARN(fmt, ...)                                                                            \
   dlog_warn(AICPU_MODULE_NAME, "[%s][%s:%d][tid:%lu]:" fmt, KERNEL_MODULE, __FUNCTION__, __LINE__, GetTid(), \
-            ##__VA_ARGS__);
+            ##__VA_ARGS__)
 #define KERNEL_LOG_ERROR(fmt, ...)                                                                            \
   dlog_error(AICPU_MODULE_NAME, "[%s][%s:%d][tid:%lu]:" fmt, KERNEL_MODULE, __FUNCTION__, __LINE__, GetTid(), \
-             ##__VA_ARGS__);
+             ##__VA_ARGS__)
 #define KERNEL_LOG_EVENT(fmt, ...)                                                                            \
   dlog_event(AICPU_MODULE_NAME, "[%s][%s:%d][tid:%lu]:" fmt, KERNEL_MODULE, __FUNCTION__, __LINE__, GetTid(), \
-             ##__VA_ARGS__);
+             ##__VA_ARGS__)
 
 #define KERNEL_CHECK_NULLPTR_VOID(value, logText...) \
   if (value == nullptr) {                            \

mindspore/include/mindspore/ops/kernel/ascend/aicpu/aicpu_ops/cpu_kernel/format_transfer/formats_definitions.h

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) Huawei Technologies Co., Ltd. 2020-2021. All rights reserved.
+ * Copyright 2019-2020 Huawei Technologies Co., Ltd
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -12,6 +12,10 @@
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
+ *
+ * https://gitee.com/mindspore/graphengine/blob/v0.1.0-alpha/src/ge/common/formats/utils/formats_definitions.h
+ *
+ * Additional modifications made by Huawei Technologies Co., Ltd in 2021.
  */
 
 #ifndef AICPU_KERNELS_HOST_FORMAT_TRANSFER_FORMAT_TRANSFERS_FORMAT_TRANSFER_DEFINITIONS_H

mindspore/include/mindspore/ops/kernel/ascend/aicpu/aicpu_ops/cpu_kernel/format_transfer/register_format_transfer.h

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) Huawei Technologies Co., Ltd. 2020-2021. All rights reserved.
+ * Copyright 2019-2020 Huawei Technologies Co., Ltd
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -12,6 +12,10 @@
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
+ *
+ * https://gitee.com/mindspore/graphengine/blob/v0.1.0-alpha/src/ge/common/formats/format_transfers/format_transfer.h
+ *
+ * Additional modifications made by Huawei Technologies Co., Ltd in 2022.
  */
 #ifndef AICPU_KERNELS_HOST_FORMAT_TRANSFER_REGISTER_FORMAT_TRANSFER_H
 #define AICPU_KERNELS_HOST_FORMAT_TRANSFER_REGISTER_FORMAT_TRANSFER_H