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

mindspore/include/mindspore/ccsrc/backend/ge_backend/runtime/actor/data_prepare_actor.h

@@ -55,16 +55,16 @@ class DataPrepareActor : public DebugAwareActor {
 
   // The process entry of data prepare.
   void PrepareData(const std::vector<std::vector<TensorPtr>> &input_tensors, const VectorRef &args,
-                   OpContext<DeviceTensor> *const context, GraphExecutionStrategy real_strategy);
+                   OpContext<KernelTensor> *const context, GraphExecutionStrategy real_strategy);
 
   // The debug related operation interface.
-  void SendDebugReq(OpContext<DeviceTensor> *const context) override;
-  void SendProfilerReq(OpContext<DeviceTensor> *const context);
-  void OnDebugFinish(OpContext<DeviceTensor> *const context) override;
+  void SendDebugReq(OpContext<KernelTensor> *const context) override;
+  void SendProfilerReq(OpContext<KernelTensor> *const context);
+  void OnDebugFinish(OpContext<KernelTensor> *const context) override;
 
  protected:
   void Init() override;
-  void Run(OpContext<DeviceTensor> *const context) override {
+  void Run(OpContext<KernelTensor> *const context) override {
     VectorRef empty_args;
     PrepareData(init_tensors_, empty_args, context, GraphExecutionStrategy::kPipeline);
   }
@@ -80,36 +80,36 @@ class DataPrepareActor : public DebugAwareActor {
                              const KernelWithIndex &front_node);
 
   void PrepareDataForDeviceTensorStore(const std::vector<std::vector<TensorPtr>> &input_tensors, const VectorRef &args,
-                                       OpContext<DeviceTensor> *const context);
+                                       OpContext<KernelTensor> *const context);
   void PrepareDataForHostTensorQueue(const std::vector<std::vector<TensorPtr>> &input_tensors, const VectorRef &args,
-                                     OpContext<DeviceTensor> *const context);
-  void PrepareDataForHostTensorQueueNew(const VectorRef &args, OpContext<DeviceTensor> *const context);
+                                     OpContext<KernelTensor> *const context);
+  void PrepareDataForHostTensorQueueNew(const VectorRef &args, OpContext<KernelTensor> *const context);
 
   // Prepare the device data for persistent device tensor of weight node from host tensor.
   void PrepareDataForWeightNode(const AnfNodePtr &backend_node, const AnfNodePtr &front_node, const TensorPtr &tensor,
-                                OpContext<DeviceTensor> *const context);
+                                OpContext<KernelTensor> *const context);
   // Prepare the device data for persistent device tensor of value node.
   void PrepareDataForValueNode(const ValueNodePtr &node, const AnfNodePtr &front_node,
-                               OpContext<DeviceTensor> *const context) const;
+                               OpContext<KernelTensor> *const context) const;
   void PrepareDataForStringValue(const ValueNodePtr &node, size_t index, const AnfNodePtr &front_node,
-                                 OpContext<DeviceTensor> *const context) const;
+                                 OpContext<KernelTensor> *const context) const;
   // Sync host data of Sequence or Scalar type value to device side.
   void PrepareDataForSequenceAndScalarValue(const ValueNodePtr &node, size_t index, const AnfNodePtr &front_node,
-                                            OpContext<DeviceTensor> *const context) const;
+                                            OpContext<KernelTensor> *const context) const;
   //  The branch processing of PrepareDataForValueNode that value type is tensor.
   void PrepareDataForValueNodeTensor(const ValueNodePtr &node, const ValuePtr &node_value, const AnfNodePtr &front_node,
-                                     OpContext<DeviceTensor> *const context) const;
+                                     OpContext<KernelTensor> *const context) const;
 
   // The data prepare in the control flow scene.
   // If the parameters in the root graph are only used by the control node, these parameters will not be initialized
   // by the kernel graph, and addresses need to be specially allocated for these parameters.
   void PrepareDeviceTensorStoreForControlNode(const ControlNodeParserPtr &control_node_parser,
                                               const std::vector<TensorPtr> &tensors, const VectorRef &args,
-                                              OpContext<DeviceTensor> *const context);
+                                              OpContext<KernelTensor> *const context);
   void PrepareHostTensorQueueForControlNode(const std::vector<TensorPtr> &tensors,
                                             std::vector<TensorPtr> *const host_tensors,
-                                            OpContext<DeviceTensor> *const context);
-  void PrepareDataForControlValueNode(const KernelWithIndex &node_with_index, OpContext<DeviceTensor> *const context,
+                                            OpContext<KernelTensor> *const context);
+  void PrepareDataForControlValueNode(const KernelWithIndex &node_with_index, OpContext<KernelTensor> *const context,
                                       const ControlNodeParserPtr &parser) const;
 
   void SetInitTensorsIfNeeded(const std::vector<std::vector<TensorPtr>> &input_tensors);

