onnxruntime 0.9.3-arm64-darwin → 0.10.0-arm64-darwin

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a0f68aa52a14030b633fd2424395a803150d0f336259de1c97a7e27430259191
-  data.tar.gz: 6619423585e62a142abf5298f90ebecd16396264b689da3885535967f6dca1d1
+  metadata.gz: f7dad037f608d84cfab56c437400214af6a2337f82fdde99da832fd439f427b6
+  data.tar.gz: c5add82f70cc8262f8d8650fbf27ec862b20d287b30b58a5166d922b6b761181
 SHA512:
-  metadata.gz: 616c2f43fd027b2461e3ceb798d7de8288afc6cf0df46982635bfd0507b5c46ab607b6088fffbb1c969f036e109a25aaafb661ca9d8fd88562e5c3af3c27ab89
-  data.tar.gz: aa82092853cfa49307d665972348b54eab01d685cd638ebfda8c5adfe7d3d4f43bb31aa9a1e93ea4740a7de6e21efea8711365509ae155035d1cdafff7a9bb1f
+  metadata.gz: c77c90b6fd4d689ce048ead1c2a06e5122b2c15a55826224fda7268413d0443f4a1bff65c3e1c87b367fa795d2c7c80ea012462d5de355647edda0d72c5830f5
+  data.tar.gz: acb452d01571852dac8807ecc989714bfd13374c4d58c1c1dfb3a084a17cb04fd9c0ac658756d8a93ef387766bf3e5101e0e7e573270a40adf9583d6c082b9c8

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+## 0.10.0 (2025-05-11)
+
+- Updated ONNX Runtime to 1.22.0
+- Dropped support for Ruby < 3.2
+
+## 0.9.4 (2025-03-08)
+
+- Updated ONNX Runtime to 1.21.0
+
 ## 0.9.3 (2024-11-01)
 
 - Updated ONNX Runtime to 1.20.0

data/LICENSE.txt

@@ -1,7 +1,7 @@
 MIT License
 
 Copyright (c) Microsoft Corporation
