[mlir][python] Include anchor op in PassManager.parse

[rkayaith]

Summary

The pipeline string must now include the pass manager's anchor op. This
makes the parse API properly roundtrip the printed form of a pass
manager.

[rkayaith]

update summary

[mehdi_amini]

Nice :)

[rkayaith]

rebase

mlir/lib/Bindings/Python/Pass.cpp

py::class_<PyPassManager>(m, "PassManager", py::module_local())
             mlirPassManagerEnableVerifier(passManager.get(), enable);
           },
           py::arg("enable"), "Enable / disable verify-each.")
       .def_static(
           "parse",
           [](const std::string &pipeline, DefaultingPyMlirContext context) {
             MlirPassManager passManager = mlirPassManagerCreate(context->get());
             PyPrintAccumulator errorMsg;
-            MlirLogicalResult status = mlirOpPassManagerAddPipeline(
+            MlirLogicalResult status = mlirParsePassPipeline(
                 mlirPassManagerGetAsOpPassManager(passManager),
                 mlirStringRefCreate(pipeline.data(), pipeline.size()),
                 errorMsg.getCallback(), errorMsg.getUserData());
             if (mlirLogicalResultIsFailure(status))
               throw SetPyError(PyExc_ValueError, std::string(errorMsg.join()));
             return new PyPassManager(passManager);
           },
           py::arg("pipeline"), py::arg("context") = py::none(),

mlir/test/Integration/Dialect/SparseTensor/python/tools/sparse_compiler.py

 #  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 contains the sparse compiler class.
 
 from mlir import execution_engine
 from mlir import ir
 from mlir import passmanager
 from typing import Sequence
 
 class SparseCompiler:
   """Sparse compiler class for compiling and building MLIR modules."""
 
   def __init__(self, options: str, opt_level: int, shared_libs: Sequence[str]):
-    pipeline = f'sparse-compiler{{{options} reassociate-fp-reductions=1 enable-index-optimizations=1}}'
+    pipeline = f'builtin.module(sparse-compiler{{{options} reassociate-fp-reductions=1 enable-index-optimizations=1}})'
     self.pipeline = pipeline
     self.opt_level = opt_level
     self.shared_libs = shared_libs
 
   def __call__(self, module: ir.Module):
     """Convenience application method."""
     self.compile(module)
 

mlir/test/Integration/Dialect/SparseTensor/taco/tools/mlir_sparse_compiler.py

 from mlir import passmanager
 from typing import Sequence
 
 
 class SparseCompiler:
   """Sparse compiler class for compiling and building MLIR modules."""
 
   def __init__(self, options: str, opt_level: int, shared_libs: Sequence[str]):
-    pipeline = f'sparse-compiler{{{options} reassociate-fp-reductions=1 enable-index-optimizations=1}}'
+    pipeline = f'builtin.module(sparse-compiler{{{options} reassociate-fp-reductions=1 enable-index-optimizations=1}})'
     self.pipeline = pipeline
     self.opt_level = opt_level
     self.shared_libs = shared_libs
 
   def __call__(self, module: ir.Module):
     """Convenience application method."""
     self.compile(module)
 

mlir/test/python/dialects/async_dialect.py

 # RUN: %PYTHON %s | FileCheck %s
 
 from mlir.ir import *
 import mlir.dialects.async_dialect
 import mlir.dialects.async_dialect.passes
 from mlir.passmanager import *
 
 def run(f):
   print("\nTEST:", f.__name__)
   f()
 
 def testAsyncPass():
   with Context() as context:
-    PassManager.parse('async-to-async-runtime')
+    PassManager.parse('any(async-to-async-runtime)')
   print('SUCCESS')
 
 # CHECK-LABEL: testAsyncPass
 #       CHECK: SUCCESS
 run(testAsyncPass)

mlir/test/python/dialects/gpu.py

 # RUN: %PYTHON %s | FileCheck %s
 
 from mlir.ir import *
 import mlir.dialects.gpu
 import mlir.dialects.gpu.passes
 from mlir.passmanager import *
 
 def run(f):
   print("\nTEST:", f.__name__)
   f()
 
 def testGPUPass():
   with Context() as context:
-    PassManager.parse('gpu-kernel-outlining')
+    PassManager.parse('any(gpu-kernel-outlining)')
   print('SUCCESS')
 
 # CHECK-LABEL: testGPUPass
 #       CHECK: SUCCESS
 run(testGPUPass)

mlir/test/python/dialects/sparse_tensor/passes.py

def run(f):
   f()
   return f
 
 
 # CHECK-LABEL: TEST: testSparseTensorPass
 @run
 def testSparseTensorPass():
   with Context() as context:
-    PassManager.parse('sparsification')
-    PassManager.parse('sparse-tensor-conversion')
+    PassManager.parse('any(sparsification)')
+    PassManager.parse('any(sparse-tensor-conversion)')
   # CHECK: SUCCESS
   print('SUCCESS')

mlir/test/python/execution_engine.py

except RuntimeError as e:
       log("Got RuntimeError: ", e)
 
 
 run(testInvalidModule)
 
 
 def lowerToLLVM(module):
   pm = PassManager.parse(
-      "convert-complex-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts")
+      "builtin.module(convert-complex-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)")
   pm.run(module)
   return module
 
 
 # Test simple ExecutionEngine execution
 # CHECK-LABEL: TEST: testInvokeVoid
 def testInvokeVoid():
   with Context():

mlir/test/python/integration/dialects/linalg/opsrun.py

 
 def transform(module, boilerplate):
   # TODO: Allow cloning functions from one module to another.
   # Atm we have to resort to string concatenation.
   ops = module.operation.regions[0].blocks[0].operations
   mod = Module.parse("\n".join([str(op) for op in ops]) + boilerplate)
 
   pm = PassManager.parse(
-      "func.func(convert-linalg-to-loops, lower-affine, " +
+      "builtin.module(func.func(convert-linalg-to-loops, lower-affine, " +
       "convert-math-to-llvm, convert-scf-to-cf, arith-expand, memref-expand), "
       + "convert-vector-to-llvm, convert-memref-to-llvm, convert-func-to-llvm," +
-      "reconcile-unrealized-casts")
+      "reconcile-unrealized-casts)")
   pm.run(mod)
   return mod
 
 
 def test_elemwise_builtin():
   with Context() as ctx, Location.unknown():
     module = Module.create()
     f32 = F32Type.get()

