mindspore 2.6.0rc1__cp311-cp311-manylinux1_x86_64.whl → 2.7.0__cp311-cp311-manylinux1_x86_64.whl

mindspore/include/mindspore/ccsrc/plugin/res_manager/ascend/collective/utils.h

@@ -0,0 +1,83 @@
+/**
+ * Copyright 2025 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * 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.
+ */
+
+#ifndef MINDSPORE_CCSRC_RUNTIME_HARDWARE_ASCEND_UTILS_H_
+#define MINDSPORE_CCSRC_RUNTIME_HARDWARE_ASCEND_UTILS_H_
+
+#include <hccl/hccl_types.h>
+
+#include <algorithm>
+#include <map>
+#include <set>
+#include <sstream>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "mindspore/core/include/utils/ms_utils.h"
+
+#ifndef EXPORT_WRAPPER
+#define EXPORT_WRAPPER __attribute__((visibility("default")))
+#endif
+
+namespace mindspore {
+namespace device {
+namespace ascend {
+
+using GroupsVecBuffleSet = std::set<std::pair<std::vector<uint32_t>, std::string>>;
+
+// hccl buffle size config.
+const char kHcclConf[] = "MS_DEV_HCCL_CONF";
+const char kHcclEnableConfig[] = "enable_hccl_config";
+const char kHcclCustomizedDefault[] = "hccl_customized_default";
+const char kHcclListConfig[] = "hccl_list_config";
+const char kHcclStrideConfig[] = "hccl_stride_config";
+
+// comm
+const char kWhiteSpace[] = " \t";
+
+EXPORT_WRAPPER std::map<std::vector<unsigned int>, uint32_t> GetHcclBuffleConfig();
+EXPORT_WRAPPER std::string GetHcclConfigValue(const std::string &hccl_config);
+EXPORT_WRAPPER bool IsEnableHcclConfig(const std::string &hccl_config);
+EXPORT_WRAPPER bool IsDisableHcclConfig(const std::string &hccl_config);
+EXPORT_WRAPPER uint32_t GetHcclBufferSize(const std::string &group_name, const std::vector<unsigned int> &rank_id_list);
+
+class EXPORT_WRAPPER VectorUtils {
+ public:
+  template <typename T>
+  static std::string PrintVector(const std::vector<T> &vec) {
+    constexpr int MAX_PRINT_NUM = 100;
+    std::stringstream ss;
+    ss << "[";
+    int size = std::min(static_cast<int>(vec.size()), MAX_PRINT_NUM);
+    for (int i = 0; i < size; ++i) {
+      ss << std::to_string(vec[i]);
+      if (i != size - 1) {
+        ss << ", ";
+      }
+    }
+    if (vec.size() > MAX_PRINT_NUM) {
+      ss << ", ... to be continue";
+    }
+    ss << "]";
+    return ss.str();
+  }
+};
+}  // namespace ascend
+}  // namespace device
+}  // namespace mindspore
+
+#endif  // MINDSPORE_CCSRC_RUNTIME_HARDWARE_ASCEND_UTILS_H_

mindspore/include/mindspore/ccsrc/plugin/res_manager/ascend/device_context_conf/op_tuning_conf.h

