Implemented first version of systolic array time loop transform

Author: Fiwo735

include/phism/mlir/Transforms/Passes.h

@@ -25,7 +25,7 @@ std::unique_ptr<mlir::OperationPass<mlir::ModuleOp>> createLiftMemRefSubviewPass
 std::unique_ptr<mlir::OperationPass<mlir::ModuleOp>> createSCoPDecompositionPass();
 std::unique_ptr<mlir::OperationPass<mlir::ModuleOp>> createInlineSCoPAffinePass();
 std::unique_ptr<mlir::OperationPass<mlir::ModuleOp>> createEmitHLSPass();
-std::unique_ptr<mlir::OperationPass<mlir::ModuleOp>> createSystolicArraySPass();
+std::unique_ptr<mlir::OperationPass<mlir::ModuleOp>> createSystolicArrayTimeLoopPass();
 
 /// Generate the code for registering passes.
 #define GEN_PASS_REGISTRATION

include/phism/mlir/Transforms/Passes.td

@@ -143,12 +143,12 @@ def EmitHLSPass : Pass<"emit-hls", "::mlir::ModuleOp"> {
   ];
 }
 
-def SystolicArrayPass : Pass<"systolic-array", "::mlir::ModuleOp"> {
+def SystolicArrayTimeLoopPass : Pass<"systolic-array-time-loop", "::mlir::ModuleOp"> {
   let summary = "TODO";
   let description = [{ 
     TODO
   }];
-  let constructor = "phism::createSystolicArraySPass()";
+  let constructor = "phism::createSystolicArrayTimeLoopPass()";
   let options = [
     Option<"fileName", "file-name", "std::string", /*default=*/"", "The output code">
   ];

include/phism/mlir/Transforms/PhismTransforms.h

@@ -15,7 +15,7 @@ void registerFoldIfPasses();
 void registerAllPhismPasses();
 // void registerDependenceAnalysisPasses();
 void registerEmitHLSPass();
-void registerSystolicArrayPass();
+void registerSystolicArrayTimeLoopPass();
 } // namespace phism
 
 #endif

lib/mlir/Transforms/CMakeLists.txt

@@ -14,7 +14,7 @@ add_mlir_library(PhismTransforms
   SCoPDecomposition.cc
   LoadSwitch.cc
   EmitHLS.cc
-  SystolicArray.cc
+  SystolicArrayTimeLoop.cc
   Utils.cc
 
   ADDITIONAL_HEADER_DIRS

lib/mlir/Transforms/PhismTransforms.cc

@@ -30,7 +30,7 @@ void registerAllPhismPasses() {
   registerInlineSCoPAffinePass();
   registerLoadSwitchPass();
   registerEmitHLSPass();
-  registerSystolicArrayPass();
+  registerSystolicArrayTimeLoopPass();
 }
 
 } // namespace phism

lib/mlir/Transforms/SystolicArray.cc …mlir/Transforms/SystolicArrayTimeLoop.cclib/mlir/Transforms/SystolicArray.cc renamed to lib/mlir/Transforms/SystolicArrayTimeLoop.cc lib/mlir/Transforms/SystolicArray.cc renamed to lib/mlir/Transforms/SystolicArrayTimeLoop.cc

@@ -1,4 +1,4 @@
-//===- SystolicArray.cc ----------------------------------------------------===//
+//===- SystolicArrayTimeLoop.cc ----------------------------------------------------===//
 //
 // This file implements passes that TODO
 //
@@ -38,15 +38,15 @@ using namespace mlir;
 using namespace llvm;
 using namespace phism;
 
-#define DEBUG_TYPE "systolic-array"
+#define DEBUG_TYPE "systolic-array-time-loop"
 
 //----------------------------------------------------------------------------//
-// SystolicArrayPass:
+// SystolicArrayTimeLoopPass:
 // * TODO
 //----------------------------------------------------------------------------//
 
 namespace {
-struct SystolicArrayPipelineOptions : public mlir::PassPipelineOptions<SystolicArrayPipelineOptions> {
+struct SystolicArrayTimeLoopPipelineOptions : public mlir::PassPipelineOptions<SystolicArrayTimeLoopPipelineOptions> {
   Option<std::string> fileName{
     *this, "file-name",
     llvm::cl::desc("The output HLS code")
@@ -90,35 +90,69 @@ static int countSubstring(std::string pat, std::string txt) {
   return res;
 }
 
+static mlir::FuncOp createPE(AffineForOp affine_for_op) {
+  LLVM_DEBUG(dbgs() << "op name to create PE from: " << affine_for_op << "\n");
+
+  // mlir::FuncOp PE_func_op = mlir::FuncOp
+
+  // return PE_func_op
+}
+
+template <typename OpType>
+static bool contains(Block &block) {
+  for (auto &op : block) {
+    if (dyn_cast<OpType>(op)) {
+      return true;
+    }
+  }
+  return false;
+}
+
 
 namespace {
-class SystolicArrayPass : public phism::SystolicArrayPassBase<SystolicArrayPass> {
+class SystolicArrayTimeLoopPass : public phism::SystolicArrayTimeLoopPassBase<SystolicArrayTimeLoopPass> {
 public:
 
   std::string fileName = "";
 
-  SystolicArrayPass() = default;
-  SystolicArrayPass(const SystolicArrayPipelineOptions & options)
+  SystolicArrayTimeLoopPass() = default;
+  SystolicArrayTimeLoopPass(const SystolicArrayTimeLoopPipelineOptions & options)
     : fileName(!options.fileName.hasValue() ? "" : options.fileName.getValue()){
   }
 
   void runOnOperation() override {
     ModuleOp m = getOperation();
-    //TODO
+
+    SmallVector<mlir::AffineForOp> to_create_PE;
+    m.walk([&](mlir::AffineForOp op) {
+      LLVM_DEBUG(dbgs() << "op name: " << op << "\n");
+      // TODO find a proper way of determining time loops from polyhedral analysis
+      bool contains_affine_for = contains<AffineForOp>(*op.getBody());
+      LLVM_DEBUG(dbgs() << "Op contains more AffineForOp inside?: " << contains_affine_for << "\n");
+      if (!contains_affine_for) {
+        to_create_PE.push_back(op);
+      }
+    });
+
+    for (mlir::AffineForOp op : to_create_PE) {
+      createPE(op);
+    }
+
+    
   }
 };
 } // namespace
 
 std::unique_ptr<mlir::OperationPass<mlir::ModuleOp>>
-phism::createSystolicArraySPass() {
-  return std::make_unique<SystolicArrayPass>();
+phism::createSystolicArrayTimeLoopPass() {
+  return std::make_unique<SystolicArrayTimeLoopPass>();
 }
 
-void phism::registerSystolicArrayPass() {
-  PassPipelineRegistration<SystolicArrayPipelineOptions>(
-    "systolic-array", "Systolic array TODO.",
-    [](OpPassManager &pm, const SystolicArrayPipelineOptions &options) {
-      pm.addPass(std::make_unique<SystolicArrayPass>(options));
+void phism::registerSystolicArrayTimeLoopPass() {
+  PassPipelineRegistration<SystolicArrayTimeLoopPipelineOptions>(
+    "systolic-array-time-loop", "Systolic array time loop TODO.",
+    [](OpPassManager &pm, const SystolicArrayTimeLoopPipelineOptions &options) {
+      pm.addPass(std::make_unique<SystolicArrayTimeLoopPass>(options));
     }
   );
 }

pyphism/polybench/pb_flow.py

@@ -930,7 +930,7 @@ def emit_HLS(self):
         src_file, self.cur_file = self.cur_file, self.cur_file.replace(
             ".mlir", ".cpp"
         )
-        log_file = self.cur_file.replace(".cpp", ".log")
+        log_file = self.cur_file.replace(".cpp", ".cpp.log")
 
         args = [
             self.get_program_abspath("phism-opt"),
@@ -985,12 +985,17 @@ def check_if_systolic_array_possible(self):
     def post_poly(self):
         return (
             # Systolic array possible so use corresponding transforms
-            self.sanity_check() #
-            .systolic_array_transform()
-            # .systolic_array_transform2()
-            # .systolic_array_transform3()
-            # .systolic_array_transform4()
+            self.sanity_check()
+            .constant_args()
+            .sanity_check()
+            .loop_transforms()
+            .sanity_check()
+            .array_partition()
+            .sanity_check(no_diff=True)
+            .scop_stmt_inline()
             .sanity_check(no_diff=True)
+            .systolic_array_time_loop_transform()
+            .sanity_check() #TODO diff or no diff?
 
         ) if self.check_if_systolic_array_possible() else (
             # Systolic array not possible so use default transforms
@@ -1005,19 +1010,17 @@ def post_poly(self):
             .sanity_check(no_diff=True)
         )
 
-    def systolic_array_transform(self):
+    def systolic_array_time_loop_transform(self):
         src_file, self.cur_file = self.cur_file, self.cur_file.replace(
-            ".mlir", ".sa.mlir"
+            ".mlir", ".sat.mlir"
         )
         log_file = self.cur_file.replace(".mlir", ".log")
 
-        # 3 TODO implement a dummy pass in SystolicArray.cc
-        # 4 TODO understand the differences in AutoSA generated C code and Polsca to implement a proper transform
         args = [
             self.get_program_abspath("phism-opt"),
             src_file,
-            f'-systolic-array',
-            "-debug-only=systolic-array",
+            f'-systolic-array-time-loop',
+            "-debug-only=systolic-array-time-loop",
         ]
 
         self.run_command(
@@ -1029,6 +1032,29 @@ def systolic_array_transform(self):
         )
 
         return self
+    
+    def systolic_array_space_loop_transform(self):
+        src_file, self.cur_file = self.cur_file, self.cur_file.replace(
+            ".mlir", ".sas.mlir"
+        )
+        log_file = self.cur_file.replace(".mlir", ".log")
+
+        # args = [
+        #     self.get_program_abspath("phism-opt"),
+        #     src_file,
+        #     f'-systolic-array',
+        #     "-debug-only=systolic-array",
+        # ]
+
+        # self.run_command(
+        #     cmd=" ".join(args),
+        #     shell=True,
+        #     stderr=open(log_file, "w"),
+        #     stdout=open(self.cur_file, "w"),
+        #     env=self.env,
+        # )
+
+        return self
 
 
     def run_command(