fix comments

Author: BRUCE11111

include/gc/Analysis/VectorBasedFusionAnalysis.h

@@ -74,19 +74,25 @@ class VectorFusionBase {
   func::FuncOp func;
   /// Type helper class, can help us to get operation type
   TypeHelper typehelper;
+  /// IR rewriter
+  IRRewriter *rewriter;
 
 public:
-  VectorFusionBase() = default;
-  VectorFusionBase(func::FuncOp &func, HardWareInfo &info)
-      : func(func), typehelper(info) {}
-  VectorFusionBase(VectorFusionBase &base)
-      : func(base.getFunction()), typehelper(base.getHardwareInfo()) {}
+  VectorFusionBase(func::FuncOp &func, HardWareInfo &info, IRRewriter *rewriter)
+      : func(func), typehelper(info), rewriter(rewriter) {}
+  VectorFusionBase(VectorFusionBase &base, IRRewriter *rewriter)
+      : func(base.getFunction()), typehelper(base.getHardwareInfo()),
+        rewriter(rewriter) {}
 
   /// get current function IR
   func::FuncOp &getFunction() { return func; }
   /// get current hardware info
-  HardWareInfo &getHardwareInfo() { return typehelper.getHardwareInfo(); }
-  TypeHelper &getTypeHelper() { return typehelper; }
+  HardWareInfo &getHardwareInfo() noexcept {
+    return typehelper.getHardwareInfo();
+  }
+  TypeHelper &getTypeHelper() noexcept { return typehelper; }
+  IRRewriter *getRewriter() noexcept { return rewriter; }
+  void setRewriter(IRRewriter *rewriter) noexcept { this->rewriter = rewriter; }
 };
 
 /// Group operation fusion strategy class.