-Copyright (c) 2019-2024 Andrew Kane
+Copyright (c) 2019-2025 Andrew Kane
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -4,6 +4,8 @@
 
 Check out [an example](https://ankane.org/tensorflow-ruby)
 
+For transformer models, check out [Informers](https://github.com/ankane/informers)
+
 [![Build Status](https://github.com/ankane/onnxruntime-ruby/actions/workflows/build.yml/badge.svg)](https://github.com/ankane/onnxruntime-ruby/actions)
 
 ## Installation

data/lib/onnxruntime/ffi.rb

@@ -147,7 +147,7 @@ module OnnxRuntime
         :FillStringTensorElement, callback(%i[pointer string size_t], :pointer),
         :AddSessionConfigEntry, callback(%i[pointer string string], :pointer),
         :CreateAllocator, callback(%i[], :pointer),
-        :ReleaseAllocator, callback(%i[], :pointer),
+        :ReleaseAllocator, callback(%i[pointer], :pointer),
         :RunWithBinding, callback(%i[], :pointer),
         :CreateIoBinding, callback(%i[], :pointer),
         :ReleaseIoBinding, callback(%i[], :pointer),
@@ -249,7 +249,7 @@ module OnnxRuntime
     def self.api
       @api ||= begin
         api = self.OrtGetApiBase[:GetApi].call(ORT_API_VERSION)
-        api = Api.by_ref.from_native(api, nil) if RUBY_PLATFORM == "java"
+        api = Api.by_ref.from_native(api, nil) if RUBY_ENGINE == "jruby"
         api
       end
     end

data/lib/onnxruntime/inference_session.rb

@@ -6,52 +6,54 @@ module OnnxRuntime
       # session options
       session_options = ::FFI::MemoryPointer.new(:pointer)
       check_status api[:CreateSessionOptions].call(session_options)
+      session_options = ::FFI::AutoPointer.new(session_options.read_pointer, api[:ReleaseSessionOptions])
+
       if enable_cpu_mem_arena
-        check_status api[:EnableCpuMemArena].call(session_options.read_pointer)
+        check_status api[:EnableCpuMemArena].call(session_options)
       else
-        check_status api[:DisableCpuMemArena].call(session_options.read_pointer)
+        check_status api[:DisableCpuMemArena].call(session_options)
       end
       if enable_mem_pattern
-        check_status api[:EnableMemPattern].call(session_options.read_pointer)
+        check_status api[:EnableMemPattern].call(session_options)
       else
-        check_status api[:DisableMemPattern].call(session_options.read_pointer)
+        check_status api[:DisableMemPattern].call(session_options)
       end
       if enable_profiling
-        check_status api[:EnableProfiling].call(session_options.read_pointer, ort_string(profile_file_prefix || "onnxruntime_profile_"))
+        check_status api[:EnableProfiling].call(session_options, ort_string(profile_file_prefix || "onnxruntime_profile_"))
       else
-        check_status api[:DisableProfiling].call(session_options.read_pointer)
+        check_status api[:DisableProfiling].call(session_options)
       end
       if execution_mode
         execution_modes = {sequential: 0, parallel: 1}
         mode = execution_modes[execution_mode]
         raise ArgumentError, "Invalid execution mode" unless mode
-        check_status api[:SetSessionExecutionMode].call(session_options.read_pointer, mode)
+        check_status api[:SetSessionExecutionMode].call(session_options, mode)
       end
       if free_dimension_overrides_by_denotation
         free_dimension_overrides_by_denotation.each do |k, v|
-          check_status api[:AddFreeDimensionOverride].call(session_options.read_pointer, k.to_s, v)
+          check_status api[:AddFreeDimensionOverride].call(session_options, k.to_s, v)
         end
       end
       if free_dimension_overrides_by_name
         free_dimension_overrides_by_name.each do |k, v|
-          check_status api[:AddFreeDimensionOverrideByName].call(session_options.read_pointer, k.to_s, v)
+          check_status api[:AddFreeDimensionOverrideByName].call(session_options, k.to_s, v)
         end
       end
       if graph_optimization_level
         optimization_levels = {none: 0, basic: 1, extended: 2, all: 99}
         level = optimization_levels[graph_optimization_level]
         raise ArgumentError, "Invalid graph optimization level" unless level
-        check_status api[:SetSessionGraphOptimizationLevel].call(session_options.read_pointer, level)
+        check_status api[:SetSessionGraphOptimizationLevel].call(session_options, level)
       end
-      check_status api[:SetInterOpNumThreads].call(session_options.read_pointer, inter_op_num_threads) if inter_op_num_threads
-      check_status api[:SetIntraOpNumThreads].call(session_options.read_pointer, intra_op_num_threads) if intra_op_num_threads
-      check_status api[:SetSessionLogSeverityLevel].call(session_options.read_pointer, log_severity_level) if log_severity_level
-      check_status api[:SetSessionLogVerbosityLevel].call(session_options.read_pointer, log_verbosity_level) if log_verbosity_level
-      check_status api[:SetSessionLogId].call(session_options.read_pointer, logid) if logid
-      check_status api[:SetOptimizedModelFilePath].call(session_options.read_pointer, ort_string(optimized_model_filepath)) if optimized_model_filepath
+      check_status api[:SetInterOpNumThreads].call(session_options, inter_op_num_threads) if inter_op_num_threads
+      check_status api[:SetIntraOpNumThreads].call(session_options, intra_op_num_threads) if intra_op_num_threads
+      check_status api[:SetSessionLogSeverityLevel].call(session_options, log_severity_level) if log_severity_level
+      check_status api[:SetSessionLogVerbosityLevel].call(session_options, log_verbosity_level) if log_verbosity_level
+      check_status api[:SetSessionLogId].call(session_options, logid) if logid
+      check_status api[:SetOptimizedModelFilePath].call(session_options, ort_string(optimized_model_filepath)) if optimized_model_filepath
       if session_config_entries
         session_config_entries.each do |k, v|
-          check_status api[:AddSessionConfigEntry].call(session_options.read_pointer, k.to_s, v.to_s)
+          check_status api[:AddSessionConfigEntry].call(session_options, k.to_s, v.to_s)
         end
       end
       providers.each do |provider|
@@ -64,15 +66,15 @@ module OnnxRuntime
         when "CUDAExecutionProvider"
           cuda_options = ::FFI::MemoryPointer.new(:pointer)
           check_status api[:CreateCUDAProviderOptions].call(cuda_options)
-          check_status api[:SessionOptionsAppendExecutionProvider_CUDA_V2].call(session_options.read_pointer, cuda_options.read_pointer)
-          release :CUDAProviderOptions, cuda_options
+          cuda_options = ::FFI::AutoPointer.new(cuda_options.read_pointer, api[:ReleaseCUDAProviderOptions])
+          check_status api[:SessionOptionsAppendExecutionProvider_CUDA_V2].call(session_options, cuda_options)
         when "CoreMLExecutionProvider"
           unless FFI.respond_to?(:OrtSessionOptionsAppendExecutionProvider_CoreML)
             raise ArgumentError, "Provider not available: #{provider}"
           end
 
           coreml_flags = 0
-          check_status FFI.OrtSessionOptionsAppendExecutionProvider_CoreML(session_options.read_pointer, coreml_flags)
+          check_status FFI.OrtSessionOptionsAppendExecutionProvider_CoreML(session_options, coreml_flags)
         when "CPUExecutionProvider"
           break
         else
@@ -81,13 +83,9 @@ module OnnxRuntime
       end
 
       @session = load_session(path_or_bytes, session_options)
-      ObjectSpace.define_finalizer(@session, self.class.finalize(read_pointer.to_i))
-
       @allocator = Utils.allocator
       @inputs = load_inputs
       @outputs = load_outputs
-    ensure
-      release :SessionOptions, session_options
     end
 
     def run(output_names, input_feed, log_severity_level: nil, log_verbosity_level: nil, logid: nil, terminate: nil, output_type: :ruby)
@@ -119,51 +117,57 @@ module OnnxRuntime
       # run options
       run_options = ::FFI::MemoryPointer.new(:pointer)
       check_status api[:CreateRunOptions].call(run_options)
-      check_status api[:RunOptionsSetRunLogSeverityLevel].call(run_options.read_pointer, log_severity_level) if log_severity_level
-      check_status api[:RunOptionsSetRunLogVerbosityLevel].call(run_options.read_pointer, log_verbosity_level) if log_verbosity_level
-      check_status api[:RunOptionsSetRunTag].call(run_options.read_pointer, logid) if logid
-      check_status api[:RunOptionsSetTerminate].call(run_options.read_pointer) if terminate
+      run_options = ::FFI::AutoPointer.new(run_options.read_pointer, api[:ReleaseRunOptions])
 
-      check_status api[:Run].call(read_pointer, run_options.read_pointer, input_node_names, input_tensor, input_feed.size, output_node_names, output_names.size, output_tensor)
+      check_status api[:RunOptionsSetRunLogSeverityLevel].call(run_options, log_severity_level) if log_severity_level
+      check_status api[:RunOptionsSetRunLogVerbosityLevel].call(run_options, log_verbosity_level) if log_verbosity_level
+      check_status api[:RunOptionsSetRunTag].call(run_options, logid) if logid
+      check_status api[:RunOptionsSetTerminate].call(run_options) if terminate
 
-      output_names.size.times.map { |i| OrtValue.new(output_tensor[i]) }
-    ensure
-      release :RunOptions, run_options
+      check_status api[:Run].call(@session, run_options, input_node_names, input_tensor, input_feed.size, output_node_names, output_names.size, output_tensor)
+
+      output_names.size.times.map { |i| OrtValue.new(output_tensor[i].read_pointer) }
     end
 
     def modelmeta
+      metadata = ::FFI::MemoryPointer.new(:pointer)
+      check_status api[:SessionGetModelMetadata].call(@session, metadata)
+      metadata = ::FFI::AutoPointer.new(metadata.read_pointer, api[:ReleaseModelMetadata])
+
       keys = ::FFI::MemoryPointer.new(:pointer)
       num_keys = ::FFI::MemoryPointer.new(:int64_t)
-      description = ::FFI::MemoryPointer.new(:string)
-      domain = ::FFI::MemoryPointer.new(:string)
-      graph_name = ::FFI::MemoryPointer.new(:string)
-      graph_description = ::FFI::MemoryPointer.new(:string)
-      producer_name = ::FFI::MemoryPointer.new(:string)
-      version = ::FFI::MemoryPointer.new(:int64_t)
-
-      metadata = ::FFI::MemoryPointer.new(:pointer)
-      check_status api[:SessionGetModelMetadata].call(read_pointer, metadata)
+      check_status api[:ModelMetadataGetCustomMetadataMapKeys].call(metadata, @allocator, keys, num_keys)
+      keys = keys.read_pointer
 
       custom_metadata_map = {}
-      check_status api[:ModelMetadataGetCustomMetadataMapKeys].call(metadata.read_pointer, @allocator.read_pointer, keys, num_keys)
       num_keys.read(:int64_t).times do |i|
-        key_ptr = keys.read_pointer[i * ::FFI::Pointer.size]
-        key = key_ptr.read_pointer.read_string
-        value = ::FFI::MemoryPointer.new(:string)
-        check_status api[:ModelMetadataLookupCustomMetadataMap].call(metadata.read_pointer, @allocator.read_pointer, key, value)
+        key_ptr = keys.get_pointer(i * ::FFI::Pointer.size)
+        key = key_ptr.read_string
+        value = ::FFI::MemoryPointer.new(:pointer)
+        check_status api[:ModelMetadataLookupCustomMetadataMap].call(metadata, @allocator, key, value)
         custom_metadata_map[key] = value.read_pointer.read_string
 
         allocator_free key_ptr
-        allocator_free value
+        allocator_free value.read_pointer
       end
-      allocator_free keys
 
-      check_status api[:ModelMetadataGetDescription].call(metadata.read_pointer, @allocator.read_pointer, description)
-      check_status api[:ModelMetadataGetDomain].call(metadata.read_pointer, @allocator.read_pointer, domain)
-      check_status api[:ModelMetadataGetGraphName].call(metadata.read_pointer, @allocator.read_pointer, graph_name)
-      check_status api[:ModelMetadataGetGraphDescription].call(metadata.read_pointer, @allocator.read_pointer, graph_description)
-      check_status api[:ModelMetadataGetProducerName].call(metadata.read_pointer, @allocator.read_pointer, producer_name)
-      check_status api[:ModelMetadataGetVersion].call(metadata.read_pointer, version)
+      description = ::FFI::MemoryPointer.new(:pointer)
+      check_status api[:ModelMetadataGetDescription].call(metadata, @allocator, description)
+
+      domain = ::FFI::MemoryPointer.new(:pointer)
+      check_status api[:ModelMetadataGetDomain].call(metadata, @allocator, domain)
+
+      graph_name = ::FFI::MemoryPointer.new(:pointer)
+      check_status api[:ModelMetadataGetGraphName].call(metadata, @allocator, graph_name)
+
+      graph_description = ::FFI::MemoryPointer.new(:pointer)
+      check_status api[:ModelMetadataGetGraphDescription].call(metadata, @allocator, graph_description)
+
+      producer_name = ::FFI::MemoryPointer.new(:pointer)
+      check_status api[:ModelMetadataGetProducerName].call(metadata, @allocator, producer_name)
+
+      version = ::FFI::MemoryPointer.new(:int64_t)
+      check_status api[:ModelMetadataGetVersion].call(metadata, version)
 
       {
         custom_metadata_map: custom_metadata_map,
@@ -175,19 +179,23 @@ module OnnxRuntime
         version: version.read(:int64_t)
       }
     ensure
-      release :ModelMetadata, metadata
-      allocator_free description
-      allocator_free domain
-      allocator_free graph_name
-      allocator_free graph_description
-      allocator_free producer_name
+      allocator_free keys
+      allocator_free description.read_pointer
+      allocator_free domain.read_pointer
+      allocator_free graph_name.read_pointer
+      allocator_free graph_description.read_pointer
+      allocator_free producer_name.read_pointer
     end
 
     # return value has double underscore like Python
     def end_profiling
-      out = ::FFI::MemoryPointer.new(:string)
-      check_status api[:SessionEndProfiling].call(read_pointer, @allocator.read_pointer, out)
-      out.read_pointer.read_string
+      out = ::FFI::MemoryPointer.new(:pointer)
+      check_status api[:SessionEndProfiling].call(@session, @allocator, out)
+      begin
+        out.read_pointer.read_string
+      ensure
+        allocator_free out.read_pointer
+      end
     end
 
     # no way to set providers with C API yet
@@ -197,10 +205,7 @@ module OnnxRuntime
       length_ptr = ::FFI::MemoryPointer.new(:int)
       check_status api[:GetAvailableProviders].call(out_ptr, length_ptr)
       length = length_ptr.read_int
-      providers = []
-      length.times do |i|
-        providers << out_ptr.read_pointer[i * ::FFI::Pointer.size].read_pointer.read_string
-      end
+      providers = out_ptr.read_pointer.read_array_of_pointer(length).map(&:read_string)
       api[:ReleaseAvailableProviders].call(out_ptr.read_pointer, length)
       providers
     end
@@ -208,7 +213,6 @@ module OnnxRuntime
     private
 
     def load_session(path_or_bytes, session_options)
-      session = ::FFI::MemoryPointer.new(:pointer)
       from_memory =
         if path_or_bytes.respond_to?(:read)
           path_or_bytes = path_or_bytes.read
@@ -218,44 +222,49 @@ module OnnxRuntime
           false
         end
 
+      session = ::FFI::MemoryPointer.new(:pointer)
       if from_memory
-        check_status api[:CreateSessionFromArray].call(env.read_pointer, path_or_bytes, path_or_bytes.bytesize, session_options.read_pointer, session)
+        check_status api[:CreateSessionFromArray].call(env, path_or_bytes, path_or_bytes.bytesize, session_options, session)
       else
-        check_status api[:CreateSession].call(env.read_pointer, ort_string(path_or_bytes), session_options.read_pointer, session)
+        check_status api[:CreateSession].call(env, ort_string(path_or_bytes), session_options, session)
       end
-      session
+      ::FFI::AutoPointer.new(session.read_pointer, api[:ReleaseSession])
     end
 
     def load_inputs
-      inputs = []
       num_input_nodes = ::FFI::MemoryPointer.new(:size_t)
-      check_status api[:SessionGetInputCount].call(read_pointer, num_input_nodes)
-      num_input_nodes.read(:size_t).times do |i|
-        name_ptr = ::FFI::MemoryPointer.new(:string)
-        check_status api[:SessionGetInputName].call(read_pointer, i, @allocator.read_pointer, name_ptr)
-        # freed in node_info
+      check_status api[:SessionGetInputCount].call(@session, num_input_nodes)
+
+      num_input_nodes.read(:size_t).times.map do |i|
+        name_ptr = ::FFI::MemoryPointer.new(:pointer)
+        check_status api[:SessionGetInputName].call(@session, i, @allocator, name_ptr)
+        name_str = name_ptr.read_pointer.read_string
+        allocator_free name_ptr.read_pointer
+
         typeinfo = ::FFI::MemoryPointer.new(:pointer)
-        check_status api[:SessionGetInputTypeInfo].call(read_pointer, i, typeinfo)
-        inputs << {name: name_ptr.read_pointer.read_string}.merge(Utils.node_info(typeinfo))
-        allocator_free name_ptr
+        check_status api[:SessionGetInputTypeInfo].call(@session, i, typeinfo)
+        typeinfo = ::FFI::AutoPointer.new(typeinfo.read_pointer, api[:ReleaseTypeInfo])
+
+        {name: name_str}.merge(Utils.node_info(typeinfo))
       end
-      inputs
     end
 
     def load_outputs
-      outputs = []
       num_output_nodes = ::FFI::MemoryPointer.new(:size_t)
-      check_status api[:SessionGetOutputCount].call(read_pointer, num_output_nodes)
-      num_output_nodes.read(:size_t).times do |i|
-        name_ptr = ::FFI::MemoryPointer.new(:string)
-        check_status api[:SessionGetOutputName].call(read_pointer, i, @allocator.read_pointer, name_ptr)
-        # freed in node_info
+      check_status api[:SessionGetOutputCount].call(@session, num_output_nodes)
+
+      num_output_nodes.read(:size_t).times.map do |i|
+        name_ptr = ::FFI::MemoryPointer.new(:pointer)
+        check_status api[:SessionGetOutputName].call(@session, i, @allocator, name_ptr)
+        name_str = name_ptr.read_pointer.read_string
+        allocator_free name_ptr.read_pointer
+
         typeinfo = ::FFI::MemoryPointer.new(:pointer)
-        check_status api[:SessionGetOutputTypeInfo].call(read_pointer, i, typeinfo)
-        outputs << {name: name_ptr.read_pointer.read_string}.merge(Utils.node_info(typeinfo))
-        allocator_free name_ptr
+        check_status api[:SessionGetOutputTypeInfo].call(@session, i, typeinfo)
+        typeinfo = ::FFI::AutoPointer.new(typeinfo.read_pointer, api[:ReleaseTypeInfo])
+
+        {name: name_str}.merge(Utils.node_info(typeinfo))
       end
-      outputs
     end
 
     def create_input_tensor(input_feed)
@@ -285,10 +294,6 @@ module OnnxRuntime
       ptr
     end
 
-    def read_pointer
-      @session.read_pointer
-    end
-
     def check_status(status)
       Utils.check_status(status)
     end
@@ -301,27 +306,14 @@ module OnnxRuntime
       self.class.api
     end
 
-    def release(*args)
-      self.class.release(*args)
-    end
-
     def allocator_free(ptr)
-      api[:AllocatorFree].call(@allocator.read_pointer, ptr.read_pointer)
+      api[:AllocatorFree].call(@allocator, ptr)
     end
 
     def self.api
       FFI.api
     end
 
-    def self.release(type, pointer)
-      Utils.release(type, pointer)
-    end
-
-    def self.finalize(addr)
-      # must use proc instead of stabby lambda
-      proc { api[:ReleaseSession].call(::FFI::Pointer.new(:pointer, addr)) }
-    end
-
     # wide string on Windows
     # char string on Linux
     # see ORTCHAR_T in onnxruntime_c_api.h
@@ -333,7 +325,8 @@ module OnnxRuntime
         raise Error, "Expected mbstowcs to return #{str.size}, got #{ret}" if ret != str.size
         dest
       else
-        str
+        # prevent frozen string literal warnings
+        +str
       end
     end
 
@@ -343,7 +336,7 @@ module OnnxRuntime
         @@env ||= begin
           env = ::FFI::MemoryPointer.new(:pointer)
           check_status api[:CreateEnv].call(3, "Default", env)
-          at_exit { release :Env, env }
+          env = ::FFI::AutoPointer.new(env.read_pointer, api[:ReleaseEnv])
           # disable telemetry
           # https://github.com/microsoft/onnxruntime/blob/master/docs/Privacy.md
           check_status api[:DisableTelemetryEvents].call(env)

data/lib/onnxruntime/ort_value.rb

@@ -1,9 +1,8 @@
 module OnnxRuntime
   class OrtValue
     def initialize(ptr, ref = nil)
-      @ptr = ptr.read_pointer
+      @ptr = ::FFI::AutoPointer.new(ptr, FFI.api[:ReleaseValue])
       @ref = ref # keep reference to data
-      ObjectSpace.define_finalizer(@ptr, self.class.finalize(@ptr.to_i))
     end
 
     def self.from_numo(numo_obj)
@@ -27,14 +26,14 @@ module OnnxRuntime
       if element_type == :string
         # keep reference to _str_ptrs until FillStringTensor call
         input_tensor_values, _str_ptrs = create_input_strings(input)
-        Utils.check_status FFI.api[:CreateTensorAsOrtValue].call(Utils.allocator.read_pointer, input_node_dims, shape.size, type_enum, ptr)
+        Utils.check_status FFI.api[:CreateTensorAsOrtValue].call(Utils.allocator, input_node_dims, shape.size, type_enum, ptr)
         Utils.check_status FFI.api[:FillStringTensor].call(ptr.read_pointer, input_tensor_values, input_tensor_values.size / input_tensor_values.type_size)
       else
         input_tensor_values = create_input_data(input, element_type)
-        Utils.check_status FFI.api[:CreateTensorWithDataAsOrtValue].call(allocator_info.read_pointer, input_tensor_values, input_tensor_values.size, input_node_dims, shape.size, type_enum, ptr)
+        Utils.check_status FFI.api[:CreateTensorWithDataAsOrtValue].call(allocator_info, input_tensor_values, input_tensor_values.size, input_node_dims, shape.size, type_enum, ptr)
       end
 
-      new(ptr, input_tensor_values)
+      new(ptr.read_pointer, input_tensor_values)
     end
 
     def self.from_shape_and_type(shape, element_type)
@@ -45,9 +44,9 @@ module OnnxRuntime
       input_node_dims.write_array_of_int64(shape)
 
       ptr = ::FFI::MemoryPointer.new(:pointer)
-      Utils.check_status FFI.api[:CreateTensorAsOrtValue].call(Utils.allocator.read_pointer, input_node_dims, shape.size, type_enum, ptr)
+      Utils.check_status FFI.api[:CreateTensorAsOrtValue].call(Utils.allocator, input_node_dims, shape.size, type_enum, ptr)
 
-      new(ptr)
+      new(ptr.read_pointer)
     end
 
     def self.create_input_data(input, tensor_type)
@@ -88,6 +87,7 @@ module OnnxRuntime
       @data_type ||= begin
         typeinfo = ::FFI::MemoryPointer.new(:pointer)
         Utils.check_status FFI.api[:GetTypeInfo].call(@ptr, typeinfo)
+        typeinfo = ::FFI::AutoPointer.new(typeinfo.read_pointer, FFI.api[:ReleaseTypeInfo])
         Utils.node_info(typeinfo)[:type]
       end
     end
@@ -134,13 +134,10 @@ module OnnxRuntime
 
     def type_and_shape_info
       @type_and_shape_info ||= begin
-        begin
-          typeinfo = ::FFI::MemoryPointer.new(:pointer)
-          Utils.check_status FFI.api[:GetTensorTypeAndShape].call(@ptr, typeinfo)
-          Utils.tensor_type_and_shape(typeinfo)
-        ensure
-          Utils.release :TensorTypeAndShapeInfo, typeinfo
-        end
+        typeinfo = ::FFI::MemoryPointer.new(:pointer)
+        Utils.check_status FFI.api[:GetTensorTypeAndShape].call(@ptr, typeinfo)
+        typeinfo = ::FFI::AutoPointer.new(typeinfo.read_pointer, FFI.api[:ReleaseTensorTypeAndShapeInfo])
+        Utils.tensor_type_and_shape(typeinfo)
       end
     end
 
@@ -153,6 +150,7 @@ module OnnxRuntime
       when :tensor
         typeinfo = ::FFI::MemoryPointer.new(:pointer)
         Utils.check_status FFI.api[:GetTensorTypeAndShape].call(out_ptr, typeinfo)
+        typeinfo = ::FFI::AutoPointer.new(typeinfo.read_pointer, FFI.api[:ReleaseTensorTypeAndShapeInfo])
 
         type, shape = Utils.tensor_type_and_shape(typeinfo)
 
@@ -160,11 +158,9 @@ module OnnxRuntime
         Utils.check_status FFI.api[:GetTensorMutableData].call(out_ptr, tensor_data)
 
         out_size = ::FFI::MemoryPointer.new(:size_t)
-        Utils.check_status FFI.api[:GetTensorShapeElementCount].call(typeinfo.read_pointer, out_size)
+        Utils.check_status FFI.api[:GetTensorShapeElementCount].call(typeinfo, out_size)
         output_tensor_size = out_size.read(:size_t)
 
-        Utils.release :TensorTypeAndShapeInfo, typeinfo
-
         # TODO support more types
         type = FFI::TensorElementDataType[type]
 
@@ -203,20 +199,22 @@ module OnnxRuntime
 
         out.read(:size_t).times.map do |i|
           seq = ::FFI::MemoryPointer.new(:pointer)
-          Utils.check_status FFI.api[:GetValue].call(out_ptr, i, Utils.allocator.read_pointer, seq)
+          Utils.check_status FFI.api[:GetValue].call(out_ptr, i, Utils.allocator, seq)
           create_from_onnx_value(seq.read_pointer, output_type)
         end
       when :map
-        type_shape = ::FFI::MemoryPointer.new(:pointer)
         map_keys = ::FFI::MemoryPointer.new(:pointer)
+        Utils.check_status FFI.api[:GetValue].call(out_ptr, 0, Utils.allocator, map_keys)
+
         map_values = ::FFI::MemoryPointer.new(:pointer)
-        elem_type = ::FFI::MemoryPointer.new(:int)
+        Utils.check_status FFI.api[:GetValue].call(out_ptr, 1, Utils.allocator, map_values)
 
-        Utils.check_status FFI.api[:GetValue].call(out_ptr, 0, Utils.allocator.read_pointer, map_keys)
-        Utils.check_status FFI.api[:GetValue].call(out_ptr, 1, Utils.allocator.read_pointer, map_values)
+        type_shape = ::FFI::MemoryPointer.new(:pointer)
         Utils.check_status FFI.api[:GetTensorTypeAndShape].call(map_keys.read_pointer, type_shape)
-        Utils.check_status FFI.api[:GetTensorElementType].call(type_shape.read_pointer, elem_type)
-        Utils.release :TensorTypeAndShapeInfo, type_shape
+        type_shape = ::FFI::AutoPointer.new(type_shape.read_pointer, FFI.api[:ReleaseTensorTypeAndShapeInfo])
+
+        elem_type = ::FFI::MemoryPointer.new(:int)
+        Utils.check_status FFI.api[:GetTensorElementType].call(type_shape, elem_type)
 
         # TODO support more types
         elem_type = FFI::TensorElementDataType[elem_type.read_int]
@@ -255,23 +253,17 @@ module OnnxRuntime
     end
 
     def reshape(arr, dims)
-      arr = arr.flatten
       dims[1..-1].reverse_each do |dim|
         arr = arr.each_slice(dim)
       end
       arr.to_a
     end
 
-    def self.finalize(addr)
-      # must use proc instead of stabby lambda
-      proc { FFI.api[:ReleaseValue].call(::FFI::Pointer.new(:pointer, addr)) }
-    end
-
     def self.allocator_info
       @allocator_info ||= begin
         allocator_info = ::FFI::MemoryPointer.new(:pointer)
         Utils.check_status FFI.api[:CreateCpuMemoryInfo].call(1, 0, allocator_info)
-        allocator_info
+        ::FFI::AutoPointer.new(allocator_info.read_pointer, FFI.api[:ReleaseMemoryInfo])
       end
     end
   end