[mlir][CAPI] Allow specifying pass manager anchor

[rkayaith]

Summary

This adds a new function for creating pass managers that takes an
argument for the anchor string.

[rkayaith]

description

[mehdi_amini]

I'm a bit hesitant if we should rename C API in this kind of case to make sure the build breakage is visible through the symbol name change?

[rkayaith]

I could rename it to something like mlirPassManagerCreateWithAnchor but it's a bit unfortunate, mlirPassManagerCreate feels like the "right" name. Or maybe there should be both: mlirPassManagerCreate which uses the default anchor (builtin.module for now, but should probably be changed to any) and mlirPassManagerCreateWithAnchor with the anchor argument?

And I suppose the same thing about renaming applies to D136403?

[mehdi_amini]

In D136404#3881445, @rkayaith wrote:

I could rename it to something like mlirPassManagerCreateWithAnchor but it's a bit unfortunate, mlirPassManagerCreate feels like the "right" name. Or maybe there should be both: mlirPassManagerCreate which uses the default anchor (builtin.module for now, but should probably be changed to any) and mlirPassManagerCreateWithAnchor with the anchor argument?

And I suppose the same thing about renaming applies to D136403?

Yes, I'd wait for @ftynse and @stellaraccident to chime in here.

[ftynse]

I don't have a strong opinion. We don't (yet) offer any sort of API stability guarantees at this level, so just changing it is fine. There will be a compiler error, it's not like changing the type from one pointer to another. On the other hand, having mlirPassManagerCreate to work on builtin.module sounds like a reasonable default and we can have a more verbose mlirPassManagerCreateOnOperation that also needs a more verbose argument.

[stellaraccident]

In D136404#3885547, @ftynse wrote:

I don't have a strong opinion. We don't (yet) offer any sort of API stability guarantees at this level, so just changing it is fine. There will be a compiler error, it's not like changing the type from one pointer to another. On the other hand, having mlirPassManagerCreate to work on builtin.module sounds like a reasonable default and we can have a more verbose mlirPassManagerCreateOnOperation that also needs a more verbose argument.

I concur with Alex. I have a slight preference for the mlirPassManagerCreateOnOperation approach but wouldn't insist on it.

[rkayaith]

create new function, mlirPassManagerCreateOnOperation, instead of changing the existing one

mlir/include/mlir-c/Pass.h

 DEFINE_C_API_STRUCT(MlirOpPassManager, void);
 
 #undef DEFINE_C_API_STRUCT
 
 //===----------------------------------------------------------------------===//
 // PassManager/OpPassManager APIs.
 //===----------------------------------------------------------------------===//
 
-/// Create a new top-level PassManager.
-MLIR_CAPI_EXPORTED MlirPassManager mlirPassManagerCreate(MlirContext ctx);
+/// Create a new top-level PassManager anchored on `anchorOp`.
+MLIR_CAPI_EXPORTED MlirPassManager
+mlirPassManagerCreate(MlirContext ctx, MlirStringRef anchorOp);
 
 /// Destroy the provided PassManager.
 MLIR_CAPI_EXPORTED void mlirPassManagerDestroy(MlirPassManager passManager);
 
 /// Checks if a PassManager is null.
 static inline bool mlirPassManagerIsNull(MlirPassManager passManager) {
   return !passManager.ptr;
 }