mindspore/include/mindspore/ccsrc/backend/ge_backend/runtime/actor/data_source_actor.h

@@ -56,19 +56,19 @@ class DataSourceActor : public DebugAwareActor {
 
   void Init() override;
 
-  void Run(OpContext<DeviceTensor> *const context) override { FetchData(context); }
+  void Run(OpContext<KernelTensor> *const context) override { FetchData(context); }
 
   // The process entry of data processing.
-  void FetchData(OpContext<DeviceTensor> *const context);
+  void FetchData(OpContext<KernelTensor> *const context);
 
   // Construct the device tensors and fill to device tensor buffer from the member nodes during the data fetching.
   virtual void FillDataBuffer() = 0;
 
-  void UpdateOutputData(OpData<DeviceTensor> *const output_data, const DataArrowPtr &data_arrow,
-                        const AnfNodePtr &output_node, OpContext<DeviceTensor> *const context) override;
+  void UpdateOutputData(OpData<KernelTensor> *const output_data, const DataArrowPtr &data_arrow,
+                        const AnfNodePtr &output_node, OpContext<KernelTensor> *const context) override;
 
   // The buffers store the device tensors.
-  std::queue<std::vector<DeviceTensor *>> buffers_;
+  std::queue<std::vector<KernelTensorPtr>> buffers_;
   size_t buffer_capacity_;
 };
 
