Use PassPipelineCLParser in mlir-reduce

[Chia-hungDuan]

Summary

We are able to config the reducer pass pipeline through command-line.

[Chia-hungDuan]

mlir/include/mlir/Reducer/Passes.td

37–40

I'm wondering if I could lift this to a ReductionBase, i.e.,

class ReductionBase : Pass<...> {

let options = [
   ...
]

}

ReductionTree : ReductionBase<...> {

...

}

Make ReductionTree inherits the options from base. It didn't work, I'm checking if I did anything wrong

[Chia-hungDuan]

This CL also erases the bug mentioned here, https://bugs.llvm.org/show_bug.cgi?id=48094

mlir/include/mlir/Reducer/Passes.td

37–40

Note: After checking the tblgen, it seems we don't support this feature.

[rriddle]

Nice cleanup!

mlir/include/mlir/Reducer/Passes.td

37–40

I don't know if it's necessary to share here, but if you wanted to you could define a separate list and then concat them together:

// Op's regions that don't need a terminator: requires some other traits
// so it defines a list that must be concatenated.
def SharedReductionPassOptions {
  list<Option> options = [
    Option<"TesterName", "test", "std::string", /* default */"",
           "The filename of the tester">,
    ListOption<"TesterArgs", "test-arg", "std::string",
               "llvm::cl::ZeroOrMore, llvm::cl::MiscFlags::CommaSeparated">,
  ];
}

...

def OptReduction : Pass<"opt-reduction-pass", "ModuleOp"> {
  let summary = "A reduction pass wrapper for optimization passes";

  let constructor = "mlir::createOptReductionPass()";

  let options = [
    Option<"OptPass", "opt-pass", "std::string", /* default */"",
           "The optimization pass will be run dynamically in OptReductionPass">,
  ] # SharedReductionPassOptions.options;
}

mlir/tools/mlir-reduce/OptReductionPass.cpp

18

I think this header is already transitively included.

23–24

This change goes against the style, using namespace is preferred.

68

Use explicit namespace resolution for functions:

https://llvm.org/docs/CodingStandards.html#use-namespace-qualifiers-to-implement-previously-declared-functions

mlir/tools/mlir-reduce/mlir-reduce.cpp

93

What is the GG for here? (Good Game?)

93–94

[Chia-hungDuan]

Fixes from review comments

mlir/include/mlir/Reducer/Passes.td

37–40

Thanks! First time to know # can do this!

mlir/tools/mlir-reduce/mlir-reduce.cpp

93

lol, sorry, that's my bad. Left some verification codes...

[rriddle]

mlir/include/mlir/Reducer/Passes.td

20

The option names should be camelCase, as they correspond to C++ variable names.

mlir/tools/mlir-reduce/OptReductionPass.cpp

28

nit: Drop the const, we generally don't use it in situations like this.

[jpienaar]

Nice thanks, LG with River's comments ddressed

[Chia-hungDuan]

Fix naming

mlir/include/mlir/Reducer/CMakeLists.txt

 set(LLVM_TARGET_DEFINITIONS Passes.td)
-mlir_tablegen(Passes.h.inc -gen-pass-decls)
+mlir_tablegen(Passes.h.inc -gen-pass-decls -name Reducer)
 add_public_tablegen_target(MLIRReducerIncGen)
 
 add_mlir_doc(Passes -gen-pass-doc ReducerPasses ./)

mlir/include/mlir/Reducer/OptReductionPass.h

 #include "mlir/Reducer/Tester.h"
 #include "mlir/Transforms/Passes.h"
 #include "llvm/Support/Debug.h"
 
 namespace mlir {
 
 class OptReductionPass : public OptReductionBase<OptReductionPass> {
 public:
-  OptReductionPass(const Tester &test, MLIRContext *context,
-                   std::unique_ptr<Pass> optPass);
+  OptReductionPass() = default;
 
-  OptReductionPass(const OptReductionPass &srcPass);
+  OptReductionPass(const OptReductionPass &srcPass) = default;
 
   /// Runs the pass instance in the pass pipeline.
   void runOnOperation() override;
-
-private:
-  // Points to the context to be used in the pass manager.
-  MLIRContext *context;
-
-  // This is used to test the interesting behavior of the transformed module.
-  const Tester &test;
-
-  // Points to the mlir-opt pass to be called.
-  std::unique_ptr<Pass> optPass;
 };
 
 } // end namespace mlir
 
 #endif

