fix static-check

mindspore/ccsrc/backend/kernel_compiler/akg/akg_kernel_build.cc

@@ -211,7 +211,7 @@ int32_t AkgKernelPool::Init(const std::vector<JsonNodePair> &build_args) {
   return 0;
 }
 
-int32_t AkgKernelPool::Release() {
+int32_t AkgKernelPool::Release() const {
   {
     LockMng lock(fd_);
     if (!lock.locked_) {
@@ -250,11 +250,6 @@ int32_t AkgKernelPool::Release() {
     }
   }
 
-  // Close key file
-  if (fd_ != -1) {
-    (void)close(fd_);
-  }
-
   return 0;
 }
 

mindspore/ccsrc/backend/kernel_compiler/akg/akg_kernel_build.h

@@ -81,10 +81,15 @@ class AkgKernelPool {
 
  public:
   AkgKernelPool() = default;
-  virtual ~AkgKernelPool() = default;
+  virtual ~AkgKernelPool() {
+    // Close key file
+    if (fd_ != -1) {
+      (void)close(fd_);
+    }
+  }
 
   int32_t Init(const std::vector<JsonNodePair> &build_args);
-  int32_t Release();
+  int32_t Release() const;
   int32_t FetchKernels(std::set<size_t> *out);
   int32_t UpdateAndWait(const std::set<size_t> &ids);
 

mindspore/ccsrc/backend/optimizer/graph_kernel/add_atomic_clean.cc

@@ -517,6 +517,12 @@ void AtomicCleanInsertter::ProcessOriginCNodeUser(const KernelGraphPtr &main_gra
   }
 }
 
+void AtomicCleanInsertter::UpdateAtomicAddInfo(const AtomicAddInfo &atomic_add_info) {
+  atomic_add_node_ = atomic_add_info.atomic_add_node;
+  reduce_real_output_index_ = atomic_add_info.reduce_real_output_index;
+  real_output_num_ = atomic_add_info.real_output_num;
+}
+
 void AtomicCleanInsertter::InsertAtomicClean(const KernelGraphPtr &main_graph, const AnfNodePtr &anf_node,
                                              const FuncGraphManagerPtr &mng) {
   auto origin_composite_node = anf_node->cast<CNodePtr>();
@@ -577,12 +583,10 @@ bool AtomicCleanInsertter::Run(const FuncGraphPtr &func_graph) {
     if (!atomic_add_checker->Check(node) || !IsExistStructuralObstacle(kernel_graph, node, mng)) {
       continue;
     }
+    changed = true;
     auto atomic_add_info = atomic_add_checker->GetAtomicAddInfo();
-    atomic_add_node_ = atomic_add_info.atomic_add_node;
-    reduce_real_output_index_ = atomic_add_info.reduce_real_output_index;
-    real_output_num_ = atomic_add_info.real_output_num;
+    UpdateAtomicAddInfo(atomic_add_info);
     InsertAtomicClean(kernel_graph, node, mng);
-    changed = true;
   }
 
   if (changed) {

mindspore/ccsrc/backend/optimizer/graph_kernel/add_atomic_clean.h

@@ -86,7 +86,7 @@ class AtomicCleanInsertter : public opt::Pass {
   void ProcessOriginCNodeUser(const KernelGraphPtr &main_graph, const AnfNodePtr &composite_node,
                               const AnfNodePtr &broadcast_to_node, const AnfNodePtr &update_state_node,
                               const FuncGraphManagerPtr &mng);
-
+  void UpdateAtomicAddInfo(const AtomicAddInfo &info);
   CNodePtr atomic_add_node_{nullptr};
   size_t reduce_real_output_index_{0};
   size_t real_output_num_{0};

mindspore/ccsrc/backend/optimizer/graph_kernel/arithmetic_simplify.cc

@@ -389,7 +389,7 @@ class ExtraReduce1PatternTree : public PatternTree {
         if (st.find(n) != st.end()) {
           shift++;
         } else {
-          mp[SizeToLong(n - shift)] = n;
+          mp[n - shift] = n;
         }
       }
       std::for_each(first_axis.begin(), first_axis.end(), [&axis_set](auto &i) { axis_set.insert(i); });

mindspore/ccsrc/backend/optimizer/graph_kernel/expanders/standardnormal.cc

@@ -24,7 +24,7 @@ class StandardNormal : public OpExpander {
  public:
   StandardNormal() {
     std::initializer_list<std::string> attrs{"seed", "seed2"};
-    validators_.emplace_back(std::make_unique<CheckAttr>(attrs));
+    (void)validators_.emplace_back(std::make_unique<CheckAttr>(attrs));
   }
   ~StandardNormal() {}
   NodePtrList Expand() override {

mindspore/ccsrc/backend/optimizer/graph_kernel/graph_kernel_helper.cc

@@ -971,4 +971,19 @@ std::vector<PrimitivePtr> GetValidOps(
   }
   return valid_ops;
 }
+
+FuncGraphManagerPtr GetFuncGraphManager(const FuncGraphPtr &func_graph) {
+  MS_EXCEPTION_IF_NULL(func_graph);
+  FuncGraphManagerPtr manager = func_graph->manager();
+  if (manager == nullptr) {
+    manager = Manage(func_graph, true);
+    func_graph->set_manager(manager);
+  }
+  return manager;
+}
+
+void UpdateMng(FuncGraphManagerPtr mng, const FuncGraphPtr &func_graph) {
+  mng->RemoveRoots();
+  mng->KeepRoots({func_graph});
+}
 }  // namespace mindspore::graphkernel

mindspore/ccsrc/backend/optimizer/graph_kernel/graph_kernel_helper.h

@@ -142,5 +142,10 @@ void EliminateRedundantParameters(const FuncGraphPtr &func_graph, AnfNodePtrList
 
 std::vector<PrimitivePtr> GetValidOps(
   const std::vector<std::tuple<std::string, unsigned int, PrimitivePtr>> &ops_with_level, unsigned int level);
+
+// return a func_graph's manager
+FuncGraphManagerPtr GetFuncGraphManager(const FuncGraphPtr &func_graph);
+
+void UpdateMng(FuncGraphManagerPtr mng, const FuncGraphPtr &func_graph);
 }  // namespace mindspore::graphkernel
 #endif  // MINDSPORE_CCSRC_BACKEND_OPTIMIZER_GRAPH_KERNEL_GRAPH_KERNEL_HELPER_H_

mindspore/ccsrc/backend/optimizer/graph_kernel/model/op_node.cc

@@ -127,11 +127,11 @@ tensor::TensorPtr CalcByOperator(const NodePtrList &inputs, const std::string &o
     {"Sub", [](const std::vector<TM> &n) { return n[0] - n[1]; }},
     {"Mul", [](const std::vector<TM> &n) { return n[0] * n[1]; }},
     {"RealDiv", [](const std::vector<TM> &n) { return n[0] / n[1]; }},
-    {"Neg", [](const std::vector<TM> &n) { return -n[0]; }},
+    {"Neg", [](const std::vector<TM> &n) { return TM(0) - n[0]; }},
     {"Reciprocal", [](const std::vector<TM> &n) { return TM(1) / n[0]; }},
     {"Log", [](const std::vector<TM> &n) { return log(n[0]); }},
     {"Exp", [](const std::vector<TM> &n) { return exp(n[0]); }},
-    {"Abs", [](const std::vector<TM> &n) { return n[0] < TM(0) ? (-n[0]) : n[0]; }},
+    {"Abs", [](const std::vector<TM> &n) { return n[0] < TM(0) ? (TM(0) - n[0]) : n[0]; }},
     {"Sqrt", [](const std::vector<TM> &n) { return sqrt(n[0]); }},
     {"Rsqrt", [](const std::vector<TM> &n) { return TM(1) / sqrt(n[0]); }},
   };
@@ -543,7 +543,7 @@ void ComplexOp::CheckType(const NodePtrList &inputs, const DAttrs &attrs) {
   }
 }
 
-DShape StandardNormalOp::InferShape(const NodePtrList &inputs, const DAttrs &attrs) {
+DShape StandardNormalOp::InferShape(const NodePtrList &, const DAttrs &attrs) {
   CHECK_ATTR(attrs, "shape");
   return GetListInt(attrs.find("shape")->second);
 }

mindspore/ccsrc/backend/optimizer/graph_kernel/parallel_fusion.cc

@@ -419,7 +419,7 @@ OrderedMap<AnfNodePtr, NodeRelation> ParallelOpFusion::GenAnalysisGraph(const An
   OrderedMap<AnfNodePtr, NodeRelation> node_rels;
   auto get_info = [&node_rels](const AnfNodePtr &node) {
     if (node_rels.count(node) == 0) {
-      node_rels.insert({node, NodeRelation()});
+      (void)node_rels.emplace(node, NodeRelation());
     }
     return &(node_rels[node]);
   };

mindspore/ccsrc/backend/optimizer/graph_kernel/reorder_ops.cc

@@ -24,6 +24,7 @@
 #include "utils/log_adapter.h"
 #include "backend/session/anf_runtime_algorithm.h"
 #include "debug/anf_ir_dump.h"
+#include "backend/optimizer/graph_kernel/graph_kernel_helper.h"
 
 namespace mindspore::graphkernel {
 namespace {
@@ -324,12 +325,7 @@ bool ReorderOps::ReorderCastTypeInsensitive(const FuncGraphPtr &func_graph) {
   // Limitation: Assuming the type insensitive node will not change the type of input nodes, otherwise it can be seen
   //   as another cast node in some sense, such as LessEqual operator, which performs on two inputs and output a
   //   a boolean result.
-  MS_EXCEPTION_IF_NULL(func_graph);
-  auto mng = func_graph->manager();
-  if (mng == nullptr) {
-    mng = Manage(func_graph, true);
-    func_graph->set_manager(mng);
-  }
+  auto mng = GetFuncGraphManager(func_graph);
   bool changed = false;
   auto todos = TopoSort(func_graph->get_return());
   for (const auto &anf_node : todos) {
@@ -351,13 +347,7 @@ bool ReorderOps::ReorderCastTypeInsensitive(const FuncGraphPtr &func_graph) {
 }
 
 bool ReorderOps::Run(const FuncGraphPtr &func_graph) {
-  MS_EXCEPTION_IF_NULL(func_graph);
-  auto mng = func_graph->manager();
-  if (mng == nullptr) {
-    mng = Manage(func_graph, true);
-    func_graph->set_manager(mng);
-  }
-
+  auto mng = GetFuncGraphManager(func_graph);
   bool changed = false;
   auto todos = TopoSort(func_graph->get_return());
   for (const auto &anf_node : todos) {

mindspore/ccsrc/backend/optimizer/graph_kernel/transform_op_optimizer.cc

@@ -242,7 +242,7 @@ class TransformOp {
 };
 
 bool IsFlexibleOp(const NodePtr &node) {
-  static std::set<std::string> format_flexible_ops = {
+  static const std::set<std::string> format_flexible_ops = {
     "Abs",  "Add",     "Sub",     "Mul",   "Round",   "Cast",         "Neg",  "Exp",       "Log",
     "Pow",  "Minimum", "Maximum", "Rsqrt", "Sqrt",    "Reciprocal",   "Tanh", "Sin",       "Cos",
     "Asin", "ACos",    "RealDiv", "Equal", "Greater", "GreaterEqual", "Less", "LessEqual", "Sign"};

mindspore/ccsrc/backend/optimizer/graph_kernel/uss_atomic_add.cc

@@ -68,10 +68,8 @@ bool UssAtomicAdd::Run(const FuncGraphPtr &func_graph) {
     if (!atomic_add_checker->Check(node)) {
       continue;
     }
-    auto atomic_add_info = atomic_add_checker->GetAtomicAddInfo();
-    atomic_add_node_ = atomic_add_info.atomic_add_node;
-    reduce_real_output_index_ = atomic_add_info.reduce_real_output_index;
-    real_output_num_ = atomic_add_info.real_output_num;
+    auto info = atomic_add_checker->GetAtomicAddInfo();
+    UpdateAtomicAddInfo(info);
     InsertAtomicClean(kernel_graph, node, mng);
     changed = true;
   }

mindspore/ccsrc/utils/context/graph_kernel_flags.cc

@@ -85,7 +85,7 @@ class FlagRegister {
   ~FlagRegister() = default;
 
   template <typename T>
-  void AddFlag(std::string flag_name, T *flag_var, T default_value = T()) {
+  void AddFlag(const std::string &flag_name, T *const flag_var, T default_value = T()) const {
     auto iter = flag_map_.find(flag_name);
     if (iter != flag_map_.end()) {
       T var;