@@ -85,10 +85,10 @@ class HostQueueDataSourceActor : public DataSourceActor {
   ~HostQueueDataSourceActor() override = default;
 
   // The memory related operation interface.
-  void SendMemoryAllocReq(OpContext<DeviceTensor> *const context) override;
-  void SendMemoryFreeReq(OpContext<DeviceTensor> *const context) override;
+  void SendMemoryAllocReq(OpContext<KernelTensor> *const context) override;
+  void SendMemoryFreeReq(OpContext<KernelTensor> *const context) override;
   // Copy data from data source to the device tensor buffer of actor after memory alloc finished.
-  void OnMemoryAllocFinish(OpContext<DeviceTensor> *const context) override;
+  void OnMemoryAllocFinish(OpContext<KernelTensor> *const context) override;
 
   size_t FetchNodePosition(const KernelWithIndex &node) const override;
   KernelWithIndex FetchNode(size_t node_position) const;
@@ -100,7 +100,7 @@ class HostQueueDataSourceActor : public DataSourceActor {
   void FillDataBuffer() override;
 
   void AddCopyDataCallBack(bool enable_async_copy, const mindspore::tensor::TensorPtrList &host_tensors,
-                           const std::vector<DeviceTensor *> &device_tensors);
+                           const std::vector<KernelTensorPtr> &kernel_tensors);
 
  private:
   friend class GraphScheduler;

mindspore/include/mindspore/ccsrc/backend/ge_backend/runtime/actor/debug_actor.h

@@ -32,20 +32,20 @@ class DebugActor : public ActorBase {
   ~DebugActor() override = default;
 
   // The debug of each node.
-  void DebugPreLaunch(const AnfNodePtr &node, const std::vector<DeviceTensor *> &op_input_kernel_tensors,
-                      const std::vector<DeviceTensor *> &op_output_kernel_tensors,
-                      OpContext<DeviceTensor> *const op_context, const AID *from_aid);
-  void DebugPostLaunch(const AnfNodePtr &node, const std::vector<DeviceTensor *> &op_input_kernel_tensors,
-                       const std::vector<DeviceTensor *> &op_output_kernel_tensors,
-                       OpContext<DeviceTensor> *const op_context, const AID *from_aid);
+  void DebugPreLaunch(const AnfNodePtr &node, const std::vector<KernelTensorPtr> &op_input_kernel_tensors,
+                      const std::vector<KernelTensorPtr> &op_output_kernel_tensors,
+                      OpContext<KernelTensor> *const op_context, const AID *from_aid);
+  void DebugPostLaunch(const AnfNodePtr &node, const std::vector<KernelTensorPtr> &op_input_kernel_tensors,
+                       const std::vector<KernelTensorPtr> &op_output_kernel_tensors,
+                       OpContext<KernelTensor> *const op_context, const AID *from_aid);
 
   // The debug on step begin.
   void DebugOnStepBegin(const std::vector<KernelGraphPtr> &graphs,
                         const std::vector<AnfNodePtr> &origin_parameters_order,
-                        OpContext<DeviceTensor> *const op_context, const AID *from_aid);
+                        OpContext<KernelTensor> *const op_context, const AID *from_aid);
 
   // The debug on step end.
-  void DebugOnStepEnd(OpContext<DeviceTensor> *const op_context, const AID *from_aid, int total_running_count,
+  void DebugOnStepEnd(OpContext<KernelTensor> *const op_context, const AID *from_aid, int total_running_count,
                       int sink_size);
 
  private:

mindspore/include/mindspore/ccsrc/backend/ge_backend/runtime/actor/debug_aware_actor.h

@@ -33,8 +33,8 @@ class DebugAwareActor : public MemoryAwareActor {
         profiler_aid_(profiler_aid) {}
   ~DebugAwareActor() override = default;
 
-  virtual void SendDebugReq(OpContext<DeviceTensor> *const context) {}
-  virtual void OnDebugFinish(OpContext<DeviceTensor> *const context) { PostRun(context); }
+  virtual void SendDebugReq(OpContext<KernelTensor> *const context) {}
+  virtual void OnDebugFinish(OpContext<KernelTensor> *const context) { PostRun(context); }
 
  protected:
   // The id of debug actor. Send message to it for debug.

mindspore/include/mindspore/ccsrc/backend/ge_backend/runtime/actor/loop_count_actor.h

@@ -52,11 +52,11 @@ class LoopCountActor : public DebugAwareActor {
   ~LoopCountActor() override = default;
 
   // The callback waits for the memory manager actor to finish all the message processing.
-  void OnMemoryAllocFinish(OpContext<DeviceTensor> *const context) override;
+  void OnMemoryAllocFinish(OpContext<KernelTensor> *const context) override;
 
   // The debug related operation interface.
-  void SendDebugReq(OpContext<DeviceTensor> *const context) override;
-  void SendProfilerReq(OpContext<DeviceTensor> *const context);
+  void SendDebugReq(OpContext<KernelTensor> *const context) override;
+  void SendProfilerReq(OpContext<KernelTensor> *const context);
 
   // Get the member.
   size_t loop_count() const { return loop_count_; }
@@ -65,14 +65,14 @@ class LoopCountActor : public DebugAwareActor {
   const std::vector<AID> &entrance_aids() const { return entrance_aids_; }
 
  protected:
-  void Run(OpContext<DeviceTensor> *const context) override;
-  void SendOutput(OpContext<DeviceTensor> *const context) override;
+  void Run(OpContext<KernelTensor> *const context) override;
+  void SendOutput(OpContext<KernelTensor> *const context) override;
 
  private:
   friend class GraphScheduler;
   friend class ControlNodeScheduler;
 
-  void IncreaseLoopCount(OpContext<DeviceTensor> *const context);
+  void IncreaseLoopCount(OpContext<KernelTensor> *const context);
 
   // Graph name of GraphCompilerInfo. For example, kernel_graph_0-3.
   std::string graph_name_;

mindspore/include/mindspore/ccsrc/backend/ge_backend/runtime/actor/memory_aware_actor.h

@@ -17,9 +17,9 @@
 #ifndef MINDSPORE_CCSRC_RUNTIME_FRAMEWORK_ACTOR_MEMORY_AWARE_ACTOR_H_
 #define MINDSPORE_CCSRC_RUNTIME_FRAMEWORK_ACTOR_MEMORY_AWARE_ACTOR_H_
 
-#include <string>
 #include <memory>
-#include <mutex>
+#include <string>
+
 #include "backend/ge_backend/runtime/actor/abstract_actor.h"
 #include "backend/ge_backend/runtime/device_tensor_store.h"
 
@@ -34,9 +34,9 @@ class MemoryAwareActor : public AbstractActor {
       : AbstractActor(name, type, recorder_aid), memory_manager_aid_(memory_manager_aid) {}
   ~MemoryAwareActor() override = default;
 
-  virtual void SendMemoryAllocReq(OpContext<DeviceTensor> *const context) {}
-  virtual void SendMemoryFreeReq(OpContext<DeviceTensor> *const context) {}
-  virtual void OnMemoryAllocFinish(OpContext<DeviceTensor> *const context) {}
+  virtual void SendMemoryAllocReq(OpContext<KernelTensor> *const context) {}
+  virtual void SendMemoryFreeReq(OpContext<KernelTensor> *const context) {}
+  virtual void OnMemoryAllocFinish(OpContext<KernelTensor> *const context) {}
 
   const AID &memory_manager_aid() const { return memory_manager_aid_; }
 
@@ -44,7 +44,7 @@ class MemoryAwareActor : public AbstractActor {
   friend class GraphScheduler;
 
   // The processing after actor run: 1.erase input, 2.free memory, 3.send output.
-  void PostRun(OpContext<DeviceTensor> *const context) {
+  void PostRun(OpContext<KernelTensor> *const context) {
     // The input is invalid and needs to be erased when finish run.
     EraseInput(context);
 

mindspore/include/mindspore/ccsrc/backend/ge_backend/runtime/actor/memory_manager_actor.h

@@ -36,30 +36,27 @@ using mindspore::runtime::ProfilerRecorder;
 // MemoryManagerActor need response to memory alloc and free quickly, so must bind single thread.
 class MemoryManagerActor : public ActorBase {
  public:
-  static std::shared_ptr<MemoryManagerActor> &GetInstance() {
-    static std::shared_ptr<MemoryManagerActor> instance = std::shared_ptr<MemoryManagerActor>(new MemoryManagerActor());
-    return instance;
-  }
+  static std::shared_ptr<MemoryManagerActor> &GetInstance();
   ~MemoryManagerActor() override = default;
 
   // The process entry of memory alloc.
-  void AllocateMemory(const std::vector<DeviceTensor *> *alloc_list, OpContext<DeviceTensor> *const op_context,
+  void AllocateMemory(const std::vector<KernelTensorPtr> *alloc_list, OpContext<kernel::KernelTensor> *const op_context,
                       const AID &from_aid);
 
-  void AllocateBatchMemory(const std::vector<DeviceTensor *> *alloc_list, OpContext<DeviceTensor> *const op_context,
-                           const AID &from_aid);
+  void AllocateBatchMemory(const std::vector<KernelTensorPtr> *alloc_list,
+                           OpContext<kernel::KernelTensor> *const op_context, const AID &from_aid);
 
   // The process entry of memory free.
-  void FreeMemory(const std::vector<DeviceTensor *> *free_list, OpContext<DeviceTensor> *const op_context,
+  void FreeMemory(const std::vector<KernelTensorPtr> *free_list, OpContext<kernel::KernelTensor> *const op_context,
                   const AID &from_aid);
 
-  void FreeBatchMemory(const std::vector<DeviceTensor *> *free_list, OpContext<DeviceTensor> *const op_context,
+  void FreeBatchMemory(const std::vector<KernelTensorPtr> *free_list, OpContext<kernel::KernelTensor> *const op_context,
                        const AID &from_aid);
 
   void FreeMemoryByRefCount(DeviceTensor *const device_tensor, const std::string &op_name);
 
   // Wait the MemoryManagerActor to finish running all current messages.
-  void Wait(OpContext<DeviceTensor> *const op_context, const AID &from_aid);
+  void Wait(OpContext<kernel::KernelTensor> *const op_context, const AID &from_aid);
 
  private:
   MemoryManagerActor() : ActorBase("GEMemoryManagerActor") {}
@@ -67,7 +64,7 @@ class MemoryManagerActor : public ActorBase {
 
   // When allocate device memory fail, print error log and set op context failed status.
   void SetOpContextMemoryAllocFail(const std::string &kernel_name, size_t alloc_size,
-                                   OpContext<DeviceTensor> *const op_context);
+                                   OpContext<kernel::KernelTensor> *const op_context);
 
   // MemoryManagerActor object is used like a single instance, if one actor allocates memory failed in one batch, which
   // will set fail message info OpContext, major thread will destroy the OpContext object, subsequent actor can not set

mindspore/include/mindspore/ccsrc/backend/ge_backend/runtime/actor/output_actor.h

@@ -52,15 +52,15 @@ class OutputActor : public AbstractActor {
         current_outputs_num_(0) {
     outputs_.resize(outputs_num);
     output_nodes_.resize(outputs_num);
-    output_device_tensors_.resize(outputs_num);
+    output_kernel_tensors_.resize(outputs_num);
   }
   ~OutputActor() override = default;
 
   // The output actor collects loop count when receive the input control of loop count actor.
-  void RunOpControl(AID *const input_control, OpContext<DeviceTensor> *const context) override;
+  void RunOpControl(AID *const input_control, OpContext<KernelTensor> *const context) override;
 
   // The output actor collects output result when receive the data of actor.
-  void RunOpData(OpData<DeviceTensor> *const input_data, OpContext<DeviceTensor> *const context) override;
+  void RunOpData(OpData<KernelTensor> *const input_data, OpContext<KernelTensor> *const context) override;
 
   // The graph output need be set new device address every step or loop, to avoid that the device address
   // context of tensor be rewritten in the next step or next loop.
@@ -74,6 +74,8 @@ class OutputActor : public AbstractActor {
   size_t loop_count() const { return loop_count_; }
   size_t outputs_num() const { return outputs_num_; }
   const std::vector<TensorPtr> &outputs() const { return outputs_; }
+  const std::vector<kernel::KernelTensorPtr> &output_kernel_tensors() const { return output_kernel_tensors_; }
+  const std::vector<TypePtr> &output_types() const { return output_types_; }
 
   // Set the stub output node and flatten them to vector by output position.
   void SetStubOutput(const stub::StubNodePtr &stub_output);
@@ -86,7 +88,7 @@ class OutputActor : public AbstractActor {
   friend class ControlNodeScheduler;
 
   TensorPtr CreateOutputTensor(const AnfNodePtr &output_node, size_t output_index, size_t output_position,
-                               OpContext<DeviceTensor> *const context);
+                               OpContext<KernelTensor> *const context);
 
   // The output device memory will be taken over by tensor in the last loop, otherwise needs to free the memory.
   // 1.Avoid the memory leak when memory used by dynamic ref count in the control flow scene.
@@ -105,7 +107,8 @@ class OutputActor : public AbstractActor {
   std::vector<KernelWithIndex> summary_nodes_;
   std::vector<TensorPtr> outputs_;
   std::vector<KernelWithIndex> output_nodes_;
-  std::vector<DeviceTensor *> output_device_tensors_;
+  std::vector<KernelTensorPtr> output_kernel_tensors_;
+  std::vector<TypePtr> output_types_;
   size_t outputs_num_;
   size_t current_outputs_num_;
 

mindspore/include/mindspore/ccsrc/backend/ge_backend/runtime/actor/profiler_actor.h

@@ -43,10 +43,10 @@ class ProfilerActor : public ActorBase {
   // The debug on step begin.
   void ProfilerOnStepBegin(const std::vector<KernelGraphPtr> &graphs,
                            const std::vector<AnfNodePtr> &origin_parameters_order,
-                           OpContext<DeviceTensor> *const op_context, const AID *from_aid);
+                           OpContext<KernelTensor> *const op_context, const AID *from_aid);
 
   // The debug on step end.
-  void ProfilerOnStepEnd(OpContext<DeviceTensor> *const op_context, const AID *from_aid, int total_running_count_);
+  void ProfilerOnStepEnd(OpContext<KernelTensor> *const op_context, const AID *from_aid, int total_running_count_);
   static inline uint64_t current_step{1};
 
  private:

mindspore/include/mindspore/ccsrc/backend/ge_backend/runtime/actor/recorder_actor.h

@@ -39,11 +39,11 @@ class RecorderActor : public ActorBase {
 
   // The memory recorder of each node.
   void RecordInfo(const std::string op_name, const KernelLaunchAddr *launch_info,
-                  OpContext<DeviceTensor> *const op_context);
+                  OpContext<KernelTensor> *const op_context);
 
   // Clear memory recorder at the step end.
   // Record fp_start and iter_end op name and timestamp at the step end. (GPU)
-  void RecordOnStepEnd(OpContext<DeviceTensor> *const op_context);
+  void RecordOnStepEnd(OpContext<KernelTensor> *const op_context);
 };
 }  // namespace runtime
 }  // namespace ge_backend

mindspore/include/mindspore/ccsrc/backend/ge_backend/runtime/actor/super_kernel_actor.h

@@ -44,47 +44,47 @@ class SuperKernelActor : public DebugAwareActor {
  public:
   SuperKernelActor(const std::string &name, const KernelGraphPtr &graph, const std::string &graph_phase,
                    const AID &memory_manager_aid, const AID *debug_aid, const AID *recorder_aid,
-                   const std::shared_ptr<device::GraphExecutor> &graph_executor,
+                   const std::shared_ptr<backend::ge_backend::GeGraphExecutor> &graph_executor,
                    KernelTransformType type = KernelTransformType::kSuperKernelActor)
       : DebugAwareActor(name, type, recorder_aid, memory_manager_aid, debug_aid, nullptr),
         graph_(graph),
         graph_phase_(graph_phase),
         is_infer_phase_(IsInferPhase(graph_phase)),
         graph_executor_(graph_executor) {
-    input_device_tensors_.resize(graph->input_nodes().size());
+    input_kernel_tensors_.resize(graph->input_nodes().size());
   }
   ~SuperKernelActor() override = default;
 
   size_t FetchInputNodePosition(const AnfNodePtr &intput_node);
-  virtual void FetchInputDeviceTensor(OpContext<DeviceTensor> *const context);
+  virtual void FetchInputDeviceTensor(OpContext<KernelTensor> *const context);
   // The debug related operation interface.
-  void SendDebugReq(OpContext<DeviceTensor> *const context) override;
+  void SendDebugReq(OpContext<KernelTensor> *const context) override;
 
   // The memory related operation interface.
-  void SendMemoryAllocReq(OpContext<DeviceTensor> *const context) override;
+  void SendMemoryAllocReq(OpContext<KernelTensor> *const context) override;
   // The callback after memory alloc finished.
-  void OnMemoryAllocFinish(OpContext<DeviceTensor> *const context) override;
+  void OnMemoryAllocFinish(OpContext<KernelTensor> *const context) override;
   // The input may come from the control actor, so need free the input memory by the dynamic ref count.
-  void SendMemoryFreeReq(OpContext<DeviceTensor> *const context) override;
-  bool CopyInputData(const OpContext<DeviceTensor> *context, const KernelGraphPtr &graph);
+  void SendMemoryFreeReq(OpContext<KernelTensor> *const context) override;
+  bool CopyInputData(const OpContext<KernelTensor> *context, const KernelGraphPtr &graph);
 
   const KernelGraphPtr &graph() const { return graph_; }
 
  protected:
   void Init() override;
-  void Run(OpContext<DeviceTensor> *const context) override;
+  void Run(OpContext<KernelTensor> *const context) override;
   // The input device tensors for launch.
-  std::vector<DeviceTensor *> input_device_tensors_;
+  std::vector<KernelTensorPtr> input_kernel_tensors_;
   // The device tensors of graph input parameter, which used to compare the recv input data.
-  std::vector<DeviceTensorPtr> node_device_tensors_;
+  std::vector<KernelTensorPtr> node_kernel_tensors_;
   // The device tensors for memory alloc.
-  std::vector<DeviceTensor *> memory_alloc_list_;
+  std::vector<KernelTensorPtr> memory_alloc_list_;
   // The lists of device tensors which need free by dynamic ref count, will be cleared at the end of step.
-  std::queue<std::vector<DeviceTensor *>> memory_free_lists_;
+  std::queue<std::vector<KernelTensorPtr>> memory_free_lists_;
 
  private:
-  bool CopyInputDataPersistedHandle(DeviceTensor *input_device_tensor, const DeviceTensorPtr &node_device_tensor,
-                                    size_t i);
+  bool CopyInputDataPersistedHandle(const KernelTensorPtr &input_kernel_tensor,
+                                    const KernelTensorPtr &node_kernel_tensor, size_t i);
 
   void FetchPersistentDeviceTensor();
 
@@ -107,10 +107,10 @@ class SuperKernelActor : public DebugAwareActor {
 
   // The received input device type and format may be different from the formal parameter in the control flow scenarios,
   // so it needs to be copied from the input data to real data that graph launch needs.
-  std::vector<DeviceTensorPtr> copy_input_device_tensors_;
+  std::vector<KernelTensorPtr> copy_input_kernel_tensors_;
   // Record the device address to the output node of graph.
   std::map<DeviceAddress *, OutputMemoryInfo> device_address_to_node_;
-  std::shared_ptr<device::GraphExecutor> graph_executor_;
+  std::shared_ptr<backend::ge_backend::GeGraphExecutor> graph_executor_;
 };
 
 using SuperKernelActorPtr = std::shared_ptr<SuperKernelActor>;

mindspore/include/mindspore/ccsrc/backend/ge_backend/runtime/device_tensor_store.h

@@ -23,14 +23,14 @@
 #include "utils/hash_map.h"
 #include "utils/ms_utils.h"
 #include "include/backend/visible.h"
-#include "common/device_address.h"
+#include "common/kernel.h"
 
 namespace mindspore {
 namespace ge_backend {
 namespace runtime {
-using DeviceTensor = mindspore::device::DeviceAddress;
+using mindspore::kernel::KernelTensor;
 using DeviceTensorType = mindspore::device::DeviceType;
-using DeviceTensorPtr = std::shared_ptr<DeviceTensor>;
+using KernelTensorPtr = std::shared_ptr<KernelTensor>;
 
 // The device tensor mainly includes address ptr, size and reference count,
 // which represents the basic data structure of kernel launch and transfers between actors.
@@ -41,13 +41,13 @@ class BACKEND_EXPORT DeviceTensorStore {
   static DeviceTensorStore &GetInstance();
 
   //  Support value modifiable.
-  void Insert(AnfNode *key, const DeviceTensorPtr &value) {
+  void Insert(AnfNode *key, const KernelTensorPtr &value) {
     MS_EXCEPTION_IF_NULL(key);
     MS_EXCEPTION_IF_NULL(value);
     std::unique_lock<std::shared_mutex> lock(map_mutex_);
-    const auto &iter = device_tensors_.find(key);
-    if (iter == device_tensors_.end()) {
-      device_tensors_[key].emplace_back(value);
+    const auto &iter = kernel_tensors_.find(key);
+    if (iter == kernel_tensors_.end()) {
+      kernel_tensors_[key].emplace_back(value);
       return;
     }
 
@@ -70,33 +70,33 @@ class BACKEND_EXPORT DeviceTensorStore {
   void Remove(AnfNode *key) {
     MS_EXCEPTION_IF_NULL(key);
     std::unique_lock<std::shared_mutex> lock(map_mutex_);
-    const auto &iter = device_tensors_.find(key);
-    if (iter != device_tensors_.end()) {
-      (void)device_tensors_.erase(iter);
+    const auto &iter = kernel_tensors_.find(key);
+    if (iter != kernel_tensors_.end()) {
+      (void)kernel_tensors_.erase(iter);
     }
   }
 
-  std::vector<DeviceTensorPtr> Fetch(AnfNode *key) const {
+  std::vector<KernelTensorPtr> Fetch(AnfNode *key) const {
     MS_EXCEPTION_IF_NULL(key);
     std::shared_lock<std::shared_mutex> lock(map_mutex_);
-    const auto &iter = device_tensors_.find(key);
-    if (iter != device_tensors_.end()) {
+    const auto &iter = kernel_tensors_.find(key);
+    if (iter != kernel_tensors_.end()) {
       return iter->second;
     } else {
-      std::vector<DeviceTensorPtr> empty_value;
+      std::vector<KernelTensorPtr> empty_value;
       return empty_value;
     }
   }
 
-  DeviceTensorPtr Fetch(AnfNode *key, DeviceTensorType value_type) const {
+  KernelTensorPtr Fetch(AnfNode *key, DeviceTensorType value_type) const {
     MS_EXCEPTION_IF_NULL(key);
     std::shared_lock<std::shared_mutex> lock(map_mutex_);
-    const auto &iter = device_tensors_.find(key);
-    if (iter != device_tensors_.end()) {
-      for (const auto &device_tensor : iter->second) {
-        MS_EXCEPTION_IF_NULL(device_tensor);
-        if (device_tensor->GetDeviceType() == value_type) {
-          return device_tensor;
+    const auto &iter = kernel_tensors_.find(key);
+    if (iter != kernel_tensors_.end()) {
+      for (const auto &kernel_tensor : iter->second) {
+        MS_EXCEPTION_IF_NULL(kernel_tensor);
+        if (kernel_tensor->GetDeviceType() == value_type) {
+          return kernel_tensor;
         }
       }
     }
@@ -105,10 +105,10 @@ class BACKEND_EXPORT DeviceTensorStore {
 
   void Clear() {
     std::unique_lock<std::shared_mutex> lock(map_mutex_);
-    device_tensors_.clear();
+    kernel_tensors_.clear();
   }
 
-  const mindspore::HashMap<AnfNode *, std::vector<DeviceTensorPtr>> &GetAll() const { return device_tensors_; }
+  const mindspore::HashMap<AnfNode *, std::vector<KernelTensorPtr>> &GetAll() const { return kernel_tensors_; }
 
  private:
   DeviceTensorStore() = default;
@@ -117,7 +117,7 @@ class BACKEND_EXPORT DeviceTensorStore {
 
   // The data storage of device tensor. Key is the anf node, value is the vector which may contains the device
   // tensors from different devices.
-  mindspore::HashMap<AnfNode *, std::vector<DeviceTensorPtr>> device_tensors_;
+  mindspore::HashMap<AnfNode *, std::vector<KernelTensorPtr>> kernel_tensors_;
   // Read/Write lock for map.
   mutable std::shared_mutex map_mutex_;
 };

mindspore/include/mindspore/ccsrc/backend/ge_backend/runtime/graph_compiler.h

@@ -33,7 +33,6 @@
 #include "kernel/framework_utils.h"
 #include "common/device_type.h"
 #include "backend/ge_backend/executor/ge_graph_executor.h"
-#include "runtime/hardware/device_context.h"
 
 namespace mindspore {
 namespace ge_backend {
@@ -86,7 +85,7 @@ struct BACKEND_EXPORT GraphCompilerInfo {
                     const KernelMapPosition &origin_outputs_order, size_t outputs_num, size_t inputs_num,
                     const std::string &name, bool need_erase, GraphExecutionStrategy strategy,
                     const std::string &graph_phase, const FuncGraphPtr &root_graph,
-                    const std::shared_ptr<device::GraphExecutor> &graph_executor)
+                    const std::shared_ptr<backend::ge_backend::GeGraphExecutor> &graph_executor)
       : graphs_(graphs),
         tensors_mask_(tensors_mask),
         input_tensors_(input_tensors),
@@ -121,12 +120,12 @@ struct BACKEND_EXPORT GraphCompilerInfo {
   mutable GraphExecutionStrategy strategy_;
   std::string graph_phase_;
   FuncGraphPtr root_graph_;
-  std::shared_ptr<device::GraphExecutor> graph_executor_;
+  std::shared_ptr<backend::ge_backend::GeGraphExecutor> graph_executor_;
 };
 
 class GraphCompiler {
  public:
-  explicit GraphCompiler(std::shared_ptr<device::GraphExecutor> graph_executor) {
+  explicit GraphCompiler(std::shared_ptr<backend::ge_backend::GeGraphExecutor> graph_executor) {
     session_ = session::SessionFactory::Get().Create(kSessionBasic);
     graph_executor_ = graph_executor;
   }
@@ -135,11 +134,10 @@ class GraphCompiler {
   // Construct kernel graph from anf nodes list and compile kernel graph in Graph mode,
   // the detailed implementation of compiling graph is in 'CompileGraphImpl'.
   GraphId CompileGraph(const GraphSegmentPtr &segment, const std::pair<AnfNodePtrList, AnfNodePtrList> &io_nodes,
-                       const backend::BackendJitConfig &backend_jit_config, device::RunMode run_mode,
-                       bool run_in_pynative = false);
+                       const backend::BackendJitConfig &backend_jit_config, bool run_in_pynative = false);
 
   GraphId CompileGraph(const KernelGraphPtr &kernel_graph, const std::pair<AnfNodePtrList, AnfNodePtrList> &io_nodes,
-                       device::RunMode run_mode, bool run_in_pynative);
+                       bool run_in_pynative);
 
   // Get graph by graph id, if not exist return nullptr, used in Graph mode.
   KernelGraphPtr Fetch(GraphId graph_id) const;
@@ -171,7 +169,7 @@ class GraphCompiler {
   // The member variable 'session_' will be removed after removing session module.
   // Now all the GraphCompiler share the same 'session_'.
   session::SessionPtr session_;
-  std::shared_ptr<device::GraphExecutor> graph_executor_;
+  std::shared_ptr<backend::ge_backend::GeGraphExecutor> graph_executor_;
 };
 }  // namespace runtime
 }  // namespace ge_backend

mindspore/include/mindspore/ccsrc/backend/ge_backend/runtime/graph_partition.h

@@ -0,0 +1,49 @@
+/**
+ * Copyright 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.
+ * 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_VM_GRAPH_PARTITION_H_
+#define MINDSPORE_CCSRC_VM_GRAPH_PARTITION_H_
+#include <vector>
+#include <string>
+#include <memory>
+#include "ir/anf.h"
+#include "ir/func_graph.h"
+#include "ir/graph_utils.h"
+#include "base/base_ref.h"
+#include "include/backend/visible.h"
+
+namespace mindspore {
+constexpr char kMsConvert[] = "ms";
+constexpr char kMsVm[] = "vm";
+constexpr char kGeVm[] = "ge";
+
+namespace ge_backend::runtime {
+class BACKEND_EXPORT GraphPartition {
+ public:
+  explicit GraphPartition(const std::vector<PrimitivePtr> &cut_list, const std::string &backend_name);
+  ~GraphPartition() = default;
+  std::vector<GraphSegmentPtr> Partition(const FuncGraphPtr &graph, bool *multi_target = nullptr);
+
+ private:
+  bool IsCut(const AnfNodePtr &node);
+  std::vector<PrimitivePtr> cut_list_;
+  std::string backend_name_;
+};
+
+using GraphPartitionPtr = std::shared_ptr<GraphPartition>;
+}  // namespace ge_backend::runtime
+}  // namespace mindspore
+#endif  // MINDSPORE_CCSRC_VM_GRAPH_PARTITION_H_