mlir/lib/Bindings/Python/Pass.cpp

 
 /// Create the `mlir.passmanager` here.
 void mlir::python::populatePassManagerSubmodule(py::module &m) {
   //----------------------------------------------------------------------------
   // Mapping of the top-level PassManager
   //----------------------------------------------------------------------------
   py::class_<PyPassManager>(m, "PassManager", py::module_local())
       .def(py::init<>([](DefaultingPyMlirContext context) {
-             MlirPassManager passManager =
-                 mlirPassManagerCreate(context->get());
+             MlirPassManager passManager = mlirPassManagerCreate(
+                 context->get(),
+                 mlirStringRefCreateFromCString("builtin.module"));
              return new PyPassManager(passManager);
            }),
            py::arg("context") = py::none(),
            "Create a new PassManager for the current (or provided) Context.")
       .def_property_readonly(MLIR_PYTHON_CAPI_PTR_ATTR,
                              &PyPassManager::getCapsule)
       .def(MLIR_PYTHON_CAPI_FACTORY_ATTR, &PyPassManager::createFromCapsule)
       .def("_testing_release", &PyPassManager::release,
            "Releases (leaks) the backing pass manager (testing)")
       .def(
           "enable_ir_printing",
           [](PyPassManager &passManager) {
             mlirPassManagerEnableIRPrinting(passManager.get());
           },
           "Enable mlir-print-ir-after-all.")
       .def(
           "enable_verifier",
           [](PyPassManager &passManager, bool enable) {
             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());
+            MlirPassManager passManager = mlirPassManagerCreate(
+                context->get(),
+                mlirStringRefCreateFromCString("builtin.module"));
             PyPrintAccumulator errorMsg;
             MlirLogicalResult status = mlirOpPassManagerAddPipeline(
                 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);

mlir/lib/CAPI/IR/Pass.cpp

 #include "mlir/Pass/PassManager.h"
 
 using namespace mlir;
 
 //===----------------------------------------------------------------------===//
 // PassManager/OpPassManager APIs.
 //===----------------------------------------------------------------------===//
 
-MlirPassManager mlirPassManagerCreate(MlirContext ctx) {
-  return wrap(new PassManager(unwrap(ctx)));
+MlirPassManager mlirPassManagerCreate(MlirContext ctx, MlirStringRef anchorOp) {
+  return wrap(new PassManager(unwrap(ctx), unwrap(anchorOp)));
 }
 
 void mlirPassManagerDestroy(MlirPassManager passManager) {
   delete unwrap(passManager);
 }
 
 MlirOpPassManager
 mlirPassManagerGetAsOpPassManager(MlirPassManager passManager) {

mlir/test/CAPI/execution_engine.c

 static void registerAllUpstreamDialects(MlirContext ctx) {
   MlirDialectRegistry registry = mlirDialectRegistryCreate();
   mlirRegisterAllDialects(registry);
   mlirContextAppendDialectRegistry(ctx, registry);
   mlirDialectRegistryDestroy(registry);
 }
 
 void lowerModuleToLLVM(MlirContext ctx, MlirModule module) {
-  MlirPassManager pm = mlirPassManagerCreate(ctx);
+  MlirPassManager pm = mlirPassManagerCreate(
+      ctx, mlirStringRefCreateFromCString("builtin.module"));
   MlirOpPassManager opm = mlirPassManagerGetNestedUnder(
       pm, mlirStringRefCreateFromCString("func.func"));
   mlirPassManagerAddOwnedPass(pm, mlirCreateConversionConvertFuncToLLVM());
   mlirOpPassManagerAddOwnedPass(
       opm, mlirCreateConversionArithToLLVMConversionPass());
   MlirLogicalResult status = mlirPassManagerRun(pm, module);
   if (mlirLogicalResultIsFailure(status)) {
     fprintf(stderr, "Unexpected failure running pass pipeline\n");

mlir/test/CAPI/pass.c

"}"));
   }
 
   // Run the print-op-stats pass on the top-level module:
   // CHECK-LABEL: Operations encountered:
   // CHECK: arith.addi        , 1
   // CHECK: func.func      , 1
   // CHECK: func.return        , 1
   {
-    MlirPassManager pm = mlirPassManagerCreate(ctx);
+    MlirPassManager pm = mlirPassManagerCreate(
+        ctx, mlirStringRefCreateFromCString("builtin.module"));
     MlirPass printOpStatPass = mlirCreateTransformsPrintOpStats();
     mlirPassManagerAddOwnedPass(pm, printOpStatPass);
     MlirLogicalResult success = mlirPassManagerRun(pm, module);
     if (mlirLogicalResultIsFailure(success)) {
       fprintf(stderr, "Unexpected failure running pass manager.\n");
       exit(EXIT_FAILURE);
     }
     mlirPassManagerDestroy(pm);
if (mlirModuleIsNull(module))
     exit(1);
 
   // Run the print-op-stats pass on functions under the top-level module:
   // CHECK-LABEL: Operations encountered:
   // CHECK: arith.addi        , 1
   // CHECK: func.func      , 1
   // CHECK: func.return        , 1
   {
-    MlirPassManager pm = mlirPassManagerCreate(ctx);
+    MlirPassManager pm = mlirPassManagerCreate(
+        ctx, mlirStringRefCreateFromCString("builtin.module"));
     MlirOpPassManager nestedFuncPm = mlirPassManagerGetNestedUnder(
         pm, mlirStringRefCreateFromCString("func.func"));
     MlirPass printOpStatPass = mlirCreateTransformsPrintOpStats();
     mlirOpPassManagerAddOwnedPass(nestedFuncPm, printOpStatPass);
     MlirLogicalResult success = mlirPassManagerRun(pm, module);
     if (mlirLogicalResultIsFailure(success))
       exit(2);
     mlirPassManagerDestroy(pm);
   }
   // Run the print-op-stats pass on functions under the nested module:
   // CHECK-LABEL: Operations encountered:
   // CHECK: arith.addf        , 1
   // CHECK: func.func      , 1
   // CHECK: func.return        , 1
   {
-    MlirPassManager pm = mlirPassManagerCreate(ctx);
+    MlirPassManager pm = mlirPassManagerCreate(
+        ctx, mlirStringRefCreateFromCString("builtin.module"));
     MlirOpPassManager nestedModulePm = mlirPassManagerGetNestedUnder(
         pm, mlirStringRefCreateFromCString("builtin.module"));
     MlirOpPassManager nestedFuncPm = mlirOpPassManagerGetNestedUnder(
         nestedModulePm, mlirStringRefCreateFromCString("func.func"));
     MlirPass printOpStatPass = mlirCreateTransformsPrintOpStats();
     mlirOpPassManagerAddOwnedPass(nestedFuncPm, printOpStatPass);
     MlirLogicalResult success = mlirPassManagerRun(pm, module);
     if (mlirLogicalResultIsFailure(success))
       exit(2);
     mlirPassManagerDestroy(pm);
   }
 
   mlirModuleDestroy(module);
   mlirContextDestroy(ctx);
 }
 
 static void printToStderr(MlirStringRef str, void *userData) {
   (void)userData;
   fwrite(str.data, 1, str.length, stderr);
 }
 
 void testPrintPassPipeline() {
   MlirContext ctx = mlirContextCreate();
-  MlirPassManager pm = mlirPassManagerCreate(ctx);
+  MlirPassManager pm = mlirPassManagerCreate(
+      ctx, mlirStringRefCreateFromCString("builtin.module"));
   // Populate the pass-manager
   MlirOpPassManager nestedModulePm = mlirPassManagerGetNestedUnder(
       pm, mlirStringRefCreateFromCString("builtin.module"));
   MlirOpPassManager nestedFuncPm = mlirOpPassManagerGetNestedUnder(
       nestedModulePm, mlirStringRefCreateFromCString("func.func"));
   MlirPass printOpStatPass = mlirCreateTransformsPrintOpStats();
   mlirOpPassManagerAddOwnedPass(nestedFuncPm, printOpStatPass);
 
void testPrintPassPipeline() {
   fprintf(stderr, "\n");
 
   mlirPassManagerDestroy(pm);
   mlirContextDestroy(ctx);
 }
 
 void testParsePassPipeline() {
   MlirContext ctx = mlirContextCreate();
-  MlirPassManager pm = mlirPassManagerCreate(ctx);
+  MlirPassManager pm = mlirPassManagerCreate(
+      ctx, mlirStringRefCreateFromCString("builtin.module"));
   // Try parse a pipeline.
   MlirLogicalResult status = mlirParsePassPipeline(
       mlirPassManagerGetAsOpPassManager(pm),
       mlirStringRefCreateFromCString(
           "builtin.module(func.func(print-op-stats{json=false}))"),
       printToStderr, NULL);
   // Expect a failure, we haven't registered the print-op-stats pass yet.
   if (mlirLogicalResultIsSuccess(status)) {
MlirPass externalPass = mlirCreateExternalPass(
         passID, name, argument, description, emptyOpName, 0, NULL,
         makeTestExternalPassCallbacks(NULL, testRunExternalPass), &userData);
 
     if (userData.constructCallCount != 1) {
       fprintf(stderr, "Expected constructCallCount to be 1\n");
       exit(EXIT_FAILURE);
     }
 
-    MlirPassManager pm = mlirPassManagerCreate(ctx);
+    MlirPassManager pm = mlirPassManagerCreate(
+        ctx, mlirStringRefCreateFromCString("builtin.module"));
     mlirPassManagerAddOwnedPass(pm, externalPass);
     MlirLogicalResult success = mlirPassManagerRun(pm, module);
     if (mlirLogicalResultIsFailure(success)) {
       fprintf(stderr, "Unexpected failure running external pass.\n");
       exit(EXIT_FAILURE);
     }
 
     if (userData.runCallCount != 1) {
MlirPass externalPass = mlirCreateExternalPass(
         makeTestExternalPassCallbacks(NULL, testRunExternalFuncPass),
         &userData);
 
     if (userData.constructCallCount != 1) {
       fprintf(stderr, "Expected constructCallCount to be 1\n");
       exit(EXIT_FAILURE);
     }
 
-    MlirPassManager pm = mlirPassManagerCreate(ctx);
+    MlirPassManager pm = mlirPassManagerCreate(
+        ctx, mlirStringRefCreateFromCString("builtin.module"));
     MlirOpPassManager nestedFuncPm =
         mlirPassManagerGetNestedUnder(pm, funcOpName);
     mlirOpPassManagerAddOwnedPass(nestedFuncPm, externalPass);
     MlirLogicalResult success = mlirPassManagerRun(pm, module);
     if (mlirLogicalResultIsFailure(success)) {
       fprintf(stderr, "Unexpected failure running external operation pass.\n");
       exit(EXIT_FAILURE);
     }
MlirPass externalPass = mlirCreateExternalPass(
                                       testRunExternalPass),
         &userData);
 
     if (userData.constructCallCount != 1) {
       fprintf(stderr, "Expected constructCallCount to be 1\n");
       exit(EXIT_FAILURE);
     }
 
-    MlirPassManager pm = mlirPassManagerCreate(ctx);
+    MlirPassManager pm = mlirPassManagerCreate(
+        ctx, mlirStringRefCreateFromCString("builtin.module"));
     mlirPassManagerAddOwnedPass(pm, externalPass);
     MlirLogicalResult success = mlirPassManagerRun(pm, module);
     if (mlirLogicalResultIsFailure(success)) {
       fprintf(stderr, "Unexpected failure running external pass.\n");
       exit(EXIT_FAILURE);
     }
 
     if (userData.initializeCallCount != 1) {
MlirPass externalPass = mlirCreateExternalPass(
                                       testRunExternalPass),
         &userData);
 
     if (userData.constructCallCount != 1) {
       fprintf(stderr, "Expected constructCallCount to be 1\n");
       exit(EXIT_FAILURE);
     }
 
-    MlirPassManager pm = mlirPassManagerCreate(ctx);
+    MlirPassManager pm = mlirPassManagerCreate(
+        ctx, mlirStringRefCreateFromCString("builtin.module"));
     mlirPassManagerAddOwnedPass(pm, externalPass);
     MlirLogicalResult success = mlirPassManagerRun(pm, module);
     if (mlirLogicalResultIsSuccess(success)) {
       fprintf(
           stderr,
           "Expected failure running pass manager on failing external pass.\n");
       exit(EXIT_FAILURE);
     }
MlirPass externalPass = mlirCreateExternalPass(
         makeTestExternalPassCallbacks(NULL, testRunFailingExternalPass),
         &userData);
 
     if (userData.constructCallCount != 1) {
       fprintf(stderr, "Expected constructCallCount to be 1\n");
       exit(EXIT_FAILURE);
     }
 
-    MlirPassManager pm = mlirPassManagerCreate(ctx);
+    MlirPassManager pm = mlirPassManagerCreate(
+        ctx, mlirStringRefCreateFromCString("builtin.module"));
     mlirPassManagerAddOwnedPass(pm, externalPass);
     MlirLogicalResult success = mlirPassManagerRun(pm, module);
     if (mlirLogicalResultIsSuccess(success)) {
       fprintf(
           stderr,
           "Expected failure running pass manager on failing external pass.\n");
       exit(EXIT_FAILURE);
     }