mindspore 2.6.0rc1__cp310-none-any.whl → 2.7.0rc1__cp310-none-any.whl

mindspore/include/mindspore/ccsrc/runtime/graph_scheduler/actor/data_prepare_actor.h

@@ -57,12 +57,12 @@ 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;
 
   void set_has_continuous_memory(bool has_continuous_memory) { has_continuous_memory_ = has_continuous_memory; }
   bool has_continuous_memory() { return has_continuous_memory_; }
@@ -70,7 +70,7 @@ class DataPrepareActor : public DebugAwareActor {
 
  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);
   }
@@ -86,45 +86,45 @@ 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);
 
   void RaiseARFError(const VectorRef &args);
 
   // 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,
-                                const DeviceContext *device_context, OpContext<DeviceTensor> *const context);
+                                const DeviceContext *device_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,
-                               const DeviceContext *device_context, OpContext<DeviceTensor> *const context) const;
+                               const DeviceContext *device_context, OpContext<KernelTensor> *const context) const;
   void PrepareDataForStringValue(const ValueNodePtr &node, size_t index, const AnfNodePtr &front_node,
-                                 const DeviceContext *device_context, OpContext<DeviceTensor> *const context) const;
+                                 const DeviceContext *device_context, 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,
                                             const DeviceContext *device_context,
-                                            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,
-                                     const DeviceContext *device_context, OpContext<DeviceTensor> *const context) const;
+                                     const DeviceContext *device_context, 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);
+                                            OpContext<KernelTensor> *const context);
   void PrepareDataForControlValueNode(const KernelWithIndex &node_with_index, const DeviceContext *device_context,
-                                      OpContext<DeviceTensor> *const context, const ControlNodeParserPtr &parser) const;
+                                      OpContext<KernelTensor> *const context, const ControlNodeParserPtr &parser) const;
 
   // The device tensor stores may exist the two device tensors and need copy data in the heterogeneous scene.
   void CopyDataFromDeviceTensorStore(const AnfNodePtr &front_node, const AnfNodePtr &backend_node,
                                      const device::DeviceAddressPtr &host_tensor_address,
-                                     const DeviceContext *device_context, OpContext<DeviceTensor> *context) const;
+                                     const DeviceContext *device_context, OpContext<KernelTensor> *context) const;
 
   void SetInitTensorsIfNeeded(const std::vector<std::vector<TensorPtr>> &input_tensors);
 
@@ -135,12 +135,13 @@ class DataPrepareActor : public DebugAwareActor {
 
   // Prepare when input optimize, prepare const value and weights at the first step.
   void PrepareDataBeforeInputOptimize(const std::vector<std::vector<TensorPtr>> &input_tensors, const VectorRef &args,
-                                      OpContext<DeviceTensor> *const context, uint64_t start_time);
+                                      OpContext<KernelTensor> *const context, uint64_t start_time);
 
   // Record updated tensors for reprepare.
   void RecordTensorsNeedReprepare(tensor::Tensor *tensor);
-  void PrepareWeightForInputOptimize(const KernelWithIndex &node_with_index, OpContext<DeviceTensor> *const context,
-                                     const DeviceContext *device_context);
+  void PrepareWeightForInputOptimize(const KernelWithIndex &node_with_index, OpContext<KernelTensor> *const context);
+  void RecordInputAndConvertStatic(const std::vector<TensorPtr> &host_tensors,
+                                   const std::vector<size_t> &host_param_indexes, bool isDyn);
 
   // Remove after refact.
   bool enable_prepare_case() {

mindspore/include/mindspore/ccsrc/runtime/graph_scheduler/actor/data_source_actor.h

@@ -57,69 +57,22 @@ 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_;
 };
 
