Remove pointer owner (#306)

lib/beaver/mlir/capi.ex

@@ -70,7 +70,7 @@ defmodule Beaver.MLIR.CAPI do
   def beaver_raw_to_string_pm(_), do: raise("NIF not loaded")
   def beaver_raw_get_string_ref(_), do: raise("NIF not loaded")
   def beaver_raw_read_opaque_ptr(_, _), do: raise("NIF not loaded")
-  def beaver_raw_own_opaque_ptr(_), do: raise("NIF not loaded")
+  def beaver_raw_deallocate_opaque_ptr(_), do: raise("NIF not loaded")
   def beaver_raw_get_null_ptr(), do: raise("NIF not loaded")
   def beaver_raw_context_attach_diagnostic_handler(_, _), do: raise("NIF not loaded")
   def beaver_raw_get_diagnostic_string_callback(), do: raise("NIF not loaded")

lib/beaver/mlir/capi_codegen.ex

@@ -43,9 +43,6 @@ defmodule Beaver.MLIR.CAPI.CodeGen do
       }
     end ++
       [
-        %KindDecl{
-          module_name: Beaver.Native.PtrOwner
-        },
         %KindDecl{
           module_name: Beaver.Native.Complex.F32
         }

lib/beaver/mlir/operation.ex

@@ -34,7 +34,7 @@ defmodule Beaver.MLIR.Operation do
   end
 
   def create(%State{} = state) do
-    state |> Beaver.Native.ptr() |> Beaver.Native.bag(state) |> mlirOperationCreate()
+    state |> Beaver.Native.ptr() |> mlirOperationCreate()
   end
 
   @doc false

lib/beaver/native.ex

@@ -62,25 +62,14 @@ defmodule Beaver.Native do
     forward(mod, :primitive, [ref])
   end
 
-  def bag(%{bag: _bag} = v, nil) do
-    v
-  end
-
-  def bag(%{bag: bag} = v, list) when is_list(list) do
-    %{v | bag: MapSet.union(MapSet.new(list), bag)}
-  end
-
-  def bag(%{bag: bag} = v, item) do
-    %{v | bag: MapSet.put(bag, item)}
-  end
-
   def check!(ret) do
     case ret do
-      {:kind, Beaver.Native.U8.Array, ref} when is_reference(ref) ->
-        struct!(Beaver.Native.C.String, %{ref: ref})
-
       {:kind, mod, ref} when is_atom(mod) and is_reference(ref) ->
-        struct!(mod, %{ref: ref})
+        try do
+          struct!(mod, %{ref: ref})
+        rescue
+          UndefinedFunctionError -> ref
+        end
 
       {:error, e} ->
         raise e

lib/beaver/native/array.ex

@@ -3,7 +3,7 @@ defmodule Beaver.Native.Array do
   This module defines functions working with C array.
   """
   alias Beaver.MLIR.CAPI
-  defstruct ref: nil, element_kind: nil, bag: MapSet.new()
+  defstruct ref: nil, element_kind: nil
 
   def as_opaque(%{ref: ref, element_kind: element_kind}) do
     ref =

lib/beaver/native/memory.ex

@@ -120,62 +120,38 @@ defmodule Beaver.Native.Memory do
   return a opaque pointer to the memory
   """
   def aligned(%__MODULE__{
-        descriptor: d,
-        storage: storage
+        descriptor: d
       }) do
-    ptr = __MODULE__.Descriptor.aligned(d)
-
-    if storage do
-      ptr |> Native.bag(storage)
-    else
-      ptr
-    end
+    __MODULE__.Descriptor.aligned(d)
   end
 
   def allocated(%__MODULE__{
-        descriptor: d,
-        storage: storage
+        descriptor: d
       }) do
-    ptr = __MODULE__.Descriptor.allocated(d)
-
-    if storage do
-      ptr |> Native.bag(storage)
-    else
-      ptr
-    end
+    __MODULE__.Descriptor.allocated(d)
   end
 
   @doc """
   return a opaque pointer to the memory descriptor. Usually used in the invoking of a generated function.
   If it is a array, will return the pointer of the array to mimic a struct of packed memory descriptors
   """
   def descriptor_ptr(%__MODULE__{
-        descriptor: d,
-        storage: storage
+        descriptor: d
       }) do
     __MODULE__.Descriptor.opaque_ptr(d)
-    |> Native.bag(storage)
   end
 
   # if this is an array, this should be packed memory descriptors for tuple
-  def descriptor_ptr(%Native.Array{ref: ref, element_kind: element_kind} = array) do
+  def descriptor_ptr(%Native.Array{ref: ref, element_kind: element_kind}) do
     ref = Native.forward(element_kind, :ptr_to_opaque, [ref])
-    struct!(Native.OpaquePtr, ref: ref) |> Native.bag(array)
+    struct!(Native.OpaquePtr, ref: ref)
   end
 
-  @doc """
-  take ownership of the memory the descriptor's `allocated` field points to
-  """
-  def own_allocated(
+  def deallocate(
         %__MODULE__{
           storage: nil
         } = m
       ) do
-    owner =
-      m
-      |> allocated
-      |> Native.PtrOwner.new()
-
-    %{m | storage: owner}
+    m |> allocated |> Beaver.Native.OpaquePtr.deallocate()
   end
 end

lib/beaver/native/opaque_ptr.ex

@@ -25,4 +25,8 @@ defmodule Beaver.Native.OpaquePtr do
   def null() do
     %__MODULE__{ref: beaver_raw_get_null_ptr() |> Beaver.Native.check!()}
   end
+
+  def deallocate(%__MODULE__{ref: ref}) do
+    beaver_raw_deallocate_opaque_ptr(ref) |> Beaver.Native.check!()
+  end
 end

lib/beaver/native/ptr.ex

@@ -2,5 +2,5 @@ defmodule Beaver.Native.Ptr do
   @moduledoc """
   This module defines functions working with pointer in C.
   """
-  defstruct ref: nil, element_kind: nil, bag: MapSet.new()
+  defstruct ref: nil, element_kind: nil
 end

native/mlir-zig-proj/src/main.zig

@@ -25,7 +25,6 @@ export fn nif_load(env: beam.env, _: [*c]?*anyopaque, _: beam.term) c_int {
     kinda.Internal.OpaqueStruct.open_all(env);
     mlir_capi.open_all(env);
     memref.open_all(env);
-    pointer.open_all(env);
     pass.open_all(env);
     return 0;
 }

native/mlir-zig-proj/src/pointer.zig

@@ -6,25 +6,21 @@ const e = @import("erl_nif");
 const result = @import("result.zig");
 const kinda = @import("kinda");
 
-pub const PtrOwner = extern struct {
-    pub const Kind = kinda.ResourceKind(@This(), "Elixir.Beaver.Native.PtrOwner");
-    ptr: mlir_capi.OpaquePtr.T,
-    extern fn free(ptr: ?*anyopaque) void;
-    pub fn destroy(_: beam.env, resource_ptr: ?*anyopaque) callconv(.C) void {
-        const this_ptr: *@This() = @ptrCast(@alignCast(resource_ptr));
-        std.debug.print("destroy {}.\n", .{this_ptr});
-        free(this_ptr.*.ptr);
-    }
-};
+extern fn free(ptr: mlir_capi.OpaquePtr.T) void;
 
 fn get_null(env: beam.env, _: c_int, _: [*c]const beam.term) !beam.term {
     return try mlir_capi.OpaquePtr.resource.make(env, null);
 }
 
-fn own_opaque_ptr(env: beam.env, _: c_int, args: [*c]const beam.term) !beam.term {
-    var ptr = try mlir_capi.OpaquePtr.resource.fetch(env, args[0]);
-    var owner: PtrOwner = .{ .ptr = ptr };
-    return try PtrOwner.Kind.resource.make(env, owner);
+fn deallocate(env: beam.env, _: c_int, args: [*c]const beam.term) !beam.term {
+    const Error = error{NullPointer};
+    var ptr: mlir_capi.OpaquePtr.T = try mlir_capi.OpaquePtr.resource.fetch(env, args[0]);
+    if (ptr) |p| {
+        free(p);
+        return beam.make_ok(env);
+    } else {
+        return Error.NullPointer;
+    }
 }
 
 fn read_opaque_ptr(env: beam.env, _: c_int, args: [*c]const beam.term) !beam.term {
@@ -38,7 +34,4 @@ fn read_opaque_ptr(env: beam.env, _: c_int, args: [*c]const beam.term) !beam.ter
     return beam.make_slice(env, slice);
 }
 
-pub const nifs = .{ result.nif("beaver_raw_get_null_ptr", 0, get_null).entry, result.nif("beaver_raw_own_opaque_ptr", 1, own_opaque_ptr).entry, result.nif("beaver_raw_read_opaque_ptr", 2, read_opaque_ptr).entry } ++ PtrOwner.Kind.nifs;
-pub fn open_all(env: beam.env) void {
-    PtrOwner.Kind.open(env);
-}
+pub const nifs = .{ result.nif("beaver_raw_get_null_ptr", 0, get_null).entry, result.nif("beaver_raw_deallocate_opaque_ptr", 1, deallocate).entry, result.nif("beaver_raw_read_opaque_ptr", 2, read_opaque_ptr).entry };

test/capi_test.exs

@@ -32,10 +32,7 @@ defmodule MlirTest do
     changeset = %MLIR.Operation.Changeset{name: "func.return", location: location}
 
     for _i <- 0..200 do
-      operation_state_ptr =
-        changeset |> MLIR.Operation.State.create() |> Beaver.Native.ptr()
-
-      _ret_op = mlirOperationCreate(operation_state_ptr)
+      changeset |> MLIR.Operation.State.create() |> Beaver.Native.ptr() |> mlirOperationCreate()
     end
 
     i64_t = mlirTypeParseGet(ctx, MLIR.StringRef.create("i64"))

test/tosa_test.exs

@@ -149,6 +149,6 @@ defmodule TosaTest do
     return.descriptor |> Native.Memory.Descriptor.dump()
     Native.Memory.descriptor_ptr(return) |> Native.dump()
     assert return.descriptor |> Native.Memory.Descriptor.offset() == 0
-    Native.Memory.own_allocated(return)
+    assert :ok == Native.Memory.deallocate(return)
   end
 end