fix the pclint of actor

mindspore/ccsrc/runtime/graph_scheduler/actor/abstract_actor.h

@@ -43,7 +43,7 @@ class AbstractActor : public OpActor<DeviceTensor> {
         input_datas_num_(0),
         input_controls_num_(0),
         running_dependent_msg_num_(0) {}
-  virtual ~AbstractActor() = default;
+  ~AbstractActor() override = default;
 
   bool IsActive(int msg_num) override { return msg_num >= running_dependent_msg_num_ ? true : false; }
 

mindspore/ccsrc/runtime/graph_scheduler/actor/control_flow/entrance_actor.h

@@ -48,6 +48,8 @@ class EntranceActor : public ControlActor {
   void RunOpRealParameterWithBranchID(const OpRealParameterWithBranchID &real_parameter_with_branch_id,
                                       OpContext<DeviceTensor> *const context);
 
+  void SendMemoryFreeReq(OpContext<DeviceTensor> *const context) override;
+
   // Clear the data which are generated in the loop body execution.
   void ClearDataOnStepEnd(AID *const input_control, OpContext<DeviceTensor> *const context);
 
@@ -58,7 +60,6 @@ class EntranceActor : public ControlActor {
   void FetchInput(OpContext<DeviceTensor> *const context) override;
   bool CheckRunningCondition(const OpContext<DeviceTensor> *context) const override;
   void EraseInput(const OpContext<DeviceTensor> *const context) override;
-  void SendMemoryFreeReq(OpContext<DeviceTensor> *const context) override;
 
  private:
   friend class ControlNodeScheduler;

mindspore/ccsrc/runtime/graph_scheduler/actor/control_flow/stack_actor.h

@@ -45,6 +45,9 @@ class StackActor : public ControlActor {
   void RunOpData(OpData<DeviceTensor> *const input_data, OpContext<DeviceTensor> *const context) override;
   void RunOpPartial(const OpPartialPtr &partial, size_t position, OpContext<DeviceTensor> *const context) override;
   void RunOpControl(AID *const input_control, OpContext<DeviceTensor> *const context) override;
+
+  void SendMemoryFreeReq(OpContext<DeviceTensor> *const context) override;
+
   size_t input_stack_data_num() const { return input_stack_data_num_; }
   size_t input_stack_partials_num() const { return input_stack_partials_num_; }
   size_t input_stack_controls_num() const { return input_stack_controls_num_; }
@@ -54,7 +57,6 @@ class StackActor : public ControlActor {
   void FetchInput(OpContext<DeviceTensor> *const context) override;
   bool CheckRunningCondition(const OpContext<DeviceTensor> *context) const override;
   void EraseInput(const OpContext<DeviceTensor> *const context) override;
-  void SendMemoryFreeReq(OpContext<DeviceTensor> *const context) override;
 
  private:
   friend class ControlNodeScheduler;

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

@@ -44,7 +44,7 @@ class DataSourceActor : public DebugAwareActor {
   DataSourceActor(const std::string &name, KernelTransformType type, size_t buffer_capacity,
                   const AID &memory_manager_aid, const AID *debug_aid, const AID *recorder_aid)
       : DebugAwareActor(name, type, recorder_aid, memory_manager_aid, debug_aid), buffer_capacity_(buffer_capacity) {}
-  virtual ~DataSourceActor() = default;
+  ~DataSourceActor() override = default;
 
  protected:
   friend class GraphScheduler;

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

@@ -28,7 +28,7 @@ class DebugAwareActor : public MemoryAwareActor {
   explicit DebugAwareActor(const std::string &name, KernelTransformType type, const AID *recorder_aid,
                            const AID &memory_manager_aid, const AID *debug_aid)
       : MemoryAwareActor(name, type, recorder_aid, memory_manager_aid), debug_aid_(debug_aid) {}
-  virtual ~DebugAwareActor() = default;
+  ~DebugAwareActor() override = default;
 
   virtual void SendDebugReq(OpContext<DeviceTensor> *const context) {}
   virtual void OnDebugFinish(OpContext<DeviceTensor> *const context) { PostRun(context); }

mindspore/ccsrc/runtime/graph_scheduler/actor/memory_aware_actor.h

@@ -30,7 +30,7 @@ class MemoryAwareActor : public AbstractActor {
   explicit MemoryAwareActor(const std::string &name, KernelTransformType type, const AID *recorder_aid,
                             const AID &memory_manager_aid)
       : AbstractActor(name, type, recorder_aid), memory_manager_aid_(memory_manager_aid) {}
-  virtual ~MemoryAwareActor() = default;
+  ~MemoryAwareActor() override = default;
 
   virtual void SendMemoryAllocReq(OpContext<DeviceTensor> *const context) {}
   virtual void SendMemoryFreeReq(OpContext<DeviceTensor> *const context) {}

mindspore/ccsrc/runtime/graph_scheduler/actor/rpc/rpc_actor.h

@@ -52,7 +52,7 @@ class RpcActor : public KernelActor {
       : KernelActor(name, kernel, device_context, memory_manager_aid, debug_aid, recorder_aid, strategy,
                     modifiable_ref_input_indexes, modifiable_ref_output_indexes, type),
         input_inter_process_num_(0) {}
-  virtual ~RpcActor() = default;
+  ~RpcActor() override = default;
 
   // Normally, an actor's op_context is passed by its input actor, but rpc actors could be triggered by inter-process
   // arrows which do not contain op_context. So we need to set op_context manually.

mindspore/ccsrc/runtime/graph_scheduler/actor/super_kernel_actor.h

@@ -49,13 +49,14 @@ class SuperKernelActor : public DebugAwareActor {
   // The debug related operation interface.
   void SendDebugReq(OpContext<DeviceTensor> *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;
+
   const KernelGraphPtr &graph() const { return graph_; }
 
  protected:
   void Init() override;
   void Run(OpContext<DeviceTensor> *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;
 
  private:
   friend class GraphScheduler;

mindspore/ccsrc/runtime/graph_scheduler/control_node_parser.cc

@@ -67,7 +67,6 @@ KernelWithIndex FetchRealInputNode(const KernelWithIndex &node_with_index) {
   }
   MS_LOG(EXCEPTION) << "Failed to get real output from node:" << node->DebugString()
                     << " index:" << node_with_index.second;
-  return {};
 }
 
 // Fetch all the output index in the sub-abstract of abstract.
@@ -111,7 +110,6 @@ std::set<size_t> FetchRealIndexByAbstract(const AbstractBasePtr &abstract, std::
         break;
       default:
         MS_LOG(EXCEPTION) << "Invalid index:" << index << " for abstract:" << abstract->ToString();
-        break;
     }
   } else if (abstract->isa<abstract::AbstractTuple>()) {
     auto tuple_abstract = abstract->cast<abstract::AbstractTuplePtr>();
@@ -681,7 +679,6 @@ abstract::AbstractBasePtr FetchAbstractByIndex(const AbstractBasePtr &abstract,
     return FetchAbstractByIndex(sub_abstract, real_index);
   }
   MS_LOG(EXCEPTION) << "Invalid abstract index:" << index << " for abstract:" << abstract->ToString();
-  return nullptr;
 }
 
 void ControlNodeParser::Parse(const std::vector<AnfNodePtr> &control_nodes, const std::vector<KernelGraphPtr> &graphs,
@@ -1192,7 +1189,6 @@ bool ControlNodeParser::IsCallInputKernelGraphGroup(const std::string &group_nam
     }
   }
   MS_LOG(EXCEPTION) << "Invalid kernel graph group name:" << group_name;
-  return false;
 }
 
 KernelWithIndex ControlNodeParser::FetchBackendNodeByFrontNode(const KernelWithIndex &node_with_index) {

mindspore/ccsrc/runtime/graph_scheduler/graph_scheduler.cc

@@ -68,6 +68,21 @@ inline bool IsSingleOpActorSet(const ActorSet *actor_set) {
   return actor_set->kernel_actors_.size() == 1;
 }
 
+bool IsTakenOverByControlFlow(const AnfNodePtr &front_node, const KernelGraphPtr &graph,
+                              const ControlNodeParserPtr &parser) {
+  MS_EXCEPTION_IF_NULL(front_node);
+  MS_EXCEPTION_IF_NULL(graph);
+  if (common::AnfAlgo::IsCallNode(front_node)) {
+    return true;
+  }
+
+  if (parser != nullptr && parser->IsInited() && (!parser->IsSameKernelGraphGroup(front_node, graph))) {
+    return true;
+  }
+
+  return false;
+}
+
 // Convert the actors vector by the actor set.
 std::vector<AbstractActorPtr> CollectActors(const ActorSet *actor_set) {
   MS_EXCEPTION_IF_NULL(actor_set);
@@ -1354,19 +1369,15 @@ void GraphScheduler::LinkControlArrowByAutoMonad(AbstractActor *to_actor, const
     if (IsInternalParameter(real_depend_kernel, graph)) {
       auto front_output_with_index = graph->GetFrontNodeByInternalParameter(real_depend_kernel);
       MS_EXCEPTION_IF_NULL(front_output_with_index.first);
-      if (graph_output_to_actor_.count(front_output_with_index) == 0) {
-        if (common::AnfAlgo::IsCallNode(front_output_with_index.first)) {
-          continue;
-        }
-        MS_LOG(EXCEPTION) << "Can't find graph output by front node:" << front_output_with_index.first->DebugString();
-      }
-
-      if (parser != nullptr && parser->IsInited() &&
-          (!parser->IsSameKernelGraphGroup(front_output_with_index.first, graph))) {
+      if (IsTakenOverByControlFlow(front_output_with_index.first, graph, parser)) {
         MS_LOG(DEBUG) << "Skip in control flow from node:" << front_output_with_index.first->DebugString()
                       << " is not in the graph:" << graph->ToString();
         continue;
       }
+
+      if (graph_output_to_actor_.count(front_output_with_index) == 0) {
+        MS_LOG(EXCEPTION) << "Can't find graph output by front node:" << front_output_with_index.first->DebugString();
+      }
       real_depend_kernel = graph_output_to_actor_[front_output_with_index].second.first;
       MS_EXCEPTION_IF_NULL(real_depend_kernel);
       MS_LOG(INFO) << "The graph " << graph->graph_id() << " link control arrow by auto monad from internal parameter: "

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

@@ -94,8 +94,8 @@ struct OpContext {
 template <typename T>
 class OpActor : public ActorBase {
  public:
-  explicit OpActor(std::string op_name) : ActorBase(op_name) {}
-  virtual ~OpActor() = default;
+  explicit OpActor(const std::string &op_name) : ActorBase(op_name) {}
+  ~OpActor() override = default;
 
   // The op actor run when receive the input data.
   virtual void RunOpData(OpData<T> *input_data, OpContext<T> *context = nullptr) {}