@@ -132,17 +138,20 @@ class GroupOperationFusion : public VectorFusionBase {
   DenseMap<Value, Value> operandOriginalValue;
 
 public:
-  GroupOperationFusion(func::FuncOp &func, HardWareInfo &info)
-      : VectorFusionBase(func, info) {}
+  GroupOperationFusion(func::FuncOp &func, HardWareInfo &info,
+                       IRRewriter *rewriter)
+      : VectorFusionBase(func, info, rewriter) {}
 
-  GroupOperationFusion(GroupOperationFusion &strategy)
-      : VectorFusionBase(strategy.getFunction(), strategy.getHardwareInfo()),
+  GroupOperationFusion(GroupOperationFusion &strategy, IRRewriter *rewriter)
+      : VectorFusionBase(strategy.getFunction(), strategy.getHardwareInfo(),
+                         rewriter),
         opGroups(strategy.opGroups), groupMaxSteps(strategy.groupMaxSteps),
         opGroupIndexMap(strategy.opGroupIndexMap),
         opAnchorPos(strategy.opAnchorPos){};
 
-  GroupOperationFusion(GroupOperationFusion &&strategy)
-      : VectorFusionBase(strategy.getFunction(), strategy.getHardwareInfo()),
+  GroupOperationFusion(GroupOperationFusion &&strategy, IRRewriter *rewriter)
+      : VectorFusionBase(strategy.getFunction(), strategy.getHardwareInfo(),
+                         rewriter),
         opGroups(std::move(strategy.opGroups)),
         groupMaxSteps(std::move(strategy.groupMaxSteps)),
         groupBigestRankVectorType(
@@ -165,9 +174,9 @@ class GroupOperationFusion : public VectorFusionBase {
     this->getFunction() = fusion.getFunction();
     this->getHardwareInfo() = fusion.getHardwareInfo();
     this->getTypeHelper() = fusion.getTypeHelper();
+    this->setRewriter(fusion.getRewriter());
     return *this;
   };
-  GroupOperationFusion &operator=(GroupOperationFusion &&) = default;
 
   /// Get the map which contains each group vector type which has biggest
   /// rank.
@@ -275,10 +284,12 @@ class GroupOperationAnalysis {
 private:
   /// vector-based fusion related data
   GroupOperationFusion fusionStrategy;
+  IRRewriter *rewriter;
 
 public:
-  GroupOperationAnalysis(func::FuncOp &func, HardWareInfo &info)
-      : fusionStrategy(func, info) {}
+  GroupOperationAnalysis(func::FuncOp &func, HardWareInfo &info,
+                         IRRewriter *rewriter)
+      : fusionStrategy(func, info, rewriter), rewriter(rewriter) {}
   /// remove the useless operation, due to it result is not require by other
   /// operation
   void analysisEmptyGroup();
@@ -288,6 +299,8 @@ class GroupOperationAnalysis {
   GroupOperationFusion &getGroupOperationFusion() { return fusionStrategy; }
   /// running the vector-based fusion
   void run() { fusionStrategy.run(); }
+  /// get current function rewriter
+  IRRewriter *getRewriter() { return rewriter; }
 };
 } // namespace gc
 } // namespace mlir

include/gc/Transforms/TilingVector.h

@@ -1,4 +1,4 @@
-//===- TilingVector.hpp - Tiling large vector to small vector ---*- C++ -*-===//
+//===- TilingVector.h - Tiling large vector to small vector -----*- C++ -*-===//
 //
 // This file is licensed under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -343,12 +343,16 @@ class ShapeCastCanonicalizer
 class ForLoopGenerator {
 private:
   GroupOperationFusion vectorBasedFusion;
+  IRRewriter *rewriter;
 
 public:
-  ForLoopGenerator(GroupOperationFusion &fusion) : vectorBasedFusion(fusion) {}
+  ForLoopGenerator(GroupOperationFusion &fusion, IRRewriter *rewriter)
+      : vectorBasedFusion(fusion, rewriter), rewriter(rewriter) {}
 
   virtual ~ForLoopGenerator() noexcept {}
 
+  IRRewriter *getRewriter() noexcept { return rewriter; }
+
   void setVectorBaseFusion(GroupOperationFusion &vectorBasedFusion) {
     this->vectorBasedFusion = vectorBasedFusion;
   };
@@ -466,7 +470,8 @@ class LoopGeneratorImpl : public ForLoopGenerator {
   SmallVector<ShapeCastCanonicalizer, 8> shapeCastCanonicalizers;
 
 public:
-  LoopGeneratorImpl(GroupOperationFusion &fusion) : ForLoopGenerator(fusion){};
+  LoopGeneratorImpl(GroupOperationFusion &fusion, IRRewriter *rewriter)
+      : ForLoopGenerator(fusion, rewriter){};
 
   virtual ~LoopGeneratorImpl() noexcept {};
 
@@ -569,8 +574,9 @@ class GroupOperationFusionImpl : public GroupOperationAnalysis {
 
 public:
   virtual ~GroupOperationFusionImpl() = default;
-  GroupOperationFusionImpl(func::FuncOp &func, HardWareInfo &info)
-      : GroupOperationAnalysis(func, info) {}
+  GroupOperationFusionImpl(func::FuncOp &func, HardWareInfo &info,
+                           IRRewriter *rewriter)
+      : GroupOperationAnalysis(func, info, rewriter) {}
 
   void broadcastFromElements(Operation *op, size_t grpIdx);
   void scalarOperandFromElements();
@@ -632,17 +638,20 @@ class VectorOperationCanonicalizer {
   LoopGeneratorImpl loopGenerator;
   CanonicalizerKind kind;
   func::FuncOp func;
-  IRRewriter rewriter;
+  IRRewriter *rewriter;
 
 public:
   VectorOperationCanonicalizer(
-      func::FuncOp &func, HardWareInfo &info,
+      func::FuncOp &func, HardWareInfo &info, IRRewriter *rewriter,
       CanonicalizerKind kind = CanonicalizerKind::GroupOperations)
-      : fusion(func, info), loopGenerator(fusion.getGroupOperationFusion()),
-        kind(kind), rewriter(func) {}
+      : fusion(func, info, rewriter),
+        loopGenerator(fusion.getGroupOperationFusion(), rewriter), kind(kind),
+        rewriter(rewriter) {}
   virtual ~VectorOperationCanonicalizer() = default;
   /// run the vector canonicalizer for the IR
   void run();
+  /// get current funtion rewriter
+  IRRewriter *getRewriter() noexcept { return rewriter; }
 };
 } // namespace gc
 } // namespace mlir

include/gc/Transforms/Utils/VectorUtils.h

@@ -24,6 +24,14 @@
 
 namespace mlir {
 namespace gc {
+
+enum class OPPRIORITY : uint8_t {
+  FIRST = 0,
+  SECOND,
+  THIRD,
+  LAST,
+  OTHERS = 255,
+};
 /// Need to move some operations like extract_slice or insert_slice.
 /// Because those operation may interpret our analysis result. e.g.:
 /// ```
@@ -54,8 +62,8 @@ namespace gc {
 /// block.
 /// insert_slice just move them to the privious of the first operation which
 /// use it.
-void moveOpsFrontOrBack(func::FuncOp *func, MLIRContext *ctx,
-                        std::function<bool(Operation *)> &conditionalFunc);
+void moveOpsFrontOrBack(func::FuncOp *func, IRRewriter &rewriter,
+                        OPPRIORITY start, OPPRIORITY end);
 
 /// build a constant operation of index type
 Value makeIndexArithConstantOp(OpBuilder &opBuilder, const Location &loc,