Add basic JIT Python Bindings

[mehdi_amini]

Summary

This offers the ability to create a JIT and invoke a function by passing
ctypes pointers to the argument and the result.

[mehdi_amini]

Switch to use ctypes for argument passing

[mehdi_amini]

Fix jit.py

[ftynse]

mlir/lib/Bindings/Python/Conversions/CMakeLists.txt

11

Please add the newline

mlir/lib/Bindings/Python/Jit.cpp

61 ↗

(On Diff #327391)

I think you can now throw py::runtime_error("message")

66 ↗

(On Diff #327391)

Nit: dialects

mlir/lib/Bindings/Python/Jit.h

1 ↗

(On Diff #327391)

Wrong header

mlir/lib/Bindings/Python/mlir/jit.py

11 ↗

(On Diff #327391)

Other files use 2 spaces for indentation

mlir/lib/CAPI/ExecutionEngine/ExecutionEngine.cpp

26

We need some mechanism of exposing this registration to Python so that out-of-tree dialects can also register their translations.

mlir/test/Bindings/Python/jit.py

37 ↗

(On Diff #327391)

Nit: add an empty line above

[mehdi_amini]

Address comments

[mehdi_amini]

mlir/lib/CAPI/ExecutionEngine/ExecutionEngine.cpp

26

ack. Not sure what we'll do for this? I suspect we'll push this on the dialects to provide an API to register them and push on the user to register before invoking the Jit?

[mehdi_amini]

mlir/lib/Bindings/Python/Jit.cpp

61 ↗

(On Diff #327391)

Any link to a doc or an example, it does not work for me?

[mehdi_amini]

Revert back to throw SetPyError(PyExc_RuntimeError and add a test for the failure

[stellaraccident]

mlir/lib/Bindings/Python/Jit.cpp

61 ↗

(On Diff #327391)

Just throw std::exception. See the mapping here: https://pybind11.readthedocs.io/en/stable/advanced/exceptions.html

(this SetPyError form is something I carried forward from the distant past/other projects and in newer code, we are throwing exceptions directly if possible)

21 ↗

(On Diff #327527)

Stale comment: ... around an MlirExecutionEngine

Maybe also a brief comment about why you switch terminology to Jit.

59 ↗

(On Diff #327527)

Does the input Module need to survive past this call (or is it converted and then not needed)? If the former, then we have a lifetime hazard here.

65 ↗

(On Diff #327527)

... must contain only ...

mlir/lib/Bindings/Python/mlir/jit.py

12 ↗

(On Diff #327527)

Elsewhere we exclusively use triple-double quotes ("""). Our style guide is silent on it, so your call.

mlir/lib/CAPI/ExecutionEngine/ExecutionEngine.cpp

26

"Standalone" out of tree dialects have quite a few issues with them being usable in practice. Things like npcomp that bring their own C-API, can provide their own entry point for registering their local translations. I wish we had a better story here, but this is far from the only thing that will have such problems.

[mehdi_amini]

mlir/lib/Bindings/Python/Jit.cpp

61 ↗

(On Diff #327391)

Couldn't throw a std::exception as there is no constructor from a string literal, but we can throw a std::runtime_error error here :)

21 ↗

(On Diff #327527)

I guess I've always used "jit" intuitively so it fit better my mental model, but I should probably stick to "ExecutionEngine" for consistency with the rest of the project.

59 ↗

(On Diff #327527)

It isn't needed after this call.

I checked the header and it is called out for this function: "the module ownership stays with the client and can be destroyed as soon as the call returns."

mlir/lib/Bindings/Python/mlir/jit.py

12 ↗

(On Diff #327527)

Consistency is important to me: I switched to triple quotes.

[mehdi_amini]

Address Stella's comments

[ftynse]

mlir/lib/CAPI/ExecutionEngine/ExecutionEngine.cpp

26

I suppose we can use a mechanism similar to dialect registration: in the C API, this is pushed down to the dialect that provides a registration function taking MlirContext. In Python, I would love to see something like import mlir.dialect.llvm.translation that calls the relevant function in its __init__.py. Not necessary for this commit.

mlir/include/mlir-c/Bindings/Python/Interop.h

 
 #ifndef MLIR_C_BINDINGS_PYTHON_INTEROP_H
 #define MLIR_C_BINDINGS_PYTHON_INTEROP_H
 
 #include <Python.h>
 
 #include "mlir-c/AffineExpr.h"
 #include "mlir-c/AffineMap.h"
+#include "mlir-c/ExecutionEngine.h"
 #include "mlir-c/IR.h"
 #include "mlir-c/IntegerSet.h"
 #include "mlir-c/Pass.h"
 
 #define MLIR_PYTHON_CAPSULE_AFFINE_EXPR "mlir.ir.AffineExpr._CAPIPtr"
 #define MLIR_PYTHON_CAPSULE_AFFINE_MAP "mlir.ir.AffineMap._CAPIPtr"
 #define MLIR_PYTHON_CAPSULE_ATTRIBUTE "mlir.ir.Attribute._CAPIPtr"
 #define MLIR_PYTHON_CAPSULE_CONTEXT "mlir.ir.Context._CAPIPtr"
+#define MLIR_PYTHON_CAPSULE_EXECUTION_ENGINE                                   \
+  "mlir.execution_engine.ExecutionEngine._CAPIPtr"
 #define MLIR_PYTHON_CAPSULE_INTEGER_SET "mlir.ir.IntegerSet._CAPIPtr"
 #define MLIR_PYTHON_CAPSULE_LOCATION "mlir.ir.Location._CAPIPtr"
 #define MLIR_PYTHON_CAPSULE_MODULE "mlir.ir.Module._CAPIPtr"
 #define MLIR_PYTHON_CAPSULE_OPERATION "mlir.ir.Operation._CAPIPtr"
 #define MLIR_PYTHON_CAPSULE_TYPE "mlir.ir.Type._CAPIPtr"
 #define MLIR_PYTHON_CAPSULE_PASS_MANAGER "mlir.passmanager.PassManager._CAPIPtr"
 
 /** Attribute on MLIR Python objects that expose their C-API pointer.

  * a null set is returned (as checked via mlirIntegerSetIsNull). In such a
  * case, the Python APIs will have already set an error. */
 static inline MlirIntegerSet mlirPythonCapsuleToIntegerSet(PyObject *capsule) {
   void *ptr = PyCapsule_GetPointer(capsule, MLIR_PYTHON_CAPSULE_INTEGER_SET);
   MlirIntegerSet integerSet = {ptr};
   return integerSet;
 }
 
+/** Creates a capsule object encapsulating the raw C-API MlirExecutionEngine.
+ * The returned capsule does not extend or affect ownership of any Python
+ * objects that reference the set in any way. */
+static inline PyObject *
+mlirPythonExecutionEngineToCapsule(MlirExecutionEngine jit) {
+  return PyCapsule_New(MLIR_PYTHON_GET_WRAPPED_POINTER(jit),
+                       MLIR_PYTHON_CAPSULE_EXECUTION_ENGINE, NULL);
+}
+
+/** Extracts an MlirExecutionEngine from a capsule as produced from
+ * mlirPythonIntegerSetToCapsule. If the capsule is not of the right type, then
+ * a null set is returned (as checked via mlirExecutionEngineIsNull). In such a
+ * case, the Python APIs will have already set an error. */
+static inline MlirExecutionEngine
+mlirPythonCapsuleToExecutionEngine(PyObject *capsule) {
+  void *ptr =
+      PyCapsule_GetPointer(capsule, MLIR_PYTHON_CAPSULE_EXECUTION_ENGINE);
+  MlirExecutionEngine jit = {ptr};
+  return jit;
+}
+
 #ifdef __cplusplus
 }
 #endif
 
 #endif // MLIR_C_BINDINGS_PYTHON_INTEROP_H

mlir/include/mlir-c/ExecutionEngine.h

 /// Invoke a native function in the execution engine by name with the arguments
 /// and result of the invoked function passed as an array of pointers. The
 /// function must have been tagged with the `llvm.emit_c_interface` attribute.
 /// Returns a failure if the execution fails for any reason (the function name
 /// can't be resolved for instance).
 MLIR_CAPI_EXPORTED MlirLogicalResult mlirExecutionEngineInvokePacked(
     MlirExecutionEngine jit, MlirStringRef name, void **arguments);
 
+/// Lookup a native function in the execution engine by name, returns nullptr
+/// if the name can't be looked-up.
+MLIR_CAPI_EXPORTED void *mlirExecutionEngineLookup(MlirExecutionEngine jit,
+                                                   MlirStringRef name);
+
 #ifdef __cplusplus
 }
 #endif
 
 #endif // EXECUTIONENGINE_H

mlir/lib/Bindings/Python/CMakeLists.txt

 include(AddMLIRPythonExtension)
 add_custom_target(MLIRBindingsPythonExtension)
 
 ################################################################################
 # Copy python source tree.
 ################################################################################
 
 set(PY_SRC_FILES
   mlir/__init__.py
   mlir/_dlloader.py
-  mlir/ir.py
+  mlir/conversions/__init__.py
   mlir/dialects/__init__.py
   mlir/dialects/_linalg.py
   mlir/dialects/_builtin.py
   mlir/ir.py
+  mlir/execution_engine.py
   mlir/passmanager.py
   mlir/transforms/__init__.py
 )
 
 add_custom_target(MLIRBindingsPythonSources ALL
   DEPENDS ${PY_SRC_FILES}
 )
 add_dependencies(MLIRBindingsPythonExtension MLIRBindingsPythonSources)

 add_mlir_python_extension(MLIRCoreBindingsPythonExtension _mlir
   INSTALL_DIR
     python
   SOURCES
     MainModule.cpp
     IRModules.cpp
     PybindUtils.cpp
     Pass.cpp
+    ExecutionEngine.cpp
 )
 add_dependencies(MLIRBindingsPythonExtension MLIRCoreBindingsPythonExtension)
 
 # Note that we copy from the source tree just like for headers because
 # it will not be polluted with py_cache runtime artifacts (from testing and
 # such).
 install(
   DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/mlir

 if (NOT LLVM_ENABLE_IDE)
   add_llvm_install_targets(
     install-MLIRBindingsPythonDialects
     DEPENDS MLIRBindingsPythonSources
     COMPONENT MLIRBindingsPythonDialects)
 endif()
 
 add_subdirectory(Transforms)
+add_subdirectory(Conversions)

mlir/lib/Bindings/Python/Conversions/CMakeLists.txt

+################################################################################
+# Build python extension
+################################################################################
+
+add_mlir_python_extension(MLIRConversionsBindingsPythonExtension _mlirConversions
+  INSTALL_DIR
+    python
+  SOURCES
+  Conversions.cpp
+)

mlir/lib/Bindings/Python/Conversions/Conversions.cpp

+//===- Conversions.cpp - Pybind module for the Conversionss library -------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "mlir-c/Conversion.h"
+
+#include <pybind11/pybind11.h>
+
+namespace py = pybind11;
+
+// -----------------------------------------------------------------------------
+// Module initialization.
+// -----------------------------------------------------------------------------
+
+PYBIND11_MODULE(_mlirConversions, m) {
+  m.doc() = "MLIR Conversions library";
+
+  // Register all the passes in the Conversions library on load.
+  mlirRegisterConversionPasses();
+}

mlir/lib/Bindings/Python/ExecutionEngine.h

+//===- ExecutionEngine.h - ExecutionEngine submodule of pybind module -----===//
+//
+// 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_BINDINGS_PYTHON_EXECUTIONENGINE_H
+#define MLIR_BINDINGS_PYTHON_EXECUTIONENGINE_H
+
+#include "PybindUtils.h"
+
+namespace mlir {
+namespace python {
+
+void populateExecutionEngineSubmodule(pybind11::module &m);
+
+} // namespace python
+} // namespace mlir
+
+#endif // MLIR_BINDINGS_PYTHON_EXECUTIONENGINE_H

mlir/lib/Bindings/Python/ExecutionEngine.cpp

+//===- ExecutionEngine.cpp - Python MLIR ExecutionEngine Bindings ---------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "ExecutionEngine.h"
+
+#include "IRModules.h"
+#include "mlir-c/Bindings/Python/Interop.h"
+#include "mlir-c/ExecutionEngine.h"
+
+namespace py = pybind11;
+using namespace mlir;
+using namespace mlir::python;
+
+namespace {
+
+/// Owning Wrapper around an ExecutionEngine.
+class PyExecutionEngine {
+public:
+  PyExecutionEngine(MlirExecutionEngine executionEngine)
+      : executionEngine(executionEngine) {}
+  PyExecutionEngine(PyExecutionEngine &&other)
+      : executionEngine(other.executionEngine) {
+    other.executionEngine.ptr = nullptr;
+  }
+  ~PyExecutionEngine() {
+    if (!mlirExecutionEngineIsNull(executionEngine))
+      mlirExecutionEngineDestroy(executionEngine);
+  }
+  MlirExecutionEngine get() { return executionEngine; }
+
+  void release() { executionEngine.ptr = nullptr; }
+  pybind11::object getCapsule() {
+    return py::reinterpret_steal<py::object>(
+        mlirPythonExecutionEngineToCapsule(get()));
+  }
+
+  static pybind11::object createFromCapsule(pybind11::object capsule) {
+    MlirExecutionEngine rawPm =
+        mlirPythonCapsuleToExecutionEngine(capsule.ptr());
+    if (mlirExecutionEngineIsNull(rawPm))
+      throw py::error_already_set();
+    return py::cast(PyExecutionEngine(rawPm), py::return_value_policy::move);
+  }
+
+private:
+  MlirExecutionEngine executionEngine;
+};
+
+} // anonymous namespace
+
+/// Create the `mlir.execution_engine` module here.
+void mlir::python::populateExecutionEngineSubmodule(py::module &m) {
+  //----------------------------------------------------------------------------
+  // Mapping of the top-level PassManager
+  //----------------------------------------------------------------------------
+  py::class_<PyExecutionEngine>(m, "ExecutionEngine")
+      .def(py::init<>([](PyModule &module) {
+             MlirExecutionEngine executionEngine =
+                 mlirExecutionEngineCreate(module.get());
+             if (mlirExecutionEngineIsNull(executionEngine))
+               throw std::runtime_error(
+                   "Failure while creating the ExecutionEngine.");
+             return new PyExecutionEngine(executionEngine);
+           }),
+           "Create a new ExecutionEngine instance for the given Module. The "
+           "module must "
+           "contain only dialects that can be translated to LLVM.")
+      .def_property_readonly(MLIR_PYTHON_CAPI_PTR_ATTR,
+                             &PyExecutionEngine::getCapsule)
+      .def("_testing_release", &PyExecutionEngine::release,
+           "Releases (leaks) the backing ExecutionEngine (for testing purpose)")
+      .def(MLIR_PYTHON_CAPI_FACTORY_ATTR, &PyExecutionEngine::createFromCapsule)
+      .def(
+          "raw_lookup",
+          [](PyExecutionEngine &executionEngine, const std::string &func) {
+            auto *res = mlirExecutionEngineLookup(
+                executionEngine.get(),
+                mlirStringRefCreate(func.c_str(), func.size()));
+            return (int64_t)res;
+          },
+          "Lookup function `func` in the ExecutionEngine.");
+}

mlir/lib/Bindings/Python/MainModule.cpp

 //===- MainModule.cpp - Main pybind module --------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include <tuple>
 
 #include "PybindUtils.h"
 
+#include "ExecutionEngine.h"
 #include "Globals.h"
 #include "IRModules.h"
 #include "Pass.h"
 
 namespace py = pybind11;
 using namespace mlir;
 using namespace mlir::python;
 
PYBIND11_MODULE(_mlir, m) {
   // Define and populate IR submodule.
   auto irModule = m.def_submodule("ir", "MLIR IR Bindings");
   populateIRSubmodule(irModule);
 
   // Define and populate PassManager submodule.
   auto passModule =
       m.def_submodule("passmanager", "MLIR Pass Management Bindings");
   populatePassManagerSubmodule(passModule);
+
+  // Define and populate ExecutionEngine submodule.
+  auto executionEngineModule =
+      m.def_submodule("execution_engine", "MLIR JIT Execution Engine");
+  populateExecutionEngineSubmodule(executionEngineModule);
 }

mlir/lib/Bindings/Python/mlir/__init__.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
 
 # Note that the only function of this module is currently to load the
 # native module and re-export its symbols. In the future, this file is
 # reserved as a trampoline to handle environment specific loading needs
 # and arbitrate any one-time initialization needed in various shared-library
 # scenarios.
 
 __all__ = [
   "ir",
+  "execution_engine",
   "passmanager",
 ]
 
 # Packaged installs have a top-level _mlir_libs package with symbols:
 #   load_extension(name): Loads a named extension module
 #   preload_dependency(public_name): Loads a shared-library/DLL into the
 #     namespace. TODO: Remove this in favor of a more robust mechanism.
 # Conditionally switch based on whether we are in a package context.
def _reexport_cext(cext_module_name, target_module_name):
   source_module = getattr(_cext, cext_module_name)
   for attr_name in dir(source_module):
     if not attr_name.startswith("__"):
       setattr(target_module, attr_name, getattr(source_module, attr_name))
 
 
 # Import sub-modules. Since these may import from here, this must come after
 # any exported definitions.
-from . import ir, passmanager
+from . import ir, execution_engine, passmanager
 
 # Add our 'dialects' parent module to the search path for implementations.
 _cext.globals.append_dialect_search_prefix("mlir.dialects")

mlir/lib/Bindings/Python/mlir/conversions/__init__.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
+
+# Expose the corresponding C-Extension module with a well-known name at this
+# level.
+from .. import _load_extension
+_cextConversions = _load_extension("_mlirConversions")

mlir/lib/Bindings/Python/mlir/execution_engine.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
+
+# Simply a wrapper around the extension module of the same name.
+from . import _cext
+import ctypes
+
+class ExecutionEngine(_cext.execution_engine.ExecutionEngine):
+
+  def lookup(self, name):
+    """Lookup a function emitted with the `llvm.emit_c_interface`
+    attribute and returns a ctype callable.
+    Raise a RuntimeError if the function isn't found.
+    """
+    func = self.raw_lookup("_mlir_ciface_" + name)
+    if not func:
+      raise RuntimeError("Unknown function " + name)
+    prototype = ctypes.CFUNCTYPE(None, ctypes.c_void_p)
+    return prototype(func)
+
+  def invoke(self, name, *ctypes_args):
+    """Invoke a function with the list of ctypes arguments.
+    All arguments must be pointers.
+    Raise a RuntimeError if the function isn't found.
+    """
+    func = self.lookup(name)
+    packed_args = (ctypes.c_void_p * len(ctypes_args))()
+    for argNum in range(len(ctypes_args)):
+      packed_args[argNum] = ctypes.cast(ctypes_args[argNum], ctypes.c_void_p)
+    func(packed_args)

mlir/lib/CAPI/ExecutionEngine/ExecutionEngine.cpp

 //===- ExecutionEngine.cpp - C API for MLIR JIT ---------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir-c/ExecutionEngine.h"
 #include "mlir/CAPI/ExecutionEngine.h"
 #include "mlir/CAPI/IR.h"
 #include "mlir/CAPI/Support.h"
+#include "mlir/Target/LLVMIR.h"
 #include "llvm/Support/TargetSelect.h"
 
 using namespace mlir;
 
 extern "C" MlirExecutionEngine mlirExecutionEngineCreate(MlirModule op) {
   static bool init_once = [] {
     llvm::InitializeNativeTarget();
     llvm::InitializeNativeTargetAsmPrinter();
     return true;
   }();
   (void)init_once;
 
+  mlir::registerLLVMDialectTranslation(*unwrap(op)->getContext());
   auto jitOrError = ExecutionEngine::create(unwrap(op));
   if (!jitOrError) {
     consumeError(jitOrError.takeError());
     return MlirExecutionEngine{nullptr};
   }
   return wrap(jitOrError->release());
 }
 
 extern "C" void mlirExecutionEngineDestroy(MlirExecutionEngine jit) {
   delete (unwrap(jit));
 }
 
 extern "C" MlirLogicalResult
 mlirExecutionEngineInvokePacked(MlirExecutionEngine jit, MlirStringRef name,
                                 void **arguments) {
   const std::string ifaceName = ("_mlir_ciface_" + unwrap(name)).str();
   llvm::Error error = unwrap(jit)->invokePacked(
       ifaceName, MutableArrayRef<void *>{arguments, (size_t)0});
   if (error)
     return wrap(failure());
   return wrap(success());
 }
+
+extern "C" void *mlirExecutionEngineLookup(MlirExecutionEngine jit,
+                                           MlirStringRef name) {
+  auto expectedFPtr = unwrap(jit)->lookup(unwrap(name));
+  if (!expectedFPtr)
+    return nullptr;
+  return reinterpret_cast<void *>(*expectedFPtr);
+}

mlir/test/Bindings/Python/execution_engine.py

+# RUN: %PYTHON %s 2>&1 | FileCheck %s
+
+import gc, sys
+from mlir.ir import *
+from mlir.passmanager import *
+from mlir.execution_engine import *
+
+# Log everything to stderr and flush so that we have a unified stream to match
+# errors/info emitted by MLIR to stderr.
+def log(*args):
+  print(*args, file=sys.stderr)
+  sys.stderr.flush()
+
+def run(f):
+  log("\nTEST:", f.__name__)
+  f()
+  gc.collect()
+  assert Context._get_live_count() == 0
+
+# Verify capsule interop.
+# CHECK-LABEL: TEST: testCapsule
+def testCapsule():
+  with Context():
+    module = Module.parse(r"""
+llvm.func @none() {
+  llvm.return
+}
+    """)
+    execution_engine = ExecutionEngine(module)
+    execution_engine_capsule = execution_engine._CAPIPtr
+    # CHECK: mlir.execution_engine.ExecutionEngine._CAPIPtr
+    log(repr(execution_engine_capsule))
+    execution_engine._testing_release()
+    execution_engine1 = ExecutionEngine._CAPICreate(execution_engine_capsule)
+    # CHECK: _mlir.execution_engine.ExecutionEngine
+    log(repr(execution_engine1))
+
+run(testCapsule)
+
+# Test invalid ExecutionEngine creation
+# CHECK-LABEL: TEST: testInvalidModule
+def testInvalidModule():
+  with Context():
+    # Builtin function
+    module = Module.parse(r"""
+    func @foo() { return }
+    """)
+    # CHECK: Got RuntimeError:  Failure while creating the ExecutionEngine.
+    try:
+      execution_engine = ExecutionEngine(module)
+    except RuntimeError as e:
+      log("Got RuntimeError: ", e)
+
+run(testInvalidModule)
+
+def lowerToLLVM(module):
+  import mlir.conversions
+  pm = PassManager.parse("convert-std-to-llvm")
+  pm.run(module)
+  return module
+
+# Test simple ExecutionEngine execution
+# CHECK-LABEL: TEST: testInvokeVoid
+def testInvokeVoid():
+  with Context():
+    module = Module.parse(r"""
+func @void() attributes { llvm.emit_c_interface } {
+  return
+}
+    """)    
+    execution_engine = ExecutionEngine(lowerToLLVM(module))
+    # Nothing to check other than no exception thrown here.
+    execution_engine.invoke("void")
+
+run(testInvokeVoid)
+
+
+# Test argument passing and result with a simple float addition.
+# CHECK-LABEL: TEST: testInvokeFloatAdd
+def testInvokeFloatAdd():
+  with Context():
+    module = Module.parse(r"""
+func @add(%arg0: f32, %arg1: f32) -> f32 attributes { llvm.emit_c_interface } {
+  %add = std.addf %arg0, %arg1 : f32
+  return %add : f32
+}
+    """)
+    execution_engine = ExecutionEngine(lowerToLLVM(module))
+    # Prepare arguments: two input floats and one result.
+    # Arguments must be passed as pointers.
+    c_float_p = ctypes.c_float * 1
+    arg0 = c_float_p(42.)
+    arg1 = c_float_p(2.)
+    res = c_float_p(-1.)
+    execution_engine.invoke("add", arg0, arg1, res)
+    # CHECK: 42.0 + 2.0 = 44.0
+    log("{0} + {1} = {2}".format(arg0[0], arg1[0], res[0]))
+
+run(testInvokeFloatAdd)

mlir/test/CMakeLists.txt

if(MLIR_VULKAN_RUNNER_ENABLED)
   )
 endif()
 
 if(MLIR_BINDINGS_PYTHON_ENABLED)
   list(APPEND MLIR_TEST_DEPENDS
     MLIRBindingsPythonExtension
     MLIRBindingsPythonTestOps
     MLIRTransformsBindingsPythonExtension
+    MLIRConversionsBindingsPythonExtension
   )
 endif()
 
 add_lit_testsuite(check-mlir "Running the MLIR regression tests"
   ${CMAKE_CURRENT_BINARY_DIR}
   DEPENDS ${MLIR_TEST_DEPENDS}
   )
 set_target_properties(check-mlir PROPERTIES FOLDER "Tests")
 
 add_lit_testsuites(MLIR ${CMAKE_CURRENT_SOURCE_DIR}
   DEPENDS ${MLIR_TEST_DEPENDS}
 )