-// The class represents that the data source is device queue.
-class DeviceQueueDataSourceActor : public DataSourceActor {
- public:
-  DeviceQueueDataSourceActor(const std::string &name, size_t buffer_capacity, const DeviceContext *device_context,
-                             const AID &memory_manager_aid, const AID *debug_aid, const AID *recorder_aid)
-      : DataSourceActor(name, KernelTransformType::kDeviceDataSourceActor, buffer_capacity, memory_manager_aid,
-                        debug_aid, recorder_aid) {
-    (void)device_contexts_.emplace_back(device_context);
-  }
-  ~DeviceQueueDataSourceActor() override = default;
-
-  // The memory related operation interface.
-  void SendMemoryAllocReq(OpContext<DeviceTensor> *const context) override;
-  void SendMemoryFreeReq(OpContext<DeviceTensor> *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 IncreaseNewRefCounts(OpContext<DeviceTensor> *const context) override;
-
-  void SendDebugReq(OpContext<DeviceTensor> *const context) override;
-
-  const CNodePtr &data_kernel() const { return data_kernel_; }
-
- protected:
-  void Init() override;
-  void FillDataBuffer() override;
-  void SendRecorderInfo(OpContext<DeviceTensor> *const context) const override;
-
- private:
-  friend class GraphScheduler;
-  friend class ControlNodeScheduler;
-
-  // Input data kernel(for example GetNext) fetches data from device queue.
-  CNodePtr data_kernel_{nullptr};
-  KernelInfo *kernel_info_{nullptr};
-
-  bool is_dynamic_shape_;
-
-  // The kernel mem info is needed for recording info.
-  KernelLaunchAddr mem_info_;
-
-  // The kernel tensors for resize and launch.
-  std::vector<KernelTensor *> output_kernel_tensors_;
-
-  // The stream resource of the Actor to launch kernel.
-  void *stream_{nullptr};
-};
-
 // The class represents that the data source is host queue.
 class HostQueueDataSourceActor : public DataSourceActor {
  public:
@@ -133,11 +86,11 @@ 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 IncreaseNewRefCounts(OpContext<DeviceTensor> *const context) override;
+  void OnMemoryAllocFinish(OpContext<KernelTensor> *const context) override;
+  void IncreaseNewRefCounts(OpContext<KernelTensor> *const context) override;
 
   size_t FetchNodePosition(const KernelWithIndex &node) const override;
   KernelWithIndex FetchNode(size_t node_position) const;
@@ -149,7 +102,7 @@ class HostQueueDataSourceActor : public DataSourceActor {
   void FillDataBuffer() override;
 
   void AddCopyDataCallBack(bool enable_async_copy, const mindspore::tensor::TensorPtrList &host_tensors,
-                           const std::vector<mindspore::runtime::DeviceTensor *> &device_tensors);
+                           const std::vector<mindspore::runtime::KernelTensorPtr> &kernel_tensors);
 
  private:
   friend class GraphScheduler;
@@ -173,7 +126,6 @@ class HostQueueDataSourceActor : public DataSourceActor {
 };
 
 using DataSourceActorPtr = std::shared_ptr<DataSourceActor>;
-using DeviceQueueDSActorPtr = std::shared_ptr<DeviceQueueDataSourceActor>;
 using HostQueueDSActorPtr = std::shared_ptr<HostQueueDataSourceActor>;
 
 }  // namespace runtime

mindspore/include/mindspore/ccsrc/runtime/graph_scheduler/actor/debug_actor.h

@@ -49,15 +49,16 @@ class DebugActor : public ActorBase {
   void ACLDump(uint32_t device_id, const std::vector<KernelGraphPtr> &graphs, bool is_kbyk);
 
   // 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, const DeviceContext *device_context,
-                      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, const DeviceContext *device_context,
-                       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, const DeviceContext *device_context,
+                      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,
+                       const DeviceContext *device_context, OpContext<KernelTensor> *const op_context,
+                       const AID *from_aid);
 #ifdef ENABLE_DEBUGGER
-  void AscendKbkDump(const CNodePtr &cnode, const std::vector<DeviceTensor *> &input_kernel_tensors,
-                     const std::vector<DeviceTensor *> &output_kernel_tensors, const DeviceContext *device_context);
+  void AscendKbkDump(const CNodePtr &cnode, const std::vector<KernelTensor *> &input_kernel_tensors,
+                     const std::vector<KernelTensor *> &output_kernel_tensors, const DeviceContext *device_context);
 #endif
   void AscendStepStart(const std::vector<KernelGraphPtr> &graphs, std::vector<DeviceContext *> device_contexts);
 
@@ -66,11 +67,11 @@ class DebugActor : public ActorBase {
   // The debug on step begin.
   void DebugOnStepBegin(const std::vector<KernelGraphPtr> &graphs,
                         const std::vector<AnfNodePtr> &origin_parameters_order,
-                        std::vector<DeviceContext *> device_contexts, OpContext<DeviceTensor> *const op_context,
+                        std::vector<DeviceContext *> device_contexts, 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_);
   static inline uint64_t current_step{1};
 

mindspore/include/mindspore/ccsrc/runtime/graph_scheduler/actor/debug_aware_actor.h

@@ -32,8 +32,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/runtime/graph_scheduler/actor/fusion/fusion_actor.h

@@ -37,9 +37,9 @@ class FusionActor : public AbstractActor {
   ~FusionActor() override = default;
 
   // The actor run when receive the input data.
-  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 actor run when receive the input control.
-  void RunOpControl(AID *const input_control, OpContext<DeviceTensor> *const context) override;
+  void RunOpControl(AID *const input_control, OpContext<KernelTensor> *const context) override;
 
   const std::vector<std::pair<AbstractActor *, size_t>> &real_input_data() const { return real_input_data_; }
   const mindspore::HashMap<std::string, std::vector<AbstractActor *>> &real_input_controls() const {

mindspore/include/mindspore/ccsrc/runtime/graph_scheduler/actor/kernel_actor.h

@@ -1,5 +1,5 @@
 /**
- * Copyright 2021-2023 Huawei Technologies Co., Ltd
+ * Copyright 2021-2024 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.
@@ -40,7 +40,9 @@ namespace runtime {
 using mindspore::device::DeviceContext;
 using mindspore::device::KernelInfo;
 using mindspore::kernel::Address;
+using mindspore::kernel::InputDataInfo;
 using mindspore::kernel::KernelLaunchAddr;
+using mindspore::kernel::KernelLaunchInfoWithStream;
 using mindspore::kernel::KernelMod;
 using mindspore::kernel::KernelTensor;
 using mindspore::kernel::KernelTensorPtr;
@@ -49,28 +51,6 @@ using mindspore::tensor::TensorPtr;
 
 class SuperKernelActor;
 
-struct InputDataInfo {
-  InputDataInfo(const std::string &format, const ShapeVector &shape, size_t size, TypeId type_id)
-      : format_(format), shape_(shape), size_(size), type_id_(type_id) {}
-  std::string format_;
-  ShapeVector shape_;
-  size_t size_;
-  TypeId type_id_;
-};
-
-struct KernelLaunchInfo {
-  KernelLaunchInfo(std::vector<KernelTensor *> input_kernel_tensors, std::vector<KernelTensor *> output_kernel_tensors,
-                   std::vector<KernelTensor *> workspace_kernel_tensors, void *stream)
-      : input_kernel_tensors_(input_kernel_tensors),
-        output_kernel_tensors_(output_kernel_tensors),
-        workspace_kernel_tensors_(workspace_kernel_tensors),
-        stream_(stream) {}
-  std::vector<KernelTensor *> input_kernel_tensors_;
-  std::vector<KernelTensor *> output_kernel_tensors_;
-  std::vector<KernelTensor *> workspace_kernel_tensors_;
-  void *stream_;
-};
-
 // The kernel actor is used to receive the device tensors and control info to luanch kernel.
 // The processing flow is RunOpData/RunOpControl -> CheckRunningCondition -> SendMemoryAllocReq
 // -> OnMemoryAllocFinish -> LaunchKernel -> SendMemoryFreeReq -> SendOutput.
@@ -85,14 +65,15 @@ class KernelActor : public DebugAwareActor {
   ~KernelActor() 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;
   // The callback after memory alloc finished.
-  void OnMemoryAllocFinish(OpContext<DeviceTensor> *const context) override;
+  void OnMemoryAllocFinish(OpContext<KernelTensor> *const context) override;
 
   const CNodePtr &kernel() const { return kernel_; }
-  KernelLaunchInfo kernel_launch_info() const {
-    return KernelLaunchInfo(input_kernel_tensors_, output_kernel_tensors_, workspace_kernel_tensors_, stream_);
+  KernelLaunchInfoWithStream kernel_launch_info() const {
+    return KernelLaunchInfoWithStream(input_launch_tensors_, output_launch_tensors_, workspace_launch_tensors_,
+                                      stream_);
   }
   const std::set<size_t> &modifiable_ref_input_indexes() const { return modifiable_ref_input_indexes_; }
   const std::set<size_t> &modifiable_ref_output_indexes() const { return modifiable_ref_output_indexes_; }
@@ -114,66 +95,76 @@ class KernelActor : public DebugAwareActor {
   void set_enable_async_infer(bool enable_async_infer) { enable_async_infer_ = enable_async_infer; }
 
   // Really do infer shape and update kernel tensor shape.
-  virtual void ExecuteInferShapeTask(OpContext<DeviceTensor> *const context);
+  virtual void ExecuteInferShapeTask(OpContext<KernelTensor> *const context);
   // Really do resize kernel mod and update new size into output and workspace kernel tensors.
-  virtual void ExecuteResizeKernelModTask(OpContext<DeviceTensor> *const context);
+  virtual void ExecuteResizeKernelModTask(OpContext<KernelTensor> *const context);
   // Really do launch kernel with memory allocate and free.
-  virtual void ExecuteLaunchKernelTask(OpContext<DeviceTensor> *const context);
+  virtual void ExecuteLaunchKernelTask(OpContext<KernelTensor> *const context);
 
   void set_stream_send_actor(KernelActor *stream_send_actor) { stream_send_actor_ = stream_send_actor; }
 
-  void SetInputDeviceTensor(DeviceTensor *input_device_tensor, size_t input_index);
+  void SetInputDeviceTensor(const KernelTensorPtr &input_kernel_tensor, size_t input_index);
 
   // Set the memory address for the tensors which use the somas.
-  void SetSomasMemory(OpContext<DeviceTensor> *const context) const;
+  void SetSomasMemory(OpContext<KernelTensor> *const context) const;
 
   bool skip_launch_shape_related_op() const { return skip_launch_shape_related_op_; }
   void set_skip_launch_shape_related_op(bool skip_launch_shape_related_op) {
     skip_launch_shape_related_op_ = skip_launch_shape_related_op;
   }
 
-  const std::map<size_t, std::pair<DeviceTensorPtr, std::pair<const DeviceContext *, std::vector<DeviceTensor *>>>>
-    &copy_output_device_tensors() const {
-    return copy_output_device_tensors_;
+  const std::map<size_t, std::pair<KernelTensorPtr, std::pair<const DeviceContext *, std::vector<KernelTensorPtr>>>>
+    &copy_output_kernel_tensors() const {
+    return copy_output_kernel_tensors_;
+  }
+  std::vector<KernelTensor *> GetOutputDeviceTensors() { return output_launch_tensors_; }
+
+  void set_insert_input_event(bool insert_input_event) { insert_input_event_ = insert_input_event; }
+
+  void set_is_first_used_param(bool is_first_used_param, size_t index) {
+    if (index >= is_first_used_params_.size()) {
+      MS_LOG(EXCEPTION) << "Out of range for setting first used param, index: " << index
+                        << ", size: " << is_first_used_params_.size();
+    }
+    is_first_used_params_[index] = is_first_used_param;
   }
-  std::vector<DeviceTensor *> GetOutputDeviceTensors() { return output_device_tensors_; }
 
   // Reset state for UCE.
-  void ResetState() override;
+  void ResetState(OpContext<KernelTensor> *const context) override;
 
-  const std::vector<DeviceTensor *> &workspace_device_tensors() { return workspace_device_tensors_; }
-  const std::vector<DeviceTensor *> &output_device_tensors() { return output_device_tensors_; }
-  const std::vector<DeviceTensor *> &input_device_tensors() { return input_device_tensors_; }
+  const std::vector<KernelTensorPtr> &workspace_kernel_tensors() { return workspace_kernel_tensors_; }
+  const std::vector<KernelTensorPtr> &output_kernel_tensors() { return output_kernel_tensors_; }
+  const std::vector<KernelTensorPtr> &input_kernel_tensors() { return input_kernel_tensors_; }
 
  protected:
   void Init() override;
-  void Run(OpContext<DeviceTensor> *const context) override;
-  void SendRecorderInfo(OpContext<DeviceTensor> *const context) const override;
+  void Run(OpContext<KernelTensor> *const context) override;
+  void SendRecorderInfo(OpContext<KernelTensor> *const context) const override;
 
   // Do kernel launching in this method after 'PreLaunchKernel' and 'PostLaunchKernel'.
-  virtual bool LaunchKernel(OpContext<DeviceTensor> *const context, bool is_skip_launch = false);
+  virtual bool LaunchKernel(OpContext<KernelTensor> *const context, bool is_skip_launch = false);
   // Handle the ref op, set input addr to output addr.
-  virtual void UpdateRefDeviceAddress(OpContext<DeviceTensor> *const context, bool increase_ref_count);
+  virtual void UpdateRefDeviceAddress(OpContext<KernelTensor> *const context, bool increase_ref_count);
   // Execute kernel actor multi stream produre to make sure safety of memory before kernel launch.
-  void ProcessMultiStreamBeforeKernelLaunch(OpContext<DeviceTensor> *const context);
+  void ProcessMultiStreamBeforeKernelLaunch(OpContext<KernelTensor> *const context);
   // Execute kernel actor multi stream produre to make sure safety of memory after kernel launch.
-  void ProcessMultiStreamAfterKernelLaunch(OpContext<DeviceTensor> *const context);
+  void ProcessMultiStreamAfterKernelLaunch(OpContext<KernelTensor> *const context);
   // Update the output ref count of graph output kernel.
-  void UpdateGraphOutputRefCount(OpContext<DeviceTensor> *const context);
+  void UpdateGraphOutputRefCount(OpContext<KernelTensor> *const context);
   // Update the input device tensors to the memory free list.
-  void UpdateMemoryFreeList(OpContext<DeviceTensor> *const context);
+  void UpdateMemoryFreeList(OpContext<KernelTensor> *const context);
   // Execute infer shape, resize and launch kernel by runtime pipeline which executes by KernelAsyncInferActor,
   // KernelAsyncResizeActor and KernelAsyncLaunchActor.
-  void RunWithMultiPipeline(OpContext<DeviceTensor> *const context);
+  void RunWithMultiPipeline(OpContext<KernelTensor> *const context);
   // Execute launch kernel asynchronously in KernelAsyncLaunchActor.
-  void RunWithAsyncLaunchKernel(OpContext<DeviceTensor> *const context);
+  void RunWithAsyncLaunchKernel(OpContext<KernelTensor> *const context);
 
   // Infer shape(and type) and resize kernel mod for dynamic shape or dynamic value, and update memory size from kernel
   // mod to output/workspace device tensors.
-  void InferAndUpdateDeviceTensorSize(OpContext<DeviceTensor> *const context);
+  void InferAndUpdateDeviceTensorSize(OpContext<KernelTensor> *const context);
 
   // Infer shape(and type) and resize kernel mod.
-  void InferAndResize(OpContext<DeviceTensor> *const context);
+  void InferAndResize(OpContext<KernelTensor> *const context);
 
   // Re-Infer shape, type and resize before kernel launch in dynamic scenarios.
   void InferShapeAndType();
@@ -184,18 +175,25 @@ class KernelActor : public DebugAwareActor {
   void ResizeKernelMod();
 
   // Update input_device_tensors by input op data.
-  void UpdateInputDeviceTensor(const OpData<DeviceTensor> *input_data, OpContext<DeviceTensor> *const context);
+  void UpdateInputDeviceTensor(const OpData<KernelTensor> *input_data, OpContext<KernelTensor> *const context);
 
   // Record the output and workspace memory pointer and size to optimize memory allocate/free performance in next step.
   // Note: only use in inference case.
   void TraceDynamicMemory();
 
+  // Only aclnn kernel support no-contiguous input, so need make input contiguous.
+  void ConvertInputContiguous(OpContext<KernelTensor> *const context);
+
+  // Recover the inputs with contiguous.
+  void RecoverInputs();
+
   // The info of kernel.
   CNodePtr kernel_;
   bool is_dynamic_shape_;
   bool is_dynamic_value_;
   bool is_dynamic_type_;
   bool has_dynamic_;
+  std::vector<size_t> rw_write_index_;
   // Whether enable asynchronously infer shape and resize kernel mod by KernelInferActor and KernelResizeActor.
   bool enable_async_infer_;
   AID kernel_async_infer_aid_;
@@ -204,48 +202,53 @@ class KernelActor : public DebugAwareActor {
   KernelInfo *kernel_info_;
   KernelMod *kernel_mod_;
 
-  // The device tensors for launch.
-  std::vector<DeviceTensor *> input_device_tensors_;
-  std::vector<DeviceTensor *> output_device_tensors_;
-  std::vector<DeviceTensor *> workspace_device_tensors_;
+  // Used for set kernel tensor to resize and launch list.
+  std::vector<KernelTensor *> input_launch_tensors_;
+  std::vector<KernelTensor *> output_launch_tensors_;
+  std::vector<KernelTensor *> workspace_launch_tensors_;
 
-  std::vector<DeviceTensor *> max_ref_cnt_output_list_;
+  std::vector<KernelTensorPtr> max_ref_cnt_output_list_;
 
   // The input kernel tensors for infer shape.
   std::vector<abstract::AbstractBasePtr> input_kernel_tensors_for_infer_;
-  // The kernel tensors for resize and launch.
-  std::vector<KernelTensor *> input_kernel_tensors_;
-  std::vector<KernelTensor *> output_kernel_tensors_;
-  std::vector<KernelTensor *> workspace_kernel_tensors_;
+  // The kernel tensors for input, output and workspace.
+  std::vector<KernelTensorPtr> input_kernel_tensors_;
+  std::vector<KernelTensorPtr> output_kernel_tensors_;
+  std::vector<KernelTensorPtr> workspace_kernel_tensors_;
 
   // 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 kernel launch needs.
   // And if the kernel has a ref input and output, the ptr should be set into the output device addresses.
-  std::vector<DeviceTensorPtr> copy_input_device_tensors_;
+  std::vector<KernelTensorPtr> copy_input_kernel_tensors_;
   // This vector record the heter input device tensor which is the source of copy input device tensors, and the
   // size of this vector is same to copy input device tensors. It is used to free memory of input, when the pre
   // input is not empty, and the input should be free, the pre device tensors should be free too.
-  std::vector<DeviceTensor *> pre_input_device_tensors_;
-  std::map<size_t, std::pair<DeviceTensorPtr, std::pair<const DeviceContext *, std::vector<DeviceTensor *>>>>
-    copy_output_device_tensors_;
+  std::vector<KernelTensorPtr> pre_input_kernel_tensors_;
+  std::map<size_t, std::pair<KernelTensorPtr, std::pair<const DeviceContext *, std::vector<KernelTensorPtr>>>>
+    copy_output_kernel_tensors_;
   // Real data info that kernel launch needs, used to check the consistency of received input data.
   std::vector<std::shared_ptr<InputDataInfo>> real_input_data_infos_;
 
+  // Store the tensor generated by ConvertInputContiguous.
+  std::vector<KernelTensorPtr> contiguous_tensors_;
+  // Store the input infos for recover after launch.
+  std::map<size_t, KernelTensorPtr> temp_input_kernel_tensors_;
+
   // The device tensors for memory alloc and free.
   // output + workspace
-  std::vector<DeviceTensor *> memory_alloc_list_;
+  std::vector<KernelTensorPtr> memory_alloc_list_;
   // input + output + workspace
-  std::vector<DeviceTensor *> memory_free_list_;
+  std::vector<KernelTensorPtr> memory_free_list_;
 
   std::vector<size_t> input_free_index_;
   std::vector<size_t> output_free_index_;
-  std::vector<DeviceTensor *> new_memory_free_list_;
+  std::vector<KernelTensorPtr> new_memory_free_list_;
 
   // depend shape input list
   std::vector<bool> depend_shape_input_list_;
   // The device tensor of external reference is not the real data of this kernel, but need add to the
   // memory_free_list_.
-  std::vector<DeviceTensor *> external_reference_tensors_;
+  std::vector<KernelTensorPtr> external_reference_tensors_;
 
   // The information used for integration of dynamic and static memory.
   SomasInfo *somas_info_;
@@ -259,13 +262,16 @@ class KernelActor : public DebugAwareActor {
   bool is_stream_recv_actor_{false};
   // Flag for indicating if current actor is multi-thread safe, which was generate at compile time.
   bool is_multi_stream_safe_{false};
-  // Record kernel actor weight input for input optimize.
+  // Flag for record weight.
   std::vector<bool> is_weight_;
+  // Flag for aclop or reshape that does not support non-contiguous input.
+  bool need_check_tensor_contiguous_{false};
+  // Flag for kernel actor should insert event for parameter.
+  bool insert_input_event_{false};
 
  protected:
   friend class GraphScheduler;
   friend class ControlNodeScheduler;
-  friend class InlineControlFlowScheduler;
   friend class SchedulerHelper;
 #ifdef ENABLE_RPC_ACTOR
   friend class RpcNodeScheduler;
@@ -280,27 +286,26 @@ class KernelActor : public DebugAwareActor {
   void InitIsMonadInput();
 
   // Fetch the device tensor for launch.
-  void FetchInputDeviceTensor(OpContext<DeviceTensor> *const context);
-  void FetchOutputDeviceTensor(OpContext<DeviceTensor> *const context);
+  void FetchInputDeviceTensor(OpContext<KernelTensor> *const context);
+  void FetchOutputDeviceTensor(OpContext<KernelTensor> *const context);
   void FetchWorkspaceDeviceTensor();
   // Need copy when the data type or format between real parameters and formal parameters are inconsistent.
-  void CopyInputDeviceTensor(DeviceTensor *device_tensor, size_t input_index, OpContext<DeviceTensor> *const context);
-  void UpdateDeviceTensorCopyStore(DeviceTensor *const new_device_tensor, DeviceTensor *const input_device_tensor,
-                                   size_t input_index);
+  void CopyInputDeviceTensor(KernelTensorPtr kernel_tensor, size_t input_index, OpContext<KernelTensor> *const context,
+                             bool parallel_dispatch_param);
   // The processing before kernel launch: update the info of kernel launch.
-  void PreLaunchKernel(OpContext<DeviceTensor> *const context);
+  void PreLaunchKernel(OpContext<KernelTensor> *const context);
   // The processing after kernel launch: 1.erase input, 2.free memory, 3.send output.
-  void PostLaunchKernel(OpContext<DeviceTensor> *const context);
+  void PostLaunchKernel(OpContext<KernelTensor> *const context);
   // Back refresh the dynamic device tensor stores that have been triggered copy.
-  void RefreshDeviceTensorCopyStore(OpContext<DeviceTensor> *const context);
+  void RefreshKernelTensorCopyStore(OpContext<KernelTensor> *const context);
 
   void *GetSomasDevicePtr(size_t offset) const;
 
   // Record mem info, because async send may free device info.
   void SetMemInfoForRdr();
   void SetShapeDependInfo();
-  void DispatchDebugActor(OpContext<DeviceTensor> *const context);
-  bool LaunchKernelWithDebug(OpContext<DeviceTensor> *const context, const bool skip_launch);
+  void DispatchDebugActor(OpContext<KernelTensor> *const context);
+  bool LaunchKernelWithDebug(OpContext<KernelTensor> *const context, const bool skip_launch);
 
   // The real input number of kernel launch.
   size_t real_input_num_;
@@ -342,6 +347,7 @@ class KernelActor : public DebugAwareActor {
   mindspore::HashMap<size_t, size_t> increase_ref_count_size_;
   std::vector<bool> is_output_kernel_;
   std::vector<bool> is_monad_input_;
+  std::vector<bool> is_first_used_params_;
   bool is_mc2_kernel_{false};
   // This flag are only valid in control flow. In inline control flow, due to the existence of switch branches, some
   // kernel actors will not be executed, and the condition switch actor controls whether to execute. It points to
@@ -349,6 +355,7 @@ class KernelActor : public DebugAwareActor {
   // it sets the flag of the branch to true to enable the actor in this branch.
   bool *is_enable_{nullptr};
   bool need_wait_pipeline_{false};
+  bool need_ref_for_storage_info_{true};
 };
 
 using KernelActorPtr = std::shared_ptr<KernelActor>;

mindspore/include/mindspore/ccsrc/runtime/graph_scheduler/actor/kernel_async_infer_actor.h

@@ -28,6 +28,7 @@
 namespace mindspore {
 namespace runtime {
 class KernelActor;
+class KernelRunner;
 
 class BACKEND_EXPORT KernelAsyncInferActor : public ActorBase {
  public:
@@ -36,7 +37,8 @@ class BACKEND_EXPORT KernelAsyncInferActor : public ActorBase {
 
   void Initialize();
 
-  void InferShape(OpContext<DeviceTensor> *const context, KernelActor *kernel_actor);
+  void InferShape(OpContext<KernelTensor> *const context, KernelActor *kernel_actor);
+  void InferShapeV2(OpContext<KernelTensor> *const context, KernelRunner *kernel_runner, bool high_perf);
 
   void Wait();