@@ -44,6 +44,17 @@ class ASCEND_RES_MANAGER_EXPORT OpTuningConf {
   bool IsJitCompileConfigured() const { return !jit_compile_.empty(); }
   bool IsAoeTuneModeConfigured() const { return !aoe_tune_mode_.empty(); }
   bool IsAoeJobTypeConfigured() const { return is_aoe_job_type_configured_; }
+  bool IsEnableAclnnGlobalCache() const { return is_enable_aclnn_global_cache_; }
+  size_t AclnnCacheQueueLength() const { return cache_queue_length_; }
+  bool IsAclnnCacheConfigured() const { return is_aclnn_cache_configured_; }
+  void SetAclnnGlobalCache(bool set_aclnn_global_cache) {
+    is_enable_aclnn_global_cache_ = set_aclnn_global_cache;
+    is_aclnn_cache_configured_ = true;
+  }
+  void SetAclnnCacheQueueLength(size_t cache_queue_length) {
+    cache_queue_length_ = cache_queue_length;
+    is_aclnn_cache_configured_ = true;
+  }
 
  private:
   static std::shared_ptr<OpTuningConf> inst_context_;
@@ -51,6 +62,9 @@ class ASCEND_RES_MANAGER_EXPORT OpTuningConf {
   std::string aoe_tune_mode_{""};
   std::string aoe_job_type_{"2"};
   bool is_aoe_job_type_configured_{false};
+  bool is_enable_aclnn_global_cache_{false};
+  bool is_aclnn_cache_configured_{false};
+  size_t cache_queue_length_{10000};
 };
 
 ASCEND_RES_MANAGER_EXPORT void RegOpTuningConf(py::module *m);

mindspore/include/mindspore/ccsrc/plugin/res_manager/ascend/dvm/dvm.h

@@ -0,0 +1,246 @@
+/**
+ * Copyright 2024-2025 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * 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.
+ */
+
+#ifndef _DVM_H_
+#define _DVM_H_
+
+#include <cstdint>
+#include <vector>
+
+namespace dvm {
+enum DType {
+  kBool = 0,
+  kFloat16,
+  kBFloat16,
+  kFloat32,
+  kInt32,
+  kInt64,
+  kTypeEnd,
+};
+
+enum UnaryOpType {
+  kSqrt = 0,
+  kAbs,
+  kLog,
+  kExp,
+  kReciprocal,
+  kIsFinite,
+  kLogicalNot,
+  kRound,
+  kFloor,
+  kCeil,
+  kTrunc,
+  kUnaryOpEnd,
+};
+
+enum GroupType {
+  kSplit_M = 0,
+  kSplit_N,
+  kSplit_K,
+  kGroupTypeEnd,
+};
+
+enum BinaryOpType {
+  kEqual = 0,
+  kNotEqual,
+  kGreater,
+  kGreaterEqual,
+  kLess,
+  kLessEqual,
+  kAdd,
+  kSub,
+  kMul,
+  kDiv,
+  kPow,
+  kMaximum,
+  kMinimum,
+  kLogicalAnd,
+  kLogicalOr,
+  kBinaryOpEnd,
+};
+
+enum ReduceOpType {
+  kSum = 0,
+  kReduceOpEnd,
+};
+
+enum KernelType {
+  kStaticShape = 0,
+  kDynShape,
+  kStaticParallel,
+  kStaticMix,
+  kDynMix,
+  kStaticStages,
+  kEager,
+  kKernelTypelEnd,
+};
+
+class NDObject;
+class VKernel;
+class MsProfHelper;
+class Communicator;
+
+struct ShapeRef {
+  ShapeRef() {}
+  explicit ShapeRef(const std::vector<int64_t> &other) : data(other.data()), size(other.size()) {}
+  ShapeRef &operator=(const std::vector<int64_t> &other) {
+    data = other.data();
+    size = other.size();
+    return *this;
+  }
+  const int64_t *data;
+  size_t size;
+};
+
+class Float16 {
+ public:
+  explicit Float16(const uint16_t &v) : value_(v) {}
+  explicit Float16(const float &v);
+  explicit Float16(const int32_t &v);
+  explicit operator float() const;
+  explicit operator int32_t() const;
+  uint16_t int_value() const { return value_; }
+
+ private:
+  uint16_t value_;
+};
+
+class BFloat16 {
+ public:
+  explicit BFloat16(const uint16_t &v) : value_(v) {}
+  explicit BFloat16(const float &v);
+  explicit BFloat16(const int32_t &v);
+  explicit operator float() const;
+  explicit operator int32_t() const;
+  uint16_t int_value() const { return value_; }
+
+ private:
+  uint16_t value_;
+};
+
+struct RelocTable {
+  NDObject **inputs;
+  size_t inputs_size;
+  NDObject **outputs;
+  size_t outputs_size;
+};
+
+struct RelocEntry {
+  RelocEntry() {}
+  RelocEntry(NDObject *p, void *a) : io(p), addr(a) {}
+  NDObject *io;
+  void *addr;
+};
+
+typedef void *(*WsAllocFunc)(uint64_t size, void *user_data);
+
+class Comm {
+ public:
+  Comm() = default;
+  ~Comm();
+  bool Init(int rank_id, int rank_size);
+  inline const Communicator *GetImpl() const { return comm_; }
+
+ private:
+  Communicator *comm_{nullptr};
+};
+
+class Kernel {
+ public:
+  Kernel();
+  ~Kernel();
+
+  void Reset(KernelType type);
+  int ParallelNext();
+
+  NDObject *Load(void *addr, ShapeRef *shape, DType type);
+  NDObject *SliceLoad(void *addr, ShapeRef *shape, ShapeRef *start, ShapeRef *size, DType type);
+  NDObject *StridedSliceLoad(void *addr, ShapeRef *shape, ShapeRef *start, ShapeRef *end, ShapeRef *step, DType type);
+  NDObject *MultiLoad(void *addr, ShapeRef *shape, DType type, const Comm *comm);
+  NDObject *Store(void *addr, NDObject *input);
+  NDObject *PadStore(void *addr, NDObject *input, int64_t pad_size);
+
+  NDObject *Unary(int op_type, NDObject *input);
+  NDObject *Binary(int op_type, NDObject *lhs, NDObject *rhs);
+  template <typename T>
+  NDObject *Binary(int op_type, T val, NDObject *rhs);
+  template <typename T>
+  NDObject *Binary(int op_type, NDObject *lhs, T val);
+
+  NDObject *Reduce(int op_type, NDObject *input, ShapeRef *dims, bool keepdims);
+  NDObject *Select(NDObject *cond, NDObject *lhs, NDObject *rhs);
+
+  NDObject *Cast(NDObject *input, DType type);
+  NDObject *Broadcast(NDObject *input, ShapeRef *shape);
+
+  template <typename T>
+  NDObject *Broadcast(T val, ShapeRef *shape, DType type, bool dummy_load);
+  NDObject *Reshape(NDObject *input, ShapeRef *shape);
+  NDObject *Copy(NDObject *input);
+
+  template <typename T>
+  NDObject *OneHot(NDObject *indices, ShapeRef *depth, int axis, T on_value, T off_value);
+
+  NDObject *ElemAny(NDObject *input);
+
+  NDObject *MatMul(NDObject *lhs, NDObject *rhs, bool trans_a, bool trans_b, NDObject *bias);
+  NDObject *GroupedMatMul(NDObject *lhs, NDObject *rhs, bool trans_a, bool trans_b, NDObject *bias,
+                          NDObject *group_list, GroupType group_type);
+
+  // collective communication
+  NDObject *AllReduce(NDObject *input, const Comm *comm);
+  NDObject *AllGather(NDObject *input, const Comm *comm);
+  NDObject *AllGatherV2(NDObject *input, const Comm *comm);
+  NDObject *ReduceScatter(NDObject *input, const Comm *comm);
+
+  void StageSwitch(KernelType type);
+  NDObject *StageLoad(NDObject *stage_store);
+  NDObject *StageStore(NDObject *input);
+  NDObject *StagePadStore(NDObject *input, int64_t pad_size);
+
+  uint64_t CodeGen();
+  // only used for dynamic-shape kernel shape inference
+  void Infer();
+  int Launch(void *workspace, void *stream);
+  int Launch(const RelocTable &reloc_table, void **inputs, void **outputs, void *workspace, void *stream);
+  int MsProfLaunch(const char *op_name, const char *op_fullname, const RelocTable &reloc_table, void **inputs,
+                   void **outputs, void *workspace, void *stream);
+
+  void EagerReset(WsAllocFunc ws_alloc, void *user_data);
+  void EagerCodeGen(const RelocEntry *reloc_table, size_t reloc_size);
+  int EagerLaunch(void *stream);
+  int EagerMsProfLaunch(void *stream);
+  void EagerClear();
+
+  ShapeRef *GetShape(NDObject *op) const;
+  DType GetDType(NDObject *op) const;
+
+  const char *Dump() const;
+  const char *Das() const;
+
+  VKernel *GetImpl() const { return kernel_; }
+
+ private:
+  VKernel *kernel_;
+  MsProfHelper *msprof_helper_;
+};
+
+void SetDeterministic(bool enable);
+
+void SetOnlineTuning(bool enable);
+
+}  // namespace dvm
+#endif  // _DVM_H_

mindspore/include/mindspore/ccsrc/plugin/res_manager/ascend/hal_manager/ascend_hal_manager.h

@@ -53,6 +53,7 @@ class ASCEND_RES_MANAGER_EXPORT AscendHalManager {
   void DestroyAllContext();
 
  private:
+  static AscendHalManager instance_;
   std::set<uint32_t> initialized_device_set_{};
   // default <device_id, aclrtcontext> pair
   std::map<uint32_t, aclrtContext> default_device_context_map_;

mindspore/include/mindspore/ccsrc/plugin/res_manager/ascend/hccl_adapter/hccl_adapter.h

@@ -49,6 +49,18 @@ struct HcclAllToAllVParams {
   std::vector<uint64_t> rdispls;
 };
 
+struct HcclAllGatherVParams {
+  uint64_t send_count;
+  std::vector<uint64_t> recv_counts;
+  std::vector<uint64_t> rdispls;
+};
+
+struct HcclReduceScatterVParams {
+  std::vector<uint64_t> send_counts;
+  std::vector<uint64_t> sdispls;
+  uint64_t recv_count;
+};
+
 struct HcclAllToAllParams {
   uint64_t sendcount;
   uint64_t recvcount;
@@ -63,6 +75,9 @@ class ASCEND_RES_MANAGER_EXPORT HcclAdapter {
   // common
   bool InitHccl(uint32_t device_id, std::string_view rank_id, std::string_view rank_file, HcclMode hccl_mode);
   bool InitHccl(uint32_t device_id, std::string_view rank_id);
+  uint32_t HcclGetCommConfigCapability();
+  HcclResult HcclSetGlobalCommInfo(uint32_t masterIp, uint32_t masterPort, uint32_t totalRankSize, uint32_t nodeId,
+                                   uint32_t localRankSize);
   HcclResult HcclCommInitClusterInfoConfig(const char *rank_table, uint32_t rank_id, HcclCommConfig *config,
                                            HcclComm *hccl_comm_);
   HcclResult HcclCommInitRootInfoConfig(uint32_t n_ranks, const HcclRootInfo *root_info, uint32_t rank,
@@ -100,6 +115,14 @@ class ASCEND_RES_MANAGER_EXPORT HcclAdapter {
                       HcclComm comm) const;
   HcclResult HcclAlltoAllV(void *send_buf, void *recv_buf, hccl::HcclAllToAllVParams params, HcclDataType dataType,
                            const aclrtStream stream, HcclComm comm) const;
+
+  HcclResult HcclReduceScatterV(void *send_buf, void *recv_buf, hccl::HcclReduceScatterVParams params,
+                                HcclDataType data_type, const HcclReduceOp op, const aclrtStream stream,
+                                HcclComm hccl_comm) const;
+
+  HcclResult HcclAllGatherV(void *send_buf, void *recv_buf, hccl::HcclAllGatherVParams params, HcclDataType data_type,
+                            const aclrtStream stream, HcclComm hccl_comm) const;
+
   HcclResult HcclAllToAll(void *send_buf, void *recv_buf, hccl::HcclAllToAllParams params, HcclDataType dataType,
                           const aclrtStream stream, HcclComm comm) const;
   HcclResult HcclBarrier(const aclrtStream stream, HcclComm comm) const;
@@ -112,6 +135,8 @@ class ASCEND_RES_MANAGER_EXPORT HcclAdapter {
 
   HcclResult HcclCommResume(HcclComm comm) const;
 
+  HcclResult HcclCommWorkingDevNicSet(HcclComm comm, uint32_t *ranks, bool *useBackup, uint32_t nRanks);
+
   // Return whether using CM to initialize HCCL.
   bool UseHcclCM() const;
   static void AddCMEnvToHcclOption(std::map<std::string, std::string> *hccl_opt_map);
@@ -135,11 +160,10 @@ class ASCEND_RES_MANAGER_EXPORT HcclAdapter {
   bool InitHcclExec();
   bool FinalizeHcclExec();
 
-  HcclMode GetCurrentHcclMode() const;
-  void CheckExcutionMode() const;
   static std::string GetHcclModeString(HcclMode hccl_mode);
   string DoGetHcomGroup(const string &original_group, const std::vector<uint32_t> &rank_ids) const;
 
+  static bool IsSimulation();
   void *plugin_handle_ = nullptr;
 
   InitHcomGraphAdapterFunObj init_hcom_graph_adapter_ = nullptr;
@@ -148,6 +172,8 @@ class ASCEND_RES_MANAGER_EXPORT HcclAdapter {
   GetAllKernelBuilderFunObj get_all_kernel_builder_ = nullptr;
   HcomDestroyFunObj hcom_destroy_ = nullptr;
 
+  HcclGetCommConfigCapabilityFunObj get_hccl_comm_config_capability_ = nullptr;
+  HcclSetGlobalCommInfoFunObj set_hccl_global_comm_info_ = nullptr;
   HcclCommInitClusterInfoFunObj init_hccl_comm_ = nullptr;
   HcclCommInitClusterInfoConfigFunObj init_hccl_global_comm_ranktable_ = nullptr;
   HcclCommInitRootInfoConfigFunObj init_hccl_root_info_config_ = nullptr;
@@ -165,10 +191,11 @@ class ASCEND_RES_MANAGER_EXPORT HcclAdapter {
   HcclGetRankIdFunObj single_op_hccl_get_rank_id_ = nullptr;
   HcclGetRankSizeFunObj single_op_hccl_get_rank_size_ = nullptr;
   HcclAlltoAllVFunObj launch_hccl_all_to_allv_ = nullptr;
+  HcclReduceScatterVFunObj launch_hccl_reduce_scatterv_ = nullptr;
+  HcclAllGatherVFunObj launch_hccl_all_gatherv_ = nullptr;
   HcclAlltoAllFunObj launch_hccl_all_to_all_ = nullptr;
   HcclBatchSendRecvFunObj launch_hccl_batch_isend_irecv_ = nullptr;
   HcclCommResumeFunObj launch_hccl_comm_resume_ = nullptr;
-
   HcclGetCommAsyncErrorFunObj hccl_get_comm_async_error_ = nullptr;
   HcclGetErrorStringFunObj hccl_get_error_string_ = nullptr;
   HcomCreateGroupFunObj hccl_create_group_ = nullptr;
@@ -179,6 +206,7 @@ class ASCEND_RES_MANAGER_EXPORT HcclAdapter {
   HcomGetLocalRankSizeFunObj hccl_get_local_rank_size_ = nullptr;
   HcomGetWorldRankFromGroupRankFunObj hccl_get_world_rank_by_group_rank_ = nullptr;
   HcomGetGroupRankFromWorldRankFunObj hccl_get_group_rank_by_world_rank_ = nullptr;
+  HcclCommWorkingDevNicSetFunObj hccl_comm_working_dev_nic_set_ = nullptr;
 
   HcomExecInitializeFunObj hccl_exec_initialize_ = nullptr;
   HcomExecFinalizeFunObj hccl_exec_finalize_ = nullptr;

mindspore/include/mindspore/ccsrc/plugin/res_manager/ascend/hccl_adapter/plugin/hccl_plugin.h

@@ -57,6 +57,11 @@ ORIGIN_METHOD(HcclSend, HcclResult, void *, uint64_t, HcclDataType, uint32_t, Hc
 ORIGIN_METHOD(HcclRecv, HcclResult, void *, uint64_t, HcclDataType, uint32_t, HcclComm, aclrtStream);
 ORIGIN_METHOD(HcclAlltoAllV, HcclResult, const void *, const void *, const void *, HcclDataType, const void *,
               const void *, const void *, HcclDataType, HcclComm, aclrtStream);
+ORIGIN_METHOD(HcclAllGatherV, HcclResult, void *, uint64_t, void *, const void *, const void *, HcclDataType, HcclComm,
+              aclrtStream);
+ORIGIN_METHOD(HcclReduceScatterV, HcclResult, void *, const void *, const void *, void *, uint64_t, HcclDataType,
+              HcclReduceOp, HcclComm, aclrtStream);
+
 ORIGIN_METHOD(HcclAlltoAll, HcclResult, const void *, uint64_t, HcclDataType, const void *, uint64_t, HcclDataType,
               HcclComm, aclrtStream);
 ORIGIN_METHOD(HcclBarrier, HcclResult, HcclComm, aclrtStream);
@@ -65,6 +70,8 @@ ORIGIN_METHOD(HcclCommResume, HcclResult, HcclComm)
 
 ORIGIN_METHOD(HcclGetCommAsyncError, HcclResult, HcclComm, HcclResult *);
 ORIGIN_METHOD(HcclGetErrorString, const char *, HcclResult);
+ORIGIN_METHOD(HcclGetCommConfigCapability, uint32_t);
+ORIGIN_METHOD(HcclSetGlobalCommInfo, HcclResult, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t);
 ORIGIN_METHOD(HcclCommInitClusterInfo, HcclResult, const char *, uint32_t, HcclComm *);
 ORIGIN_METHOD(HcclCommInitClusterInfoConfig, HcclResult, const char *, uint32_t, HcclCommConfig *, HcclComm *);
 ORIGIN_METHOD(HcclCommInitRootInfoConfig, HcclResult, uint32_t, const HcclRootInfo *, uint32_t, const HcclCommConfig *,
@@ -79,6 +86,7 @@ ORIGIN_METHOD(HcomGetLocalRankId, HcclResult, const char *, uint32_t *);
 ORIGIN_METHOD(HcomGetLocalRankSize, HcclResult, const char *, uint32_t *);
 ORIGIN_METHOD(HcomGetWorldRankFromGroupRank, HcclResult, const char *, uint32_t, uint32_t *);
 ORIGIN_METHOD(HcomGetGroupRankFromWorldRank, HcclResult, uint32_t, const char *, uint32_t *);
+ORIGIN_METHOD(HcclCommWorkingDevNicSet, HcclResult, HcclComm, uint32_t *, bool *, uint32_t);
 
 ORIGIN_METHOD(HcomCreateGroup, HcclResult, const char *, uint32_t, uint32_t *);
 ORIGIN_METHOD(HcomDestroyGroup, HcclResult, const char *);

mindspore/include/mindspore/ccsrc/plugin/res_manager/ascend/mbuf_manager/mbuf_receive_manager.h

@@ -56,6 +56,11 @@ const std::map<aclDataType, TypeId> kAclDataTypeMap = {{ACL_INT8, TypeId::kNumbe
                                                        {ACL_UINT32, TypeId::kNumberTypeUInt32},
                                                        {ACL_INT64, TypeId::kNumberTypeInt64},
                                                        {ACL_UINT64, TypeId::kNumberTypeUInt64},
+#ifdef EXPERIMENT_A5
+                                                       {ACL_HIFLOAT8, TypeId::kNumberTypeHiFloat8},
+                                                       {ACL_FLOAT8_E5M2, TypeId::kNumberTypeFloat8E5M2},
+                                                       {ACL_FLOAT8_E4M3FN, TypeId::kNumberTypeFloat8E4M3FN},
+#endif
                                                        {ACL_FLOAT16, TypeId::kNumberTypeFloat16},
                                                        {ACL_BF16, TypeId::kNumberTypeBFloat16},
                                                        {ACL_FLOAT, TypeId::kNumberTypeFloat32},
@@ -176,7 +181,7 @@ class ASCEND_RES_MANAGER_EXPORT MbufDataHandler {
   string GetChannelName() { return channel_name_; }
   uint32_t GetDeviceId() { return device_id_; }
   size_t GetCapacity() { return capacity_; }
-  void StopReceive() { stop_receive_.store(true, std::memory_order_acq_rel); }
+  void StopReceive() { stop_receive_.store(true, std::memory_order_release); }
   void CleanChannel();
 
  private:

mindspore/include/mindspore/ccsrc/plugin/res_manager/ascend/mbuf_manager/tdt_manager.h

@@ -0,0 +1,44 @@
+/**
+ * Copyright 2022-2025 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * 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.
+ */
+#ifndef MINDSPORE_CCSRC_PLUGIN_DEVICE_ASCEND_HAL_HARDWARE_ASCEND_DEPRECATED_INTERFACE_H_
+#define MINDSPORE_CCSRC_PLUGIN_DEVICE_ASCEND_HAL_HARDWARE_ASCEND_DEPRECATED_INTERFACE_H_
+
+#include <vector>
+#include <memory>
+#include <string>
+#include <map>
+#include "base/base.h"
+#include "utils/ms_context.h"
+#include "plugin/res_manager/ascend/visible.h"
+
+namespace mindspore {
+namespace device {
+namespace ascend {
+class ASCEND_RES_MANAGER_EXPORT TdtManager {
+ public:
+  ~TdtManager() = default;
+  static TdtManager &GetInstance();
+
+  bool OpenTsd(const std::shared_ptr<MsContext> &ms_context_ptr);
+  bool CloseTsd(const std::shared_ptr<MsContext> &ms_context_ptr, bool force);
+
+ private:
+  TdtManager() = default;
+};
+}  // namespace ascend
+}  // namespace device
+}  // namespace mindspore
+#endif  // MINDSPORE_CCSRC_PLUGIN_DEVICE_ASCEND_HAL_HARDWARE_ASCEND_DEPRECATED_INTERFACE_H_

mindspore/include/mindspore/ccsrc/plugin/res_manager/ascend/mem_manager/abstract_ascend_memory_pool_support.h

@@ -60,6 +60,8 @@ class ASCEND_RES_MANAGER_EXPORT AbstractAscendMemoryPoolSupport : virtual public
   size_t AllocDeviceMemByEagerFree(size_t size, DeviceMemPtr *addr) override;
 
   size_t FreeDeviceMemByEagerFree(const DeviceMemPtr addr, const size_t size) override;
+
+  size_t EmptyCache() override;
 };
 using AbstractAscendMemoryPoolSupportPtr = std::shared_ptr<AbstractAscendMemoryPoolSupport>;
 }  // namespace ascend

mindspore/include/mindspore/ccsrc/plugin/res_manager/ascend/mem_manager/ascend_dynamic_mem_adapter.h

@@ -19,8 +19,8 @@
 
 #include "plugin/res_manager/ascend/mem_manager/ascend_memory_adapter.h"
 #include <string>
+#include <map>
 #include <memory>
-#include <vector>
 
 namespace mindspore {
 namespace device {
@@ -30,6 +30,7 @@ class AscendDynamicMemAdapter : public AscendMemAdapter {
   bool Initialize() override;
   bool DeInitialize() override;
   uint8_t *MallocStaticDevMem(size_t size, const std::string &tag = "") override;
+  bool FreeStaticDevMem(void *addr) override;
   uint8_t *MallocDynamicDevMem(size_t size, const std::string &tag = "") override;
   void ResetDynamicMemory() override;
   std::string DevMemStatistics() const override;
@@ -38,7 +39,7 @@ class AscendDynamicMemAdapter : public AscendMemAdapter {
 
  private:
   size_t has_alloc_size = 0;
-  std::vector<std::shared_ptr<MemoryBlock>> static_memory_block_list_;
+  std::map<void *, std::shared_ptr<MemoryBlock>> static_memory_blocks_;
 };
 }  // namespace ascend
 }  // namespace device

mindspore/include/mindspore/ccsrc/plugin/res_manager/ascend/mem_manager/ascend_memory_adapter.h

@@ -54,6 +54,7 @@ class ASCEND_RES_MANAGER_EXPORT AscendMemAdapter {
   virtual bool DeInitialize();
 
   virtual uint8_t *MallocStaticDevMem(size_t size, const std::string &tag = "") = 0;
+  virtual bool FreeStaticDevMem(void *addr) = 0;
   virtual uint8_t *MallocDynamicDevMem(size_t size, const std::string &tag = "") = 0;
   virtual void ResetDynamicMemory() = 0;
   virtual std::string DevMemStatistics() const = 0;

mindspore/include/mindspore/ccsrc/plugin/res_manager/ascend/mem_manager/ascend_memory_manager.h

@@ -68,6 +68,7 @@ class ASCEND_RES_MANAGER_EXPORT AscendMemoryManager : public MemoryManager {
   GetPersistentMemBlocksInfoStatistics() const override;
   void ResetMaxMemoryReserved() override;
   void ResetMaxMemoryAllocated() override;
+  size_t EmptyCache() override;
 
   DynamicMemPool *GetMemoryPool() override;
 

mindspore/include/mindspore/ccsrc/plugin/res_manager/ascend/mem_manager/ascend_memory_pool.h

@@ -54,6 +54,8 @@ class ASCEND_RES_MANAGER_EXPORT DefaultAscendMemoryPool : public AbstractAscendM
   }
 
   const bool IsEnableEagerFree() const override { return AbstractAscendMemoryPoolSupport::IsEnableEagerFree(); }
+
+  size_t EmptyCache() override;
 };
 using DefaultAscendMemoryPoolPtr = std::shared_ptr<DefaultAscendMemoryPool>;
 
@@ -96,6 +98,8 @@ class ASCEND_RES_MANAGER_EXPORT DefaultEnhancedAscendMemoryPool : public Default
 
   const std::pair<size_t, size_t> FreeIdleMemsByEagerFree() override;
 
+  size_t ReleaseFreeBlocks() override { return instance_->ReleaseFreeBlocks(); }
+
   // Proxy wrapper for AbstractAscendMemoryPoolSupport
   void ResetIdleMemBuf() const override { instance_->ResetIdleMemBuf(); }
 
@@ -207,6 +211,12 @@ class ASCEND_RES_MANAGER_EXPORT DefaultEnhancedAscendMemoryPool : public Default
 
   void ReportMemoryPoolInfo() override { instance_->ReportMemoryPoolInfo(); }
 
+  void ReportMemoryPoolMallocInfoToMstx(void *ptr, size_t size) override {
+    instance_->ReportMemoryPoolMallocInfoToMstx(ptr, size);
+  }
+
+  void ReportMemoryPoolFreeInfoToMstx(void *ptr) override { instance_->ReportMemoryPoolFreeInfoToMstx(ptr); }
+
   bool IsEnableTimeEvent() override { return instance_->IsEnableTimeEvent(); }
 
   void SetEnableTimeEvent(bool enable_time_event) override { instance_->SetEnableTimeEvent(enable_time_event); }
@@ -220,6 +230,8 @@ class ASCEND_RES_MANAGER_EXPORT DefaultEnhancedAscendMemoryPool : public Default
     return instance_->GenFreeMemoryTimeEvent(addr);
   }
 
+  size_t EmptyCache() override { return instance_->EmptyCache(); }
+
  protected:
   void SetRankIdGetter(const std::function<size_t()> &rank_id_getter) override;
 
@@ -249,6 +261,8 @@ class ASCEND_RES_MANAGER_EXPORT BestFitAscendMemoryPool : public AbstractAscendM
   std::string GetMemoryPoolType() const override { return "BestFitAscendMemoryPool"; }
 
   void ReportMemoryTimeEvent(const MemoryTimeEventPtr &time_event) override;
+
+  size_t EmptyCache() override;
 };
 
 class ASCEND_RES_MANAGER_EXPORT AscendMemoryPool {

mindspore/include/mindspore/ccsrc/plugin/res_manager/ascend/mem_manager/ascend_two_pointer_mem_adapter.h

@@ -30,6 +30,7 @@ class AscendTwoPointerMemAdapter : public AscendMemAdapter {
   bool Initialize() override;
   bool DeInitialize() override;
   uint8_t *MallocStaticDevMem(size_t size, const std::string &tag = "") override;
+  bool FreeStaticDevMem(void *addr) override;
   uint8_t *MallocDynamicDevMem(size_t size, const std::string &tag = "") override;
   void ResetDynamicMemory() override;
   void SimulationInitialize() override;