mindspore 2.6.0__cp311-none-any.whl → 2.7.0rc1__cp311-none-any.whl

mindspore/include/mindspore/core/include/ir/tensor_py_wrapperbase.h

@@ -19,7 +19,7 @@
 
 #include <memory>
 
-#include "ir/base_tensor.h"
+#include "ir/tensor.h"
 
 namespace mindspore {
 namespace tensor {
@@ -28,28 +28,28 @@ class MS_CORE_API TensorPyWrapperBase : public Value {
  public:
   TensorPyWrapperBase() = default;
 
-  /// \brief Create TensorPyWrapperBase with BaseTensor.
+  /// \brief Create TensorPyWrapperBase with Tensor.
   ///
-  /// \param[in] input [BaseTensorPtr] The given BaseTensor.
-  explicit TensorPyWrapperBase(const BaseTensorPtr input) : tensor_(input) {}
+  /// \param[in] input [TensorPtr] The given Tensor.
+  explicit TensorPyWrapperBase(const TensorPtr input) : tensor_(input) {}
 
   /// Destructor of TensorPy.
   ~TensorPyWrapperBase() = default;
 
   MS_DECLARE_PARENT(TensorPyWrapperBase, Value);
 
-  /// \brief Get the BaseTensor.
+  /// \brief Get the Tensor.
   ///
-  /// \return The created BaseTensor.
-  const BaseTensorPtr &GetBaseTensorWrapper() const { return tensor_; }
+  /// \return The created Tensor.
+  const TensorPtr &GetTensorWrapper() const { return tensor_; }
 
-  /// \brief Set the BaseTensor.
+  /// \brief Set the Tensor.
   ///
-  /// \param[in] base_tensor [BaseTensorPtr] The given BaseTensor.
-  void SetBaseTensorWrapper(const BaseTensorPtr &base_tensor) { tensor_ = base_tensor; }
+  /// \param[in] base_tensor [TensorPtr] The given Tensor.
+  void SetTensorWrapper(const TensorPtr &base_tensor) { tensor_ = base_tensor; }
 
  private:
-  BaseTensorPtr tensor_;
+  TensorPtr tensor_;
 };
 
 using TensorPyWrapperBasePtr = std::shared_ptr<TensorPyWrapperBase>;

mindspore/include/mindspore/core/include/ir/tensor_storage_info.h

@@ -68,6 +68,7 @@ struct TensorStorageInfo {
     buf << "  ori_shape=" << VectorToString(ori_shape);
     buf << "  ori_strides=" << VectorToString(ori_strides);
     buf << "  is_contiguous=" << std::to_string(is_contiguous);
+    buf << "  ori_size=" << ori_size;
     buf << ")";
     return buf.str();
   }

mindspore/include/mindspore/core/include/load_mindir/infer_mindir.h

@@ -20,8 +20,9 @@
 #include "ir/anf.h"
 
 namespace mindspore {
-MS_CORE_API bool InferMindir(const FuncGraphPtr &root, const AbstractBasePtrList &args, bool raise_exception = false);
+MS_CORE_API bool InferMindir(const FuncGraphPtr &root, const AbstractBasePtrList &args, bool raise_exception = false,
+                             bool is_lite = false);
 MS_CORE_API bool ValidMindir(const FuncGraphPtr &root);
-MS_CORE_API void InferFuncGraphLoaded(const FuncGraphPtr &root);
+MS_CORE_API void InferFuncGraphLoaded(const FuncGraphPtr &root, bool is_lite = false);
 }  // namespace mindspore
 #endif  // MINDSPORE_CORE_LOAD_MINDIR_INFER_MINDIR_H

mindspore/include/mindspore/core/include/mindapi/base/macros.h

@@ -39,14 +39,14 @@
 #if (defined(_WIN32) || defined(__WIN32__) || defined(WIN32) || defined(__CYGWIN__))
 #ifdef OPS_DLL
 #define OPS_API __declspec(dllexport)
-#define OPS_VAR_DEF(type, name, value) OPS_API inline const type name = value;
+#define OPS_VAR_DEF(type, name, value) OPS_API inline const type name = value
 #else
 #define OPS_API __declspec(dllimport)
-#define OPS_VAR_DEF(type, name, value) OPS_API extern const type name;
+#define OPS_VAR_DEF(type, name, value) OPS_API extern const type name
 #endif
 #else
 #define OPS_API __attribute__((visibility("default")))
-#define OPS_VAR_DEF(type, name, value) OPS_API inline const type name = value;
+#define OPS_VAR_DEF(type, name, value) OPS_API inline const type name = value
 #endif
 
 #if (defined(_WIN32) || defined(__WIN32__) || defined(WIN32) || defined(__CYGWIN__))

mindspore/include/mindspore/core/include/mindapi/base/type_id.h

@@ -78,6 +78,9 @@ enum TypeId : int {
   kNumberTypeFloat32,
   kNumberTypeFloat64,
   kNumberTypeBFloat16,
+  kNumberTypeFloat8E4M3FN,
+  kNumberTypeFloat8E5M2,
+  kNumberTypeHiFloat8,
   kNumberTypeDouble,
   kNumberTypeComplex,
   kNumberTypeComplex64,

mindspore/include/mindspore/core/include/mindapi/base/types.h

@@ -143,6 +143,13 @@ enum NormMode : int64_t { BACKWARD = 0, FORWARD = 1, ORTHO = 2 };
 
 enum DriverName : int64_t { GELS = 0, GELSY = 1, GELSD = 2, GELSS = 3 };
 
+enum Device : int64_t {
+  DEVICE_ASCEND = 0,
+  DEVICE_NPU_LOWER = 1,
+  DEVICE_CPU = 2,
+  DEVICE_CPU_LOWER = 3,
+};
+
 // float is a float64 in python. But for some historical reason, python float is converted to float32 in
 using pyfloat = float;
 using pyint = int32_t;

mindspore/include/mindspore/core/include/ops/op_def.h

@@ -21,37 +21,9 @@
 #include <memory>
 #include <unordered_map>
 #include "ir/dtype/type_id.h"
+#include "ir/dtype/op_dtype.h"
 #include "ops/ops_func_impl/op_func_impl.h"
 namespace mindspore::ops {
-
-enum OP_DTYPE : int64_t {
-  DT_BEGIN = 0,
-  DT_BOOL,
-  DT_INT,
-  DT_FLOAT,
-  DT_NUMBER,
-  DT_TENSOR,
-  DT_STR,
-  DT_ANY,
-  DT_TUPLE_BOOL,
-  DT_TUPLE_INT,
-  DT_TUPLE_FLOAT,
-  DT_TUPLE_NUMBER,
-  DT_TUPLE_TENSOR,
-  DT_TUPLE_STR,
-  DT_TUPLE_ANY,
-  DT_LIST_BOOL,
-  DT_LIST_INT,
-  DT_LIST_FLOAT,
-  DT_LIST_NUMBER,
-  DT_LIST_TENSOR,
-  DT_LIST_STR,
-  DT_LIST_ANY,
-  DT_TYPE,
-  DT_NONE,
-  DT_END,
-};
-
 struct OpInputArg {
   std::string arg_name_;
   OP_DTYPE arg_dtype_;
@@ -92,7 +64,6 @@ class OpDefRegHelper {
   ~OpDefRegHelper() = default;
 };
 
-#define REGISTER_PRIMITIVE_OP_DEF(op_name, op_def) \
-  static const OpDefRegHelper op_def_helper_##op_name(#op_name, op_def);
+#define REGISTER_PRIMITIVE_OP_DEF(op_name, op_def) static const OpDefRegHelper op_def_helper_##op_name(#op_name, op_def)
 }  // namespace mindspore::ops
 #endif

mindspore/include/mindspore/core/include/utils/callback_handler.h

@@ -31,5 +31,5 @@
   static void Set##name##Handler(name##Handler handler) { name##_handler_ = std::move(handler); } \
                                                                                                   \
  private:                                                                                         \
-  inline static name##Handler name##_handler_;
+  inline static name##Handler name##_handler_
 #endif  // MINDSPORE_CORE_UTILS_CALLBACK_HANDLER_H_

mindspore/include/mindspore/core/include/utils/compact_set.h

@@ -20,6 +20,7 @@
 #include <vector>
 #include <utility>
 #include <algorithm>
+#include "utils/log_adapter.h"
 
 namespace mindspore {
 // CompactSet uses a std::vector to hold data, it keeps insertion order
@@ -76,6 +77,9 @@ class CompactSet {
   const T &back() const { return data_.back(); }
 
   T pop() {
+    if (data_.empty()) {
+      MS_LOG(INTERNAL_EXCEPTION) << "CompactSet::pop() attempt to pop from empty set";
+    }
     T e = std::move(data_.front());
     (void)data_.erase(data_.begin());
     return e;

mindspore/include/mindspore/core/include/utils/core_op_utils.h

@@ -46,7 +46,7 @@
   default:
 #define MS_ASSERT_TRUE(cond) \
   MS_AMBIGUOUS_ELSE_BLOCKER_ \
-  if ((cond))                \
+  if (cond)                  \
     ;                        \
   else                       \
     MS_LOG(EXCEPTION)

mindspore/include/mindspore/core/include/utils/device_manager_conf.h

@@ -41,6 +41,10 @@ class MS_CORE_API DeviceManagerConf {
     device_id_ = device_id;
     is_default_device_id_ = is_default_device_id;
   }
+  void distributed_refresh_device_id(uint32_t device_id) {
+    MS_LOG(INFO) << "Refresh device id to " << device_id << " for distributed.";
+    device_id_ = device_id;
+  }
   const std::string &GetDeviceTarget() {
     auto it = device_type_to_name_map_.find(device_type_);
     if (it == device_type_to_name_map_.end()) {

mindspore/include/mindspore/core/include/utils/info.h

@@ -75,6 +75,8 @@ class Location {
   bool operator<(const Location &other) const;
 
  private:
+  bool ReadSectionDebugInfoFromFile(SourceLineTip tip, int start_line, std::stringstream &section_debug_info_ss);
+
   std::string file_name_;
   int line_;
   int column_;
@@ -114,6 +116,11 @@ class MS_CORE_API TraceManager {
   /// \return The current trace context.
   static TraceContextPtr CurrentContextInfo();
 
+  /// \brief Get the call stack of all trace contexts.
+  ///
+  /// \return All trace contexts in the call stack, with the top-of-stack element at the end of the std::vector.
+  static const std::vector<TraceContext> &trace_context_stack();
+
   /// \brief Debug trace with the given location.
   ///
   /// \param[in] location The source code location for debug trace.

mindspore/include/mindspore/core/include/utils/log_adapter.h

@@ -29,7 +29,7 @@
 #include "mindapi/base/macros.h"
 #include "utils/os.h"
 #include "utils/overload.h"
-#include "./securec.h"
+#include "include/securec.h"
 #ifdef USE_GLOG
 #define GLOG_NO_ABBREVIATED_SEVERITIES
 #define google mindspore_private
@@ -201,6 +201,7 @@ enum SubModuleId : int {
   SM_LLM_BOOST,          // llm boost
   SM_TRACE,              // JIT trace
   SM_INTERNAL_KERNEL,    // internal kernel
+  SM_EXTENSION,          // MindSpore Extension interfaces
   NUM_SUBMODUES,         // number of submodules
 };
 
@@ -234,6 +235,7 @@ enum VLogLevel : int {
   VL_UCE = VL_GE_ADPT,                                                            // verbose log for uce function
   VL_UCE_DEVICE_MEM,                                        // verbose log for uce of type device memory error
   VL_UCE_HBM_MUTLI_BIT_ECC,                                 // verbose log for uce of type hbm mutit bit ecc error
+  VL_GE_EXECUTOR,                                           // ge graph executor
   VL_IR = COMPONENT_START + (SM_IR - 1) * COMPONENT_RANGE,  // 7. IR
   VL_KERNEL = COMPONENT_START + (SM_KERNEL - 1) * COMPONENT_RANGE,                        // 8. kernel
   VL_MD = COMPONENT_START + (SM_MD - 1) * COMPONENT_RANGE,                                // 9. MindData
@@ -259,7 +261,13 @@ enum VLogLevel : int {
   VL_ARMOUR = COMPONENT_START + (SM_ARMOUR - 1) * COMPONENT_RANGE,                        // 27. ARMOUR
   VL_HCCL_ADPT = COMPONENT_START + (SM_HCCL_ADPT - 1) * COMPONENT_RANGE,                  // 28. Hccl Adapter
   VL_RUNTIME_FRAMEWORK = COMPONENT_START + (SM_RUNTIME_FRAMEWORK - 1) * COMPONENT_RANGE,  // 29. Runtime framework
+  VL_RUNTIME_FRAMEWORK_ACTOR,
+  VL_RUNTIME_FRAMEWORK_KERNEL,
+  VL_RUNTIME_FRAMEWORK_DEVICE_ADDRESS,
+  VL_RUNTIME_FRAMEWORK_ACTOR_MSG,
   VL_RUNTIME_FRAMEWORK_MEMORY,
+  VL_RUNTIME_FRAMEWORK_PRINT_PROF,
+  VL_RUNTIME_FRAMEWORK_OTHER,
   VL_RUNTIME_FRAMEWORK_MEMORY_ALLOCATE_CHECK = VL_RUNTIME_FRAMEWORK + COMPONENT_RANGE - 1,
   VL_GE = COMPONENT_START + (SM_GE - 1) * COMPONENT_RANGE,  // 30. GraphEngine
   VL_ASCEND_KERNEL_SELECT = VL_GE,                          // print ascend kernel select

mindspore/include/mindspore/core/include/utils/ms_context.h

@@ -25,7 +25,6 @@
 #include <mutex>
 #include <vector>
 #include <optional>
-#include "utils/log_adapter.h"
 #include "utils/ms_utils.h"
 #include "utils/device_manager_conf.h"
 
@@ -53,9 +52,10 @@ enum JitSyntaxLevel : int {
 };
 
 enum JitStatus : int {
-  kNotJit,        // Not Jit.
-  kJitCompiling,  // Jit Compiling.
-  kJitRunning,    // Jit Running.
+  kNotJit,          // Not Jit.
+  kJitCompiling,    // Jit Compiling.
+  kGraphCompiling,  // JIt Compiling with graph mode.
+  kJitRunning,      // Jit Running.
 };
 
 enum DebugLevel : int {
@@ -121,11 +121,9 @@ enum MsCtxParam : unsigned {
   MS_CTX_ENABLE_PYNATIVE_SYNCHRONIZE,
   MS_CTX_ENABLE_PYNATIVE_OP_GRAPH_CACHE,
   MS_CTX_ENABLE_MEM_OFFLOAD,
-  MS_CTX_ENABLE_HYBRID_MODE,
   MS_CTX_ENABLE_RECOVERY,
   MS_CTX_ENABLE_GE_HETEROGENOUS,
   MS_CTX_DISABLE_FORMAT_TRANSFORM,
-  MS_CTX_RECOMPUTE_COMM_OVERLAP,
   MS_CTX_GRAD_COMM_OVERLAP,
   MS_CTX_RECOMPUTE_ALLGATHER_OVERLAP_FAGRAD,
   MS_CTX_ENABLE_TASK_OPT,
@@ -146,6 +144,8 @@ enum MsCtxParam : unsigned {
   MS_CTX_ENABLE_FUSED_CAST_ADD_OPT,
   MS_CTX_NEED_CKPT,
   MS_CTX_ENABLE_OFFLOADING_PACKED_EXPERTS,
+  // Used for flatten weight, remove after the feature is abort.
+  MS_ENV_FLATTEN_WEIGHT,
   MS_CTX_TYPE_BOOL_END,
 
   // parameter of type int
@@ -215,6 +215,7 @@ enum MsCtxParam : unsigned {
   MS_CTX_EXEC_ORDER,
   MS_CTX_OP_DEBUG_OPTION,
   MS_CTX_PP_1F1B_OVERLAP,
+  MS_CTX_RECOMPUTE_COMM_OVERLAP,
   MS_CTX_TYPE_STRING_END,
 
   // parameter numbers of each type
@@ -452,14 +453,11 @@ inline void MsContext::decrease_param<uint32_t>(MsCtxParam param) {
 
 MS_CORE_API bool UseSimulationApi();
 
-// The UseNewBackend will delete when new backend switch.
-MS_CORE_API bool UseNewBackend();
-
 #define MSCONTEXT_REGISTER_INIT_FUNC(name, func)                          \
   class name##InitFuncRegister {                                          \
    public:                                                                \
     name##InitFuncRegister() { MsContext::RegisterInitFunc(name, func); } \
-  } g_##name##_init_func_register;
+  } g_##name##_init_func_register
 }  // namespace mindspore
 
 #endif  // MINDSPORE_CORE_UTILS_MS_CONTEXT_H_

mindspore/include/mindspore/core/include/utils/ms_exception.h

@@ -135,19 +135,28 @@ struct FuncInfo {
   std::string api_msg;
 };
 
-enum class UCEError : int { kNoneError = 0, kDeviceMemError, kHbmMultBitEccError, kForceStopError, kUnknownError };
+enum class UCEError : int {
+  kNoneError = 0,
+  kDeviceMemError,
+  kHbmMultBitEccError,
+  kCommOpRetryFailError,
+  kForceStopError,
+  kUnknownError
+};
 
 class MS_CORE_API UCEException {
  public:
   static UCEException &GetInstance();
   static uint64_t ExtractUceTime(const char *error_msg);
   static bool IsEnableUCE();
+  static bool IsEnableHCCE();
   bool get_has_throw_error() const { return force_stop_flag_ || get_uce_flag() || is_reboot_node_; }
 
   void set_force_stop_flag(bool flag) { force_stop_flag_ = flag; }
   bool get_force_stop_flag() const { return force_stop_flag_; }
 
   bool get_uce_flag() const { return uce_error_type_ != UCEError::kNoneError; }
+  bool get_hcce_flag() const { return uce_error_type_ == UCEError::kCommOpRetryFailError; }
   void clear_uce_error() { uce_error_type_ = UCEError::kNoneError; }
 
   void set_reboot_node(bool flag) { is_reboot_node_ = flag; }
@@ -157,14 +166,31 @@ class MS_CORE_API UCEException {
   bool enable_arf() { return arf_env_; }
   void set_rebuild_group_flag(bool flag) { rebuild_group_ = flag; }
   bool rebuild_group_flag() const { return rebuild_group_; }
+  bool check_rootinfo_clean_flag() const { return had_clean_; }
+  bool need_clean_rootinfo() const { return clean_rootinfo_; }
+  void set_rootinfo_clean_flag(bool flag) { had_clean_ = flag; }
 
   void CheckUceARFEnv() {
-    const auto tftEnv = common::GetEnv("MS_ENABLE_TFT");
-    constexpr std::string_view optARF = "ARF:1";
-    if (!tftEnv.empty() && (tftEnv.find(optARF) != std::string::npos)) {
+    if (init_) {
+      return;
+    }
+    static std::string tftEnv = common::GetEnv("MS_ENABLE_TFT");
+    if (tftEnv.empty()) {
+      init_ = true;
+      return;
+    }
+    const std::string optARF = "ARF:1";
+    const std::string optRSC = "RSC:1";
+    if (tftEnv.find(optARF) != std::string::npos) {
       arf_env_ = true;
+      clean_rootinfo_ = true;
       MS_LOG(WARNING) << "ARF enabled.";
     }
+    if (tftEnv.find(optRSC) != std::string::npos) {
+      clean_rootinfo_ = true;
+      MS_LOG(WARNING) << "RSC enabled.";
+    }
+    init_ = true;
   }
   void set_uce_occur_time(uint64_t time) { uce_occur_time_ = time; }
   uint64_t get_uce_occur_time() { return uce_occur_time_; }
@@ -180,6 +206,8 @@ class MS_CORE_API UCEException {
       return "UCEError error occurs when execute, error_code=507053";
     } else if (uce_error_type_ == UCEError::kHbmMultBitEccError) {
       return "UCEError error occurs when execute, error_code=507054";
+    } else if (uce_error_type_ == UCEError::kCommOpRetryFailError) {
+      return "HCCEError error occurs when execute";
     } else if (uce_error_type_ == UCEError::kNoneError) {
       return "No uce error occurs.";
     } else {
@@ -198,6 +226,9 @@ class MS_CORE_API UCEException {
   bool is_reboot_node_{false};
   bool is_arf_{false};
   bool rebuild_group_{false};
+  bool had_clean_{false};
+  bool clean_rootinfo_{false};
+  bool init_{false};
   uint64_t uce_occur_time_{0};
   UCEError uce_error_type_{UCEError::kNoneError};
 };

mindspore/include/mindspore/core/include/utils/ms_utils.h

@@ -77,6 +77,8 @@ const char kAllocEnableVmm[] = "enable_vmm";
 const char kAllocVmmAlignSize[] = "vmm_align_size";
 const char kAllocMemoryRecycle[] = "memory_recycle";
 const char kAllocMemoryTracker[] = "memory_tracker";
+const char kAllocSimpleTracker[] = "simple_tracker";
+const char kAllocMemoryTrackerPath[] = "memory_tracker_path";
 const char kAllocDefragMemoryStepFreq[] = "defrag_memory_step_freq";
 const char kAllocMemoryPool[] = "older_pool";
 
@@ -91,7 +93,6 @@ const char kRuntimePipeline[] = "pipeline";
 const char kRuntimeGraphPipeline[] = "graph_pipeline";
 const char kRuntimeKbkSubGraphMode[] = "kbk_sub_graph_mode";
 const char kRuntimeCommunicationLaunchGroup[] = "communication_launch_group";
-const char kRuntimeView[] = "view";
 const char kRuntimeInsertTensorMove[] = "insert_tensormove";
 const char kRuntimeAllfinite[] = "all_finite";
 const char kRuntimeParalletAssignAddOpt[] = "parallel_assignadd_opt";
@@ -117,6 +118,7 @@ const char kRuntimeAclnnCacheQueueLength[] = "aclnn_cache_queue_length";
 const char kRuntimeAclnnCache[] = "aclnn_cache";
 const char kRuntimePreBuildCommKernel[] = "pre_build_comm_kernel";
 const char kRuntimeExecutionOrderCheckIteration[] = "execution_order_check_iteration";
+const char kRuntimeHPMode[] = "high_performance_mode";
 const char kSingleQuote = '\'';
 const char kDoubleQuote = '"';
 const char kSemicolon = ';';
@@ -294,13 +296,6 @@ inline bool IsExecuteSimulation() {
   return simu_execute;
 }
 
-inline bool IsDryRun() {
-  static const char kLaunchSkippedEnv[] = "MS_KERNEL_LAUNCH_SKIP";
-  static const auto launch_skipped = GetEnv(kLaunchSkippedEnv);
-  static const bool skip_launch = (launch_skipped == "all" || launch_skipped == "ALL" || IsCompileSimulation());
-  return skip_launch;
-}
-
 inline void SplitString(const std::string &str, char delim, std::set<std::string> *output_list) {
   std::stringstream ss(str);
   std::string item;

mindspore/include/mindspore/core/include/utils/ms_utils_secure.h

@@ -16,7 +16,7 @@
 #ifndef MINDSPORE_CORE_UTILS_MS_UTILS_SECURE_H_
 #define MINDSPORE_CORE_UTILS_MS_UTILS_SECURE_H_
 
-#include "securec/include/securec.h"
+#include "include/securec.h"
 #include "utils/log_adapter.h"
 
 namespace mindspore {

mindspore/include/mindspore/core/include/utils/phase.h

@@ -50,6 +50,9 @@ class MS_CORE_API PhaseManager {
   /// \brief Clear the phase by set an empty string.
   void ClearPhase() { phase_ = ""; }
 
+  /// \brief Clear jit_config.
+  void ClearJitConfig() { jit_config_.clear(); }
+
   /// \brief Set jit config.
   ///
   /// \param[in] The current jit config.

mindspore/include/mindspore/core/include/utils/system/base.h

@@ -19,7 +19,7 @@
 
 #include <string>
 #include <memory>
-#include "securec/include/securec.h"
+#include "include/securec.h"
 #include "utils/log_adapter.h"
 
 namespace mindspore {

mindspore/include/mindspore/core/mindrt/include/actor/op_actor.h

@@ -60,6 +60,15 @@ struct OpData {
   int index_;
 };
 
+// OpRTActor data.
+template <typename T>
+struct OpRTData {
+  OpRTData(const AID &op_id, const std::shared_ptr<T> &data, int index) : op_id_(op_id), data_(data), index_(index) {}
+  AID op_id_;
+  std::shared_ptr<T> data_;
+  int index_;
+};
+
 class MS_CORE_API RandInt {
  public:
   int Get() const { return rand(); }
@@ -75,6 +84,12 @@ using OpDataPtr = std::shared_ptr<OpData<T>>;
 template <typename T>
 using OpDataUniquePtr = std::unique_ptr<OpData<T>>;
 
+template <typename T>
+using OpRTDataPtr = std::shared_ptr<OpRTData<T>>;
+
+template <typename T>
+using OpRTDataUniquePtr = std::unique_ptr<OpRTData<T>>;
+
 // The context of opActor running.
 template <typename T>
 struct OpContext {
@@ -102,6 +117,34 @@ struct OpContext {
   void SetResult(size_t index, int value) const { results_->at(index).SetValue(value); }
 };
 
+// The context of opRTActor running.
+template <typename T>
+struct OpRTContext {
+  int sequential_num_;
+  std::vector<OpRTDataPtr<T>> *output_data_;
+  std::vector<Promise<int>> *results_;
+  // Record the error info for print.
+  bool is_error_{false};
+  std::string error_info_{""};
+  const void *kernel_call_back_before_;
+  const void *kernel_call_back_after_;
+
+  void SetFailed(int32_t code) const {
+    if (code == MindrtStatus::KINIT) {
+      code = MindrtStatus::KERROR;
+    }
+    results_->front().SetFailed(code);
+  }
+
+  void SetSuccess(int32_t code) const {
+    for (auto promise : *results_) {
+      promise.SetValue(code);
+    }
+  }
+
+  void SetResult(size_t index, int value) const { results_->at(index).SetValue(value); }
+};
+
 template <typename T>
 class OpActor : public ActorBase {
  public:
@@ -126,6 +169,31 @@ class OpActor : public ActorBase {
   mindspore::HashMap<int, std::vector<AID *>> input_op_controls_;
   std::vector<ControlArrowPtr> output_control_arrows_;
 };
+
+template <typename T>
+class OpRTActor : public ActorBase {
+ public:
+  explicit OpRTActor(const std::string &op_name) : ActorBase(op_name) {}
+  ~OpRTActor() override = default;
+
+  // The op actor run when receive the input data.
+  virtual void RunOpData(OpRTData<T> *input_data, OpRTContext<T> *context = nullptr) {}
+
+  // The op actor run when receive the input control.
+  virtual void RunOpControl(AID *input_control, OpRTContext<T> *context = nullptr) {}
+
+  const std::vector<DataArrowPtr> &output_data_arrows() const { return output_data_arrows_; }
+  const std::vector<ControlArrowPtr> &output_control_arrows() const { return output_control_arrows_; }
+
+ protected:
+  // The op data.
+  mindspore::HashMap<int, std::vector<OpRTData<T> *>> input_op_datas_;
+  std::vector<DataArrowPtr> output_data_arrows_;
+
+  // The op controls.
+  mindspore::HashMap<int, std::vector<AID *>> input_op_controls_;
+  std::vector<ControlArrowPtr> output_control_arrows_;
+};
 }  // namespace mindspore
 
 #endif  // MINDSPORE_CORE_MINDRT_INCLUDE_ACTOR_OP_ACTOR_H

mindspore/include/mindspore/core/mindrt/include/async/async.h

@@ -147,7 +147,7 @@ void Async(const AID &aid, const std::shared_ptr<ActorMgr> &mgr, void (T::*metho
     MINDRT_ASSERT(t != nullptr);
     Apply(t, method, tuple);
   };
-  auto msg = std::unique_ptr<MessageBase>(new (std::nothrow) MessageAsync(std::move(handler)));
+  auto msg = std::make_unique<MessageAsync>(std::move(handler));
   MINDRT_OOM_EXIT(msg);
   (void)mgr->Send(aid, std::move(msg));
 }
@@ -172,7 +172,7 @@ Future<R> Async(const AID &aid, Future<R> (T::*method)()) {
     promise->Associate((t->*method)());
   };
 
-  auto msg = std::unique_ptr<MessageBase>(new (std::nothrow) MessageAsync(std::move(handler)));
+  auto msg = std::make_unique<MessageAsync>(std::move(handler));
   MINDRT_OOM_EXIT(msg);
   (void)ActorMgr::GetActorMgrRef()->Send(aid, std::move(msg));
   return future;

mindspore/include/mindspore/core/mindrt/include/thread/hqueue.h

@@ -35,7 +35,7 @@ template <typename T>
 struct HQNode {
   std::atomic<Pointer> next;
   T *value = nullptr;
-  std::atomic_bool free = {true};
+  std::atomic_bool is_free = {true};
 };
 
 template <typename T>
@@ -59,7 +59,7 @@ class HQueue {
         return false;
       }
       node->value = nullptr;
-      node->free = true;
+      node->is_free = true;
       node->next = {-1, 0};
       nodes.emplace_back(node);
     }
@@ -67,7 +67,7 @@ class HQueue {
     // init first node as dummy head
     qhead = {0, 0};
     qtail = {0, 0};
-    nodes[0]->free = false;
+    nodes[0]->is_free = false;
     queue_size = sz;
     free_index = 1;
     return true;
@@ -85,7 +85,7 @@ class HQueue {
     int32_t nodeIdx = free_index;
     for (; nodeIdx < queue_size; ++nodeIdx) {
       bool expected = true;
-      if (nodes[nodeIdx]->free.compare_exchange_strong(expected, false)) {
+      if (nodes[nodeIdx]->is_free.compare_exchange_strong(expected, false)) {
         node = nodes[nodeIdx];
         free_index = nodeIdx + 1;
         break;
@@ -95,7 +95,7 @@ class HQueue {
       free_index = 1;
       for (nodeIdx = 1; nodeIdx < queue_size; ++nodeIdx) {
         bool expected = true;
-        if (nodes[nodeIdx]->free.compare_exchange_strong(expected, false)) {
+        if (nodes[nodeIdx]->is_free.compare_exchange_strong(expected, false)) {
           node = nodes[nodeIdx];
           free_index = nodeIdx + 1;
           break;
@@ -160,7 +160,7 @@ class HQueue {
         ret = nodes[next.index]->value;
         if (this->qhead.compare_exchange_strong(head, {next.index, head.version + 1})) {
           // free head
-          nodes[head.index]->free = true;
+          nodes[head.index]->is_free = true;
           return ret;
         }
       }