mlir/include/mlir/Reducer/Passes.h

+//===- Passes.h - Reducer Pass Construction and Registration ----*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+#ifndef MLIR_REDUCER_PASSES_H
+#define MLIR_REDUCER_PASSES_H
+
+#include "mlir/Pass/Pass.h"
+#include "mlir/Reducer/OptReductionPass.h"
+#include "mlir/Reducer/ReductionTreePass.h"
+
+namespace mlir {
+
+std::unique_ptr<Pass> createReductionTreePass();
+
+std::unique_ptr<Pass> createOptReductionPass();
+
+/// Generate the code for registering reducer passes.
+#define GEN_PASS_REGISTRATION
+#include "mlir/Reducer/Passes.h.inc"
+
+} // end namespace mlir
+
+#endif // MLIR_REDUCER_PASSES_H

mlir/include/mlir/Reducer/Passes.td

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_REDUCER_PASSES
 #define MLIR_REDUCER_PASSES
 
 include "mlir/Pass/PassBase.td"
 
+def CommonReductionPassOptions {
+  list<Option> options = [
+    Option<"testerName", "test", "std::string", /* default */"",
+           "The filename of the tester">,
+    ListOption<"testerArgs", "test-arg", "std::string",
+               "llvm::cl::ZeroOrMore, llvm::cl::MiscFlags::CommaSeparated">,
+  ];
+}
+
 def ReductionTree : Pass<"reduction-tree", "ModuleOp"> {
   let summary = "A general reduction tree pass for the MLIR Reduce Tool";
+
+  let constructor = "mlir::createReductionTreePass()";
+
+  let options = [
+    Option<"opReducerName", "op-reducer", "std::string", /* default */"",
+           "The OpReducer to reduce the module">,
+    Option<"traversalModeId", "traversal-mode", "unsigned",
+           /* default */"0", "The graph traversal mode">,
+  ] # CommonReductionPassOptions.options;
 }
 
 def OptReduction : Pass<"opt-reduction-pass", "ModuleOp"> {
   let summary = "A reduction pass wrapper for optimization passes";
+
+  let constructor = "mlir::createOptReductionPass()";
+
+  let options = [
+    Option<"optPass", "opt-pass", "std::string", /* default */"",
+           "The optimization pass will be run dynamically in OptReductionPass">,
+  ] # CommonReductionPassOptions.options;
 }
 
 #endif // MLIR_REDUCER_PASSES

mlir/include/mlir/Reducer/ReductionTreePass.h

 
 namespace mlir {
 
 /// This class defines the Reduction Tree Pass. It provides a framework to
 /// to implement a reduction pass using a tree structure to keep track of the
 /// generated reduced variants.
 class ReductionTreePass : public ReductionTreeBase<ReductionTreePass> {
 public:
-  ReductionTreePass(const ReductionTreePass &pass)
-      : ReductionTreeBase<ReductionTreePass>(pass), opType(pass.opType),
-        mode(pass.mode), test(pass.test) {}
-
-  ReductionTreePass(StringRef opType, TraversalMode mode, const Tester &test)
-      : opType(opType), mode(mode), test(test) {}
+  ReductionTreePass() = default;
+  ReductionTreePass(const ReductionTreePass &pass) = default;
 
   /// Runs the pass instance in the pass pipeline.
   void runOnOperation() override;
 
 private:
   template <typename IteratorType>
   ModuleOp findOptimal(ModuleOp module, std::unique_ptr<OpReducer> reducer,
                        ReductionNode *node);
-
-  /// The name of operation that we will try to remove.
-  StringRef opType;
-
-  TraversalMode mode;
-
-  /// This is used to test the interesting behavior of the reduction nodes in
-  /// the tree.
-  const Tester &test;
 };
 
 } // end namespace mlir
 
 #endif

mlir/test/mlir-reduce/dce-test.mlir

 // UNSUPPORTED: system-windows
