use nanobind ndarray to make use of bfloat16 weights possible (without

coping the data)

Author: DavidGinten

mlir/lib/Bindings/Python/IRAttributes.cpp

@@ -6,6 +6,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include <cstddef>
 #include <cstdint>
 #include <optional>
 #include <string>
@@ -18,6 +19,9 @@
 #include "mlir-c/BuiltinTypes.h"
 #include "mlir/Bindings/Python/NanobindAdaptors.h"
 #include "mlir/Bindings/Python/Nanobind.h"
+#include "nanobind/nanobind.h"
+#include "nanobind/ndarray.h"
+#include "pytypedefs.h"
 #include "llvm/ADT/ScopeExit.h"
 #include "llvm/Support/raw_ostream.h"
 
@@ -1494,14 +1498,63 @@ class PyDenseResourceElementsAttribute
     return PyDenseResourceElementsAttribute(contextWrapper->getRef(), attr);
   }
 
+  static PyDenseResourceElementsAttribute
+  getFromNdarray(nb::ndarray<nb::any_contig>& buffer, const std::string &name, const PyType &type,
+                std::optional<size_t> alignment, bool isMutable,
+                DefaultingPyMlirContext contextWrapper) {
+    if (!mlirTypeIsAShaped(type)) {
+      throw std::invalid_argument(
+          "Constructing a DenseResourceElementsAttr requires a ShapedType.");
+    }
+      
+    // Do not request any conversions as we must ensure to use caller
+    // managed memory.
+    if (!buffer.is_valid()) {
+      throw std::invalid_argument("The buffer should not be a nullptr.");
+    }
+
+    // Infer alignment to be the stride of one element if not explicit.
+    size_t inferredAlignment;
+    if (alignment)
+      inferredAlignment = *alignment;
+    else
+      inferredAlignment = buffer.stride_ptr()[buffer.ndim() - 1];
+
+    // The userData is a Py_buffer* that the deleter owns.
+    auto deleter = [](void *userData, const void *data, size_t size,
+        size_t align) {
+      nb::ndarray<nb::any_contig> *ownedBuffer= static_cast<nb::ndarray<nb::any_contig> *>(userData);
+      //delete ownedBuffer;
+    };
+
+    size_t rawBufferSize = buffer.size();
+    MlirAttribute attr = mlirUnmanagedDenseResourceElementsAttrGet(
+        type, toMlirStringRef(name), buffer.data(), rawBufferSize,
+        inferredAlignment, isMutable, deleter, static_cast<void *>(&buffer)); //deleter, static_cast<void *>(&buffer));
+    if (mlirAttributeIsNull(attr)) {
+      throw std::invalid_argument(
+          "DenseResourceElementsAttr could not be constructed from the given "
+          "buffer. "
+          "This may mean that the Python buffer layout does not match that "
+          "MLIR expected layout and is a bug.");
+    }
+    return PyDenseResourceElementsAttribute(contextWrapper->getRef(), attr);
+  }
+
   static void bindDerived(ClassTy &c) {
     c.def_static(
         "get_from_buffer", PyDenseResourceElementsAttribute::getFromBuffer,
         nb::arg("array"), nb::arg("name"), nb::arg("type"),
         nb::arg("alignment").none() = nb::none(), nb::arg("is_mutable") = false,
         nb::arg("context").none() = nb::none(),
         kDenseResourceElementsAttrGetFromBufferDocstring);
-  }
+    c.def_static(
+        "get_from_ndarray", PyDenseResourceElementsAttribute::getFromNdarray,
+        nb::arg("array"), nb::arg("name"), nb::arg("type"),
+        nb::arg("alignment").none() = nb::none(), nb::arg("is_mutable") = false,
+        nb::arg("context").none() = nb::none(),
+        kDenseResourceElementsAttrGetFromBufferDocstring);
+      }
 };
 
 class PyDictAttribute : public PyConcreteAttribute<PyDictAttribute> {

mlir/test/python/ir/array_attributes.py

@@ -6,6 +6,7 @@
 from mlir.ir import *
 import numpy as np
 import weakref
+import ctypes
 
 
 def run(f):
@@ -617,3 +618,119 @@ def test_attribute(context, mview):
     # CHECK: BACKING MEMORY DELETED
     # CHECK: EXIT FUNCTION
     print("EXIT FUNCTION")
+
+
+# CHECK-LABEL: TEST: testGetDenseResourceElementsAttrNdarrayI32
+@run
+def testGetDenseResourceElementsAttrNdarrayI32():
+    class DLPackWrapper:
+        def __init__(self, array: np.ndarray):
+            self.dlpack_capsule = array.__dlpack__()
+    
+        def __del__(self):
+            print("BACKING MEMORY DELETED")
+
+        def get_capsule(self):
+            return self.dlpack_capsule
+
+    context = Context()
+    mview_int32 = DLPackWrapper(np.array([[1, 2, 3], [4, 5, 6]], dtype=np.int32))
+
+    def test_attribute_int32(context, mview_int32):
+        with context, Location.unknown():
+            element_type = IntegerType.get_signless(32)
+            tensor_type = RankedTensorType.get((2, 3), element_type)
+            resource = DenseResourceElementsAttr.get_from_ndarray(
+                mview_int32.get_capsule(), "from_py", tensor_type
+            )
+            module = Module.parse("module {}")
+            module.operation.attributes["test.resource"] = resource
+            # CHECK: test.resource = dense_resource<from_py> : tensor<2x3xi32>
+            # CHECK: from_py: "0x01000000010000000200"
+            print(module)
+
+            # Verifies type casting.
+            # CHECK: dense_resource<from_py> : tensor<2x3xi32>
+            print(
+                DenseResourceElementsAttr(module.operation.attributes["test.resource"])
+            )
+
+    test_attribute_int32(context, mview_int32)
+    del mview_int32
+    gc.collect()
+    # CHECK: FREEING CONTEXT
+    print("FREEING CONTEXT")
+    context = None
+    gc.collect()
+    # CHECK: EXIT FUNCTION
+    print("EXIT FUNCTION")
+
+
+# CHECK-LABEL: TEST: testGetDenseResourceElementsAttrNdarrayF32
+@run
+def testGetDenseResourceElementsAttrNdarrayF32():
+    class DLPackWrapper:
+        def __init__(self, array: np.ndarray):
+            self.dlpack_capsule = array.__dlpack__()
+
+        def __del__(self):
+            print("BACKING MEMORY DELETED")
+
+        def get_capsule(self):
+            return self.dlpack_capsule
+
+    context = Context()
+    mview_float32 = DLPackWrapper(np.array([[1, 2, 3], [4, 5, 6]], dtype=np.float32))
+
+    def test_attribute_float32(context, mview_float32):
+        with context, Location.unknown():
+            element_type = FloatAttr.get_f32(32.0)
+            tensor_type = RankedTensorType.get((2, 3), element_type.type)
+            resource = DenseResourceElementsAttr.get_from_ndarray(
+                mview_float32.get_capsule(), "from_py", tensor_type
+            )
+            module = Module.parse("module {}")
+            module.operation.attributes["test.resource"] = resource
+            # CHECK: test.resource = dense_resource<from_py> : tensor<2x3xf32>
+            # CHECK: from_py: "0x010000000000803F0000"
+            print(module)
+
+            # Verifies type casting.
+            # CHECK: dense_resource<from_py> : tensor<2x3xf32>
+            print(
+                DenseResourceElementsAttr(module.operation.attributes["test.resource"])
+            )
+
+    test_attribute_float32(context, mview_float32)
+    del mview_float32
+    gc.collect()
+    # CHECK: FREEING CONTEXT
+    print("FREEING CONTEXT")
+    context = None
+    gc.collect()
+    # CHECK: EXIT FUNCTION
+    print("EXIT FUNCTION")
+
+
+# CHECK-LABEL: TEST: testGetDenseResourceElementsAttrNonShapedType
+@run
+def testGetDenseResourceElementsAttrNonShapedType():
+    class DLPackWrapper:
+        def __init__(self, array: np.ndarray):
+            self.dlpack_capsule = array.__dlpack__()
+
+        def __del__(self):
+            print("BACKING MEMORY DELETED")
+
+        def get_capsule(self):
+            return self.dlpack_capsule
+
+    with Context(), Location.unknown():
+        mview = DLPackWrapper(np.array([1], dtype=np.int32))
+        t = F32Type.get()
+
+        try:
+            attr = DenseResourceElementsAttr.get_from_ndarray(mview.get_capsule(), "from_py", t)
+        except ValueError as e:
+            # CHECK: Constructing a DenseResourceElementsAttr requires a ShapedType.
+            print(e)