mlir/test/python/pass_manager.py

with Context():
     except ValueError as e:
       # CHECK: ValueError exception: {{.+}} 'not-existing-pass' does not refer to a registered pass
       log("ValueError exception:", e)
     else:
       log("Exception not produced")
 
     # A registered pass should parse successfully.
     pm = PassManager.parse("builtin.module(func.func(print-op-stats{json=false}))")
-    # CHECK: Roundtrip: builtin.module(builtin.module(func.func(print-op-stats{json=false})))
+    # CHECK: Roundtrip: builtin.module(func.func(print-op-stats{json=false}))
     log("Roundtrip: ", pm)
 run(testParseSuccess)
 
 # Verify failure on unregistered pass.
 # CHECK-LABEL: TEST: testParseFail
 def testParseFail():
   with Context():
     try:
-      pm = PassManager.parse("unknown-pass")
+      pm = PassManager.parse("any(unknown-pass)")
     except ValueError as e:
       #      CHECK: ValueError exception: MLIR Textual PassPipeline Parser:1:1: error:
       # CHECK-SAME: 'unknown-pass' does not refer to a registered pass or pass pipeline
       #      CHECK: unknown-pass
       #      CHECK: ^
       log("ValueError exception:", e)
     else:
       log("Exception not produced")
else:
       log("Exception not produced")
 run(testInvalidNesting)
 
 
 # Verify that a pass manager can execute on IR
 # CHECK-LABEL: TEST: testRun
 def testRunPipeline():
   with Context():
-    pm = PassManager.parse("print-op-stats{json=false}")
+    pm = PassManager.parse("builtin.module(print-op-stats{json=false})")
     module = Module.parse(r"""func.func @successfulParse() { return }""")
     pm.run(module)
 # CHECK: Operations encountered:
 # CHECK: builtin.module    , 1
 # CHECK: func.func      , 1
 # CHECK: func.return        , 1
 run(testRunPipeline)