-// RUN: mlir-reduce %s -test %S/failure-test.sh -pass-test DCE | FileCheck %s
+// RUN: mlir-reduce %s -opt-reduction-pass='opt-pass=symbol-dce test=%S/failure-test.sh' | FileCheck %s
 // This input should be reduced by the pass pipeline so that only
 // the @simple1 function remains as the other functions should be
 // removed by the dead code elimination pass.
 
 // CHECK-NOT: func private @dead_private_function
 func private @dead_private_function()
 
 // CHECK-NOT: func nested @dead_nested_function
 func nested @dead_nested_function()
 
 // CHECK-LABEL: func @simple1(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
 func @simple1(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
   "test.crashOp" () : () -> ()
   return
 }

mlir/test/mlir-reduce/multiple-function.mlir

 // UNSUPPORTED: system-windows
-// RUN: mlir-reduce %s -test %S/failure-test.sh -pass-test function-reducer | FileCheck %s
+// RUN: mlir-reduce %s -reduction-tree='op-reducer=func traversal-mode=0 test=%S/failure-test.sh' | FileCheck %s
 // This input should be reduced by the pass pipeline so that only
 // the @simple5 function remains as this is the shortest function
 // containing the interesting behavior.
 
 // CHECK-NOT: func @simple1() {
 func @simple1() {
   return
 }

mlir/test/mlir-reduce/simple-test.mlir

 // UNSUPPORTED: system-windows
-// RUN: mlir-reduce %s -test %S/test.sh -pass-test function
+// RUN: mlir-reduce %s -reduction-tree='op-reducer=func traversal-mode=0 test=%S/test.sh'
 
 func @simple1(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
   cond_br %arg0, ^bb1, ^bb2
 ^bb1:
   br ^bb3(%arg1 : memref<2xf32>)
 ^bb2:
   %0 = memref.alloc() : memref<2xf32>
   br ^bb3(%0 : memref<2xf32>)
 ^bb3(%1: memref<2xf32>):
   return
 }

mlir/tools/mlir-reduce/OptReductionPass.cpp

 //===- OptReductionPass.cpp - Optimization Reduction Pass Wrapper ---------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines the Opt Reduction Pass Wrapper. It creates a MLIR pass to
 // run any optimization pass within it and only replaces the output module with
 // the transformed version if it is smaller and interesting.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Reducer/OptReductionPass.h"
+#include "mlir/Pass/PassRegistry.h"
+#include "mlir/Reducer/Passes.h"
+#include "mlir/Reducer/Tester.h"
 
 #define DEBUG_TYPE "mlir-reduce"
 
 using namespace mlir;
 
-OptReductionPass::OptReductionPass(const Tester &test, MLIRContext *context,
-                                   std::unique_ptr<Pass> optPass)
-    : context(context), test(test), optPass(std::move(optPass)) {}
-
-OptReductionPass::OptReductionPass(const OptReductionPass &srcPass)
-    : OptReductionBase<OptReductionPass>(srcPass), test(srcPass.test),
-      optPass(srcPass.optPass.get()) {}
-
 /// Runs the pass instance in the pass pipeline.
 void OptReductionPass::runOnOperation() {
   LLVM_DEBUG(llvm::dbgs() << "\nOptimization Reduction pass: ");
-  LLVM_DEBUG(llvm::dbgs() << optPass.get()->getName() << "\nTesting:\n");
+
+  Tester test(testerName, testerArgs);
 
   ModuleOp module = this->getOperation();
   ModuleOp moduleVariant = module.clone();
-  PassManager pmTransform(context);
-  pmTransform.addPass(std::move(optPass));
+
+  PassManager passManager(module.getContext());
+  if (failed(parsePassPipeline(optPass, passManager))) {
+    LLVM_DEBUG(llvm::dbgs() << "\nFailed to parse pass pipeline");
+    return;
+  }
 
   std::pair<Tester::Interestingness, int> original = test.isInteresting(module);
+  if (original.first != Tester::Interestingness::True) {
+    LLVM_DEBUG(llvm::dbgs() << "\nThe original input is not interested");
+    return;
+  }
 
-  if (failed(pmTransform.run(moduleVariant)))
+  if (failed(passManager.run(moduleVariant))) {
+    LLVM_DEBUG(llvm::dbgs() << "\nFailed to run pass pipeline");
     return;
+  }
 
   std::pair<Tester::Interestingness, int> reduced =
       test.isInteresting(moduleVariant);
 
   if (reduced.first == Tester::Interestingness::True &&
       reduced.second < original.second) {
     module.getBody()->clear();
     module.getBody()->getOperations().splice(
         module.getBody()->begin(), moduleVariant.getBody()->getOperations());
     LLVM_DEBUG(llvm::dbgs() << "\nSuccessful Transformed version\n\n");
   } else {
     LLVM_DEBUG(llvm::dbgs() << "\nUnsuccessful Transformed version\n\n");
   }
 
   moduleVariant->destroy();
 
   LLVM_DEBUG(llvm::dbgs() << "Pass Complete\n\n");
 }
+
+std::unique_ptr<Pass> mlir::createOptReductionPass() {
+  return std::make_unique<OptReductionPass>();
+}

mlir/tools/mlir-reduce/ReductionTreePass.cpp

 // the implementation of different reduction passes in the MLIR Reduce tool. It
 // allows for custom specification of the variant generation behavior. It
 // implements methods that define the different possible traversals of the
 // reduction tree.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Reducer/ReductionTreePass.h"
+#include "mlir/Reducer/Passes.h"
 
 #include "llvm/Support/Allocator.h"
 
 using namespace mlir;
 
 static std::unique_ptr<OpReducer> getOpReducer(llvm::StringRef opType) {
   if (opType == ModuleOp::getOperationName())
     return std::make_unique<Reducer<ModuleOp>>();
   else if (opType == FuncOp::getOperationName())
     return std::make_unique<Reducer<FuncOp>>();
   llvm_unreachable("Now only supports two built-in ops");
 }
 
 void ReductionTreePass::runOnOperation() {
   ModuleOp module = this->getOperation();
-  std::unique_ptr<OpReducer> reducer = getOpReducer(opType);
+  std::unique_ptr<OpReducer> reducer = getOpReducer(opReducerName);
   std::vector<std::pair<int, int>> ranges = {
       {0, reducer->getNumTargetOps(module)}};
 
   llvm::SpecificBumpPtrAllocator<ReductionNode> allocator;
 
   ReductionNode *root = allocator.Allocate();
   new (root) ReductionNode(nullptr, ranges, allocator);
 
   ModuleOp golden = module;
-  switch (mode) {
+  switch (traversalModeId) {
   case TraversalMode::SinglePath:
     golden = findOptimal<ReductionNode::iterator<TraversalMode::SinglePath>>(
         module, std::move(reducer), root);
     break;
   default:
     llvm_unreachable("Unsupported mode");
   }
 
   if (golden != module) {
     module.getBody()->clear();
     module.getBody()->getOperations().splice(module.getBody()->begin(),
                                              golden.getBody()->getOperations());
     golden->destroy();
   }
 }
 
 template <typename IteratorType>
 ModuleOp ReductionTreePass::findOptimal(ModuleOp module,
                                         std::unique_ptr<OpReducer> reducer,
                                         ReductionNode *root) {
+  Tester test(testerName, testerArgs);
   std::pair<Tester::Interestingness, size_t> initStatus =
       test.isInteresting(module);
+
+  if (initStatus.first != Tester::Interestingness::True) {
+    LLVM_DEBUG(llvm::dbgs() << "\nThe original input is not interested");
+    return module;
+  }
+
   root->update(initStatus);
 
   ReductionNode *smallestNode = root;
   ModuleOp golden = module;
 
   IteratorType iter(root);
 
   while (iter != IteratorType::end()) {
if (result.first == Tester::Interestingness::True &&
       cloneModule->destroy();
     }
 
     ++iter;
   }
 
   return golden;
 }
+
+std::unique_ptr<Pass> mlir::createReductionTreePass() {
+  return std::make_unique<ReductionTreePass>();
+}

mlir/tools/mlir-reduce/mlir-reduce.cpp

 // up the testing environment. It  outputs the most reduced test case variant
 // after executing the reduction passes.
 //
 //===----------------------------------------------------------------------===//
 
 #include <vector>
 
 #include "mlir/InitAllDialects.h"
+#include "mlir/InitAllPasses.h"
 #include "mlir/Parser.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Pass/PassManager.h"
 #include "mlir/Reducer/OptReductionPass.h"
+#include "mlir/Reducer/Passes.h"
 #include "mlir/Reducer/Passes/OpReducer.h"
 #include "mlir/Reducer/ReductionNode.h"
 #include "mlir/Reducer/ReductionTreePass.h"
 #include "mlir/Reducer/Tester.h"
 #include "mlir/Support/FileUtilities.h"
 #include "mlir/Support/LogicalResult.h"
 #include "mlir/Transforms/Passes.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/ToolOutputFile.h"
 
 using namespace mlir;
 
 namespace mlir {
 namespace test {
 void registerTestDialect(DialectRegistry &);
 } // namespace test
 } // namespace mlir
 
 static llvm::cl::opt<std::string> inputFilename(llvm::cl::Positional,
                                                 llvm::cl::Required,
                                                 llvm::cl::desc("<input file>"));
 
 static llvm::cl::opt<std::string>
-    testFilename("test", llvm::cl::Required, llvm::cl::desc("Testing script"));
-
-static llvm::cl::list<std::string>
-    testArguments("test-args", llvm::cl::ZeroOrMore,
-                  llvm::cl::desc("Testing script arguments"));
-
-static llvm::cl::opt<std::string>
     outputFilename("o",
                    llvm::cl::desc("Output filename for the reduced test case"),
                    llvm::cl::init("-"));
 
-// TODO: Use PassPipelineCLParser to define pass pieplines in the command line.
-static llvm::cl::opt<std::string>
-    passTestSpecifier("pass-test",
-                      llvm::cl::desc("Indicate a specific pass to be tested"));
-
 // Parse and verify the input MLIR file.
 static LogicalResult loadModule(MLIRContext &context, OwningModuleRef &module,
                                 StringRef inputFilename) {
   module = parseSourceFile(inputFilename, &context);
   if (!module)
     return failure();
 
   return success();
 }
 
 int main(int argc, char **argv) {
 
   llvm::InitLLVM y(argc, argv);
 
   registerMLIRContextCLOptions();
   registerPassManagerCLOptions();
+  registerAllPasses();
+  registerReducerPasses();
+  PassPipelineCLParser parser("", "Reduction Passes to Run");
 
   llvm::cl::ParseCommandLineOptions(argc, argv,
                                     "MLIR test case reduction tool.\n");
 
   std::string errorMessage;
 
-  auto testscript = openInputFile(testFilename, &errorMessage);
-  if (!testscript)
-    llvm::report_fatal_error(errorMessage);
-
   auto output = openOutputFile(outputFilename, &errorMessage);
   if (!output)
     llvm::report_fatal_error(errorMessage);
 
   mlir::DialectRegistry registry;
   registerAllDialects(registry);
 #ifdef MLIR_INCLUDE_TESTS
   mlir::test::registerTestDialect(registry);
 #endif
   mlir::MLIRContext context(registry);
 
   mlir::OwningModuleRef moduleRef;
   if (failed(loadModule(context, moduleRef, inputFilename)))
     llvm::report_fatal_error("Input test case can't be parsed");
 
-  // Initialize test environment.
-  const Tester test(testFilename, testArguments);
-
-  if (test.isInteresting(inputFilename) != Tester::Interestingness::True)
-    llvm::report_fatal_error(
-        "Input test case does not exhibit interesting behavior");
+  auto errorHandler = [&](const Twine &msg) {
+    return emitError(UnknownLoc::get(&context)) << msg;
+  };
 
   // Reduction pass pipeline.
   PassManager pm(&context);
-
-  if (passTestSpecifier == "DCE") {
-
-    // Opt Reduction Pass with SymbolDCEPass as opt pass.
-    pm.addPass(std::make_unique<OptReductionPass>(test, &context,
-                                                  createSymbolDCEPass()));
-
-  } else if (passTestSpecifier == "function-reducer") {
-
-    // Reduction tree pass with Reducer variant generation and single path
-    // traversal.
-    pm.addPass(std::make_unique<ReductionTreePass>(
-        FuncOp::getOperationName(), TraversalMode::SinglePath, test));
-  }
+  if (failed(parser.addToPipeline(pm, errorHandler)))
+    llvm::report_fatal_error("Failed to add pipeline");
 
   ModuleOp m = moduleRef.get().clone();
 
   if (failed(pm.run(m)))
     llvm::report_fatal_error("Error running the reduction pass pipeline");
 
   m.print(output->os());
   output->keep();
 
   return 0;
 }