onnxruntime 0.10.2-aarch64-linux → 0.11.0-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f9c82a606f3d4c9df49b98ea2242b0d9b87a89b2e4c5eecbaee7b07bd9eedd60
-  data.tar.gz: 55cd86025e9f8335a26e26e8066e3a8e91c0c5cddc5dd4e081766b5d02de0daf
+  metadata.gz: 66dadc7597304d333d32c30098ad235652d696352fb75c85561d09acd42a3b58
+  data.tar.gz: b010ec14f69aa0f58a7b25197b684e2c658157c0412647ee59994cf8e51fa52b
 SHA512:
-  metadata.gz: a599b44b439cb912f59a9c7bdcfdeb807e8ffba392f15fe8e940860876d053ba28fddec1f05d03b9870ff605c1dfe28fb02f399caad075623745f1dffd94ac79
-  data.tar.gz: 0a59400d108d9db50fd0fe3e1f703b9b6e72be41c334d76f1375360e40d4e0acc10cbd3b77ca56d18106488a65eea68d028ff31333f6fe862c3b155a6a88239f
+  metadata.gz: 20a15fc6002173ebef6241ae36b9aa652af8d07c0bbf6dc635108c258f842c729f03ad3c480feb81ebf6befd3512ca9d669f678d080fa332dd40ce4b06f8dbf0
+  data.tar.gz: 8eff1bb690d3e1c901897c227a00b1c5bb8047641c0e022a3c9a42097c12dc1a9220590ca351841ccf30d49b57b49bdcc7e4d1574b0b664bc90f5287559878c6

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 0.11.0 (2026-02-22)
+
+- Updated ONNX Runtime to 1.24.2
+- Dropped shared library for Mac x86-64 (no longer provided by upstream)
+
 ## 0.10.2 (2026-02-19)
 
 - Fixed uncaught exception with `CoreMLExecutionProvider`

data/README.md

@@ -16,6 +16,8 @@ Add this line to your application’s Gemfile:
 gem "onnxruntime"
 ```
 
+On Mac x86-64, also run `brew install onnxruntime` to install the shared library
+
 ## Getting Started
 
 Load a model and make predictions

data/lib/onnxruntime/ffi.rb

@@ -2,12 +2,20 @@ module OnnxRuntime
   module FFI
     extend ::FFI::Library
 
-    ffi_lib OnnxRuntime.ffi_lib
+    begin
+      ffi_lib OnnxRuntime.ffi_lib
+    rescue LoadError => e
+      if e.message.include?("Could not open library '/usr/local/opt/onnxruntime/lib/libonnxruntime.dylib'")
+        raise LoadError, "ONNX Runtime not found. Run `brew install onnxruntime`"
+      else
+        raise e
+      end
+    end
 
     # https://github.com/microsoft/onnxruntime/blob/master/include/onnxruntime/core/session/onnxruntime_c_api.h
     # keep same order
 
-    ORT_API_VERSION = 16
+    ORT_API_VERSION = 24
 
     # enums
     TensorElementDataType = enum(:undefined, :float, :uint8, :int8, :uint16, :int16, :int32, :int64, :string, :bool, :float16, :double, :uint32, :uint64, :complex64, :complex128, :bfloat16)

data/lib/onnxruntime/inference_session.rb

@@ -7,9 +7,8 @@ module OnnxRuntime
       env
 
       # 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])
+      session_options = Pointer.new(api[:ReleaseSessionOptions])
+      check_status api[:CreateSessionOptions].call(session_options.ref)
 
       if enable_cpu_mem_arena
         check_status api[:EnableCpuMemArena].call(session_options)
@@ -67,9 +66,8 @@ module OnnxRuntime
 
         case provider
         when "CUDAExecutionProvider"
-          cuda_options = ::FFI::MemoryPointer.new(:pointer)
-          check_status api[:CreateCUDAProviderOptions].call(cuda_options)
-          cuda_options = ::FFI::AutoPointer.new(cuda_options.read_pointer, api[:ReleaseCUDAProviderOptions])
+          cuda_options = Pointer.new(api[:ReleaseCUDAProviderOptions])
+          check_status api[:CreateCUDAProviderOptions].call(cuda_options.ref)
           check_status api[:SessionOptionsAppendExecutionProvider_CUDA_V2].call(session_options, cuda_options)
         when "CoreMLExecutionProvider"
           unless FFI.respond_to?(:OrtSessionOptionsAppendExecutionProvider_CoreML)
@@ -106,9 +104,7 @@ module OnnxRuntime
     # TODO support logid
     def run_with_ort_values(output_names, input_feed, log_severity_level: nil, log_verbosity_level: nil, logid: nil, terminate: nil)
       input_tensor = ::FFI::MemoryPointer.new(:pointer, input_feed.size)
-      input_feed.each_with_index do |(_, input), i|
-        input_tensor[i].write_pointer(input.to_ptr)
-      end
+      input_tensor.write_array_of_pointer(input_feed.values)
 
       output_names ||= @outputs.map { |v| v[:name] }
 
@@ -118,9 +114,8 @@ module OnnxRuntime
       output_node_names = create_node_names(output_names.map(&:to_s), refs)
 
       # run options
-      run_options = ::FFI::MemoryPointer.new(:pointer)
-      check_status api[:CreateRunOptions].call(run_options)
-      run_options = ::FFI::AutoPointer.new(run_options.read_pointer, api[:ReleaseRunOptions])
+      run_options = Pointer.new(api[:ReleaseRunOptions])
+      check_status api[:CreateRunOptions].call(run_options.ref)
 
       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
@@ -129,51 +124,42 @@ module OnnxRuntime
 
       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) }
+      output_tensor.read_array_of_pointer(output_names.size).map { |v| OrtValue.new(v) }
     end
 
     def modelmeta
-      metadata = ::FFI::MemoryPointer.new(:pointer)
-      check_status api[:SessionGetModelMetadata].call(@session, metadata)
-      metadata = ::FFI::AutoPointer.new(metadata.read_pointer, api[:ReleaseModelMetadata])
+      metadata = Pointer.new(api[:ReleaseModelMetadata])
+      check_status api[:SessionGetModelMetadata].call(@session, metadata.ref)
 
-      keys = ::FFI::MemoryPointer.new(:pointer)
+      keys = Pointer.new(method(:allocator_free))
       num_keys = ::FFI::MemoryPointer.new(:int64_t)
-      check_status api[:ModelMetadataGetCustomMetadataMapKeys].call(metadata, @allocator, keys, num_keys)
-      keys = ::FFI::AutoPointer.new(keys.read_pointer, method(:allocator_free))
+      check_status api[:ModelMetadataGetCustomMetadataMapKeys].call(metadata, @allocator, keys.ref, num_keys)
       key_ptrs =
         keys.read_array_of_pointer(num_keys.read(:int64_t)).map do |ptr|
           ::FFI::AutoPointer.new(ptr, method(:allocator_free))
         end
 
-      custom_metadata_map = {}
-      key_ptrs.each do |key_ptr|
-        key = key_ptr.read_string
-        value = ::FFI::MemoryPointer.new(:pointer)
-        check_status api[:ModelMetadataLookupCustomMetadataMap].call(metadata, @allocator, key, value)
-        value = ::FFI::AutoPointer.new(value.read_pointer, method(:allocator_free))
-        custom_metadata_map[key] = value.read_string
-      end
+      custom_metadata_map =
+        key_ptrs.to_h do |key|
+          value = Pointer.new(method(:allocator_free))
+          check_status api[:ModelMetadataLookupCustomMetadataMap].call(metadata, @allocator, key, value.ref)
+          [key.read_string, value.read_string]
+        end
 
-      description = ::FFI::MemoryPointer.new(:pointer)
-      check_status api[:ModelMetadataGetDescription].call(metadata, @allocator, description)
-      description = ::FFI::AutoPointer.new(description.read_pointer, method(:allocator_free))
+      description = Pointer.new(method(:allocator_free))
+      check_status api[:ModelMetadataGetDescription].call(metadata, @allocator, description.ref)
 
-      domain = ::FFI::MemoryPointer.new(:pointer)
-      check_status api[:ModelMetadataGetDomain].call(metadata, @allocator, domain)
-      domain = ::FFI::AutoPointer.new(domain.read_pointer, method(:allocator_free))
+      domain = Pointer.new(method(:allocator_free))
+      check_status api[:ModelMetadataGetDomain].call(metadata, @allocator, domain.ref)
 
-      graph_name = ::FFI::MemoryPointer.new(:pointer)
-      check_status api[:ModelMetadataGetGraphName].call(metadata, @allocator, graph_name)
-      graph_name = ::FFI::AutoPointer.new(graph_name.read_pointer, method(:allocator_free))
+      graph_name = Pointer.new(method(:allocator_free))
+      check_status api[:ModelMetadataGetGraphName].call(metadata, @allocator, graph_name.ref)
 
-      graph_description = ::FFI::MemoryPointer.new(:pointer)
-      check_status api[:ModelMetadataGetGraphDescription].call(metadata, @allocator, graph_description)
-      graph_description = ::FFI::AutoPointer.new(graph_description.read_pointer, method(:allocator_free))
+      graph_description = Pointer.new(method(:allocator_free))
+      check_status api[:ModelMetadataGetGraphDescription].call(metadata, @allocator, graph_description.ref)
 
-      producer_name = ::FFI::MemoryPointer.new(:pointer)
-      check_status api[:ModelMetadataGetProducerName].call(metadata, @allocator, producer_name)
-      producer_name = ::FFI::AutoPointer.new(producer_name.read_pointer, method(:allocator_free))
+      producer_name = Pointer.new(method(:allocator_free))
+      check_status api[:ModelMetadataGetProducerName].call(metadata, @allocator, producer_name.ref)
 
       version = ::FFI::MemoryPointer.new(:int64_t)
       check_status api[:ModelMetadataGetVersion].call(metadata, version)
@@ -191,23 +177,22 @@ module OnnxRuntime
 
     # return value has double underscore like Python
     def end_profiling
-      out = ::FFI::MemoryPointer.new(:pointer)
-      check_status api[:SessionEndProfiling].call(@session, @allocator, out)
-      out = ::FFI::AutoPointer.new(out.read_pointer, method(:allocator_free))
+      out = Pointer.new(method(:allocator_free))
+      check_status api[:SessionEndProfiling].call(@session, @allocator, out.ref)
       out.read_string
     end
 
     # no way to set providers with C API yet
     # so we can return all available providers
     def providers
-      out_ptr = ::FFI::MemoryPointer.new(:pointer)
+      out_ptr = Pointer.new
       length_ptr = ::FFI::MemoryPointer.new(:int)
-      check_status api[:GetAvailableProviders].call(out_ptr, length_ptr)
+      check_status api[:GetAvailableProviders].call(out_ptr.ref, length_ptr)
       length = length_ptr.read_int
       begin
-        out_ptr.read_pointer.read_array_of_pointer(length).map(&:read_string)
+        out_ptr.read_array_of_pointer(length).map(&:read_string)
       ensure
-        api[:ReleaseAvailableProviders].call(out_ptr.read_pointer, length)
+        api[:ReleaseAvailableProviders].call(out_ptr, length)
       end
     end
 
@@ -223,13 +208,13 @@ module OnnxRuntime
           false
         end
 
-      session = ::FFI::MemoryPointer.new(:pointer)
+      session = Pointer.new(api[:ReleaseSession])
       if from_memory
-        check_status api[:CreateSessionFromArray].call(env, path_or_bytes, path_or_bytes.bytesize, session_options, session)
+        check_status api[:CreateSessionFromArray].call(env, path_or_bytes, path_or_bytes.bytesize, session_options, session.ref)
       else
-        check_status api[:CreateSession].call(env, ort_string(path_or_bytes), session_options, session)
+        check_status api[:CreateSession].call(env, ort_string(path_or_bytes), session_options, session.ref)
       end
-      ::FFI::AutoPointer.new(session.read_pointer, api[:ReleaseSession])
+      session
     end
 
     def load_inputs
@@ -237,13 +222,11 @@ module OnnxRuntime
       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_ptr = ::FFI::AutoPointer.new(name_ptr.read_pointer, method(:allocator_free))
+        name_ptr = Pointer.new(method(:allocator_free))
+        check_status api[:SessionGetInputName].call(@session, i, @allocator, name_ptr.ref)
 
-        typeinfo = ::FFI::MemoryPointer.new(:pointer)
-        check_status api[:SessionGetInputTypeInfo].call(@session, i, typeinfo)
-        typeinfo = ::FFI::AutoPointer.new(typeinfo.read_pointer, api[:ReleaseTypeInfo])
+        typeinfo = Pointer.new(api[:ReleaseTypeInfo])
+        check_status api[:SessionGetInputTypeInfo].call(@session, i, typeinfo.ref)
 
         {name: name_ptr.read_string}.merge(Utils.node_info(typeinfo))
       end
@@ -254,13 +237,11 @@ module OnnxRuntime
       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_ptr = ::FFI::AutoPointer.new(name_ptr.read_pointer, method(:allocator_free))
+        name_ptr = Pointer.new(method(:allocator_free))
+        check_status api[:SessionGetOutputName].call(@session, i, @allocator, name_ptr.ref)
 
-        typeinfo = ::FFI::MemoryPointer.new(:pointer)
-        check_status api[:SessionGetOutputTypeInfo].call(@session, i, typeinfo)
-        typeinfo = ::FFI::AutoPointer.new(typeinfo.read_pointer, api[:ReleaseTypeInfo])
+        typeinfo = Pointer.new(api[:ReleaseTypeInfo])
+        check_status api[:SessionGetOutputTypeInfo].call(@session, i, typeinfo.ref)
 
         {name: name_ptr.read_string}.merge(Utils.node_info(typeinfo))
       end
@@ -333,9 +314,8 @@ module OnnxRuntime
       # use mutex for thread-safety
       Utils.mutex.synchronize do
         @@env ||= begin
-          env = ::FFI::MemoryPointer.new(:pointer)
-          check_status api[:CreateEnv].call(3, "Default", env)
-          env = ::FFI::AutoPointer.new(env.read_pointer, api[:ReleaseEnv])
+          env = Pointer.new(api[:ReleaseEnv])
+          check_status api[:CreateEnv].call(3, "Default", env.ref)
           # disable telemetry
           # https://github.com/microsoft/onnxruntime/blob/master/docs/Privacy.md
           check_status api[:DisableTelemetryEvents].call(env)

data/lib/onnxruntime/model.rb

@@ -7,12 +7,7 @@ module OnnxRuntime
     def predict(input_feed, output_names: nil, **run_options)
       predictions = @session.run(output_names, input_feed, **run_options)
       output_names ||= outputs.map { |o| o[:name] }
-
-      result = {}
-      output_names.zip(predictions).each do |k, v|
-        result[k.to_s] = v
-      end
-      result
+      output_names.zip(predictions).to_h { |k, v| [k.to_s, v] }
     end
 
     def inputs

data/lib/onnxruntime/ort_value.rb

@@ -22,18 +22,18 @@ module OnnxRuntime
       input_node_dims = ::FFI::MemoryPointer.new(:int64, shape.size)
       input_node_dims.write_array_of_int64(shape)
 
-      ptr = ::FFI::MemoryPointer.new(:pointer)
+      ptr = Pointer.new
       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, 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)
+        Utils.check_status FFI.api[:CreateTensorAsOrtValue].call(Utils.allocator, input_node_dims, shape.size, type_enum, ptr.ref)
+        Utils.check_status FFI.api[:FillStringTensor].call(ptr, 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, 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.ref)
       end
 
-      new(ptr.read_pointer, input_tensor_values)
+      new(ptr.to_ptr, input_tensor_values)
     end
 
     def self.from_shape_and_type(shape, element_type)
@@ -43,10 +43,10 @@ module OnnxRuntime
       input_node_dims = ::FFI::MemoryPointer.new(:int64, shape.size)
       input_node_dims.write_array_of_int64(shape)
 
-      ptr = ::FFI::MemoryPointer.new(:pointer)
-      Utils.check_status FFI.api[:CreateTensorAsOrtValue].call(Utils.allocator, input_node_dims, shape.size, type_enum, ptr)
+      ptr = Pointer.new
+      Utils.check_status FFI.api[:CreateTensorAsOrtValue].call(Utils.allocator, input_node_dims, shape.size, type_enum, ptr.ref)
 
-      new(ptr.read_pointer)
+      new(ptr.to_ptr)
     end
 
     def self.create_input_data(input, tensor_type)
@@ -85,9 +85,8 @@ module OnnxRuntime
 
     def data_type
       @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])
+        typeinfo = Pointer.new(FFI.api[:ReleaseTypeInfo])
+        Utils.check_status FFI.api[:GetTypeInfo].call(@ptr, typeinfo.ref)
         Utils.node_info(typeinfo)[:type]
       end
     end
@@ -117,9 +116,9 @@ module OnnxRuntime
     end
 
     def data_ptr
-      tensor_data = ::FFI::MemoryPointer.new(:pointer)
-      FFI.api[:GetTensorMutableData].call(@ptr, tensor_data)
-      tensor_data.read_pointer
+      tensor_data = Pointer.new
+      FFI.api[:GetTensorMutableData].call(@ptr, tensor_data.ref)
+      tensor_data.to_ptr
     end
 
     private
@@ -134,9 +133,8 @@ module OnnxRuntime
 
     def type_and_shape_info
       @type_and_shape_info ||= begin
-        typeinfo = ::FFI::MemoryPointer.new(:pointer)
-        Utils.check_status FFI.api[:GetTensorTypeAndShape].call(@ptr, typeinfo)
-        typeinfo = ::FFI::AutoPointer.new(typeinfo.read_pointer, FFI.api[:ReleaseTensorTypeAndShapeInfo])
+        typeinfo = Pointer.new(FFI.api[:ReleaseTensorTypeAndShapeInfo])
+        Utils.check_status FFI.api[:GetTensorTypeAndShape].call(@ptr, typeinfo.ref)
         Utils.tensor_type_and_shape(typeinfo)
       end
     end
@@ -148,14 +146,13 @@ module OnnxRuntime
 
       case type
       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])
+        typeinfo = Pointer.new(FFI.api[:ReleaseTensorTypeAndShapeInfo])
+        Utils.check_status FFI.api[:GetTensorTypeAndShape].call(out_ptr, typeinfo.ref)
 
         type, shape = Utils.tensor_type_and_shape(typeinfo)
 
-        tensor_data = ::FFI::MemoryPointer.new(:pointer)
-        Utils.check_status FFI.api[:GetTensorMutableData].call(out_ptr, tensor_data)
+        tensor_data = Pointer.new
+        Utils.check_status FFI.api[:GetTensorMutableData].call(out_ptr, tensor_data.ref)
 
         out_size = ::FFI::MemoryPointer.new(:size_t)
         Utils.check_status FFI.api[:GetTensorShapeElementCount].call(typeinfo, out_size)
@@ -174,15 +171,15 @@ module OnnxRuntime
           else
             numo_type = Utils.numo_types[type]
             Utils.unsupported_type("element", type) unless numo_type
-            numo_type.from_binary(tensor_data.read_pointer.read_bytes(output_tensor_size * numo_type::ELEMENT_BYTE_SIZE), shape)
+            numo_type.from_binary(tensor_data.to_ptr.read_bytes(output_tensor_size * numo_type::ELEMENT_BYTE_SIZE), shape)
           end
         when :ruby
           arr =
             case type
             when :float, :uint8, :int8, :uint16, :int16, :int32, :int64, :double, :uint32, :uint64
-              tensor_data.read_pointer.send("read_array_of_#{type}", output_tensor_size)
+              tensor_data.to_ptr.send("read_array_of_#{type}", output_tensor_size)
             when :bool
-              tensor_data.read_pointer.read_array_of_uint8(output_tensor_size).map { |v| v == 1 }
+              tensor_data.to_ptr.read_array_of_uint8(output_tensor_size).map { |v| v == 1 }
             when :string
               create_strings_from_onnx_value(out_ptr, output_tensor_size, [])
             else
@@ -198,23 +195,19 @@ module OnnxRuntime
         Utils.check_status FFI.api[:GetValueCount].call(out_ptr, out)
 
         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, seq)
-          seq = ::FFI::AutoPointer.new(seq.read_pointer, FFI.api[:ReleaseValue])
+          seq = Pointer.new(FFI.api[:ReleaseValue])
+          Utils.check_status FFI.api[:GetValue].call(out_ptr, i, Utils.allocator, seq.ref)
           create_from_onnx_value(seq, output_type)
         end
       when :map
-        map_keys = ::FFI::MemoryPointer.new(:pointer)
-        Utils.check_status FFI.api[:GetValue].call(out_ptr, 0, Utils.allocator, map_keys)
-        map_keys = ::FFI::AutoPointer.new(map_keys.read_pointer, FFI.api[:ReleaseValue])
+        map_keys = Pointer.new(FFI.api[:ReleaseValue])
+        Utils.check_status FFI.api[:GetValue].call(out_ptr, 0, Utils.allocator, map_keys.ref)
 
-        map_values = ::FFI::MemoryPointer.new(:pointer)
-        Utils.check_status FFI.api[:GetValue].call(out_ptr, 1, Utils.allocator, map_values)
-        map_values = ::FFI::AutoPointer.new(map_values.read_pointer, FFI.api[:ReleaseValue])
+        map_values = Pointer.new(FFI.api[:ReleaseValue])
+        Utils.check_status FFI.api[:GetValue].call(out_ptr, 1, Utils.allocator, map_values.ref)
 
-        type_shape = ::FFI::MemoryPointer.new(:pointer)
-        Utils.check_status FFI.api[:GetTensorTypeAndShape].call(map_keys, type_shape)
-        type_shape = ::FFI::AutoPointer.new(type_shape.read_pointer, FFI.api[:ReleaseTensorTypeAndShapeInfo])
+        type_shape = Pointer.new(FFI.api[:ReleaseTensorTypeAndShapeInfo])
+        Utils.check_status FFI.api[:GetTensorTypeAndShape].call(map_keys, type_shape.ref)
 
         elem_type = ::FFI::MemoryPointer.new(:int)
         Utils.check_status FFI.api[:GetTensorElementType].call(type_shape, elem_type)
@@ -223,13 +216,9 @@ module OnnxRuntime
         elem_type = FFI::TensorElementDataType[elem_type.read_int]
         case elem_type
         when :int64
-          ret = {}
           keys = create_from_onnx_value(map_keys, output_type)
           values = create_from_onnx_value(map_values, output_type)
-          keys.zip(values).each do |k, v|
-            ret[k] = v
-          end
-          ret
+          keys.zip(values).to_h
         else
           Utils.unsupported_type("element", elem_type)
         end
@@ -264,9 +253,9 @@ module OnnxRuntime
 
     def self.allocator_info
       @allocator_info ||= begin
-        allocator_info = ::FFI::MemoryPointer.new(:pointer)
-        Utils.check_status FFI.api[:CreateCpuMemoryInfo].call(1, 0, allocator_info)
-        ::FFI::AutoPointer.new(allocator_info.read_pointer, FFI.api[:ReleaseMemoryInfo])
+        allocator_info = Pointer.new(FFI.api[:ReleaseMemoryInfo])
+        Utils.check_status FFI.api[:CreateCpuMemoryInfo].call(1, 0, allocator_info.ref)
+        allocator_info
       end
     end
   end

data/lib/onnxruntime/pointer.rb

@@ -0,0 +1,29 @@
+module OnnxRuntime
+  class Pointer
+    attr_reader :ref
+
+    def initialize(free = nil)
+      @ref = ::FFI::MemoryPointer.new(:pointer)
+      ObjectSpace.define_finalizer(self, self.class.finalize(@ref, free)) if free
+    end
+
+    def self.finalize(ref, free)
+      proc do
+        ptr = ref.read_pointer
+        free.(ptr) unless ptr.null?
+      end
+    end
+
+    def to_ptr
+      @ref.read_pointer
+    end
+
+    def read_string(...)
+      to_ptr.read_string(...)
+    end
+
+    def read_array_of_pointer(...)
+      to_ptr.read_array_of_pointer(...)
+    end
+  end
+end

data/lib/onnxruntime/utils.rb

@@ -49,9 +49,9 @@ module OnnxRuntime
       case type
       when :tensor
         # don't free tensor_info
-        tensor_info = ::FFI::MemoryPointer.new(:pointer)
-        check_status api[:CastTypeInfoToTensorInfo].call(typeinfo, tensor_info)
-        type, shape = Utils.tensor_type_and_shape(tensor_info.read_pointer)
+        tensor_info = Pointer.new
+        check_status api[:CastTypeInfoToTensorInfo].call(typeinfo, tensor_info.ref)
+        type, shape = Utils.tensor_type_and_shape(tensor_info)
 
         {
           type: "tensor(#{FFI::TensorElementDataType[type]})",
@@ -59,12 +59,11 @@ module OnnxRuntime
         }
       when :sequence
         # don't free sequence_info
-        sequence_type_info = ::FFI::MemoryPointer.new(:pointer)
-        check_status api[:CastTypeInfoToSequenceTypeInfo].call(typeinfo, sequence_type_info)
+        sequence_type_info = Pointer.new
+        check_status api[:CastTypeInfoToSequenceTypeInfo].call(typeinfo, sequence_type_info.ref)
 
-        nested_type_info = ::FFI::MemoryPointer.new(:pointer)
-        check_status api[:GetSequenceElementType].call(sequence_type_info.read_pointer, nested_type_info)
-        nested_type_info = ::FFI::AutoPointer.new(nested_type_info.read_pointer, api[:ReleaseTypeInfo])
+        nested_type_info = Pointer.new(api[:ReleaseTypeInfo])
+        check_status api[:GetSequenceElementType].call(sequence_type_info, nested_type_info.ref)
         v = node_info(nested_type_info)[:type]
 
         {
@@ -73,18 +72,17 @@ module OnnxRuntime
         }
       when :map
         # don't free map_type_info
-        map_type_info = ::FFI::MemoryPointer.new(:pointer)
-        check_status api[:CastTypeInfoToMapTypeInfo].call(typeinfo, map_type_info)
+        map_type_info = Pointer.new
+        check_status api[:CastTypeInfoToMapTypeInfo].call(typeinfo, map_type_info.ref)
 
         # key
         key_type = ::FFI::MemoryPointer.new(:int)
-        check_status api[:GetMapKeyType].call(map_type_info.read_pointer, key_type)
+        check_status api[:GetMapKeyType].call(map_type_info, key_type)
         k = FFI::TensorElementDataType[key_type.read_int]
 
         # value
-        value_type_info = ::FFI::MemoryPointer.new(:pointer)
-        check_status api[:GetMapValueType].call(map_type_info.read_pointer, value_type_info)
-        value_type_info = ::FFI::AutoPointer.new(value_type_info.read_pointer, api[:ReleaseTypeInfo])
+        value_type_info = Pointer.new(api[:ReleaseTypeInfo])
+        check_status api[:GetMapValueType].call(map_type_info, value_type_info.ref)
         v = node_info(value_type_info)[:type]
 
         {
@@ -132,9 +130,10 @@ module OnnxRuntime
 
     def self.allocator
       @allocator ||= begin
-        allocator = ::FFI::MemoryPointer.new(:pointer)
-        check_status api[:GetAllocatorWithDefaultOptions].call(allocator)
-        allocator.read_pointer # do not free default allocator
+        # do not free default allocator
+        allocator = Pointer.new
+        check_status api[:GetAllocatorWithDefaultOptions].call(allocator.ref)
+        allocator
       end
     end
   end

data/lib/onnxruntime/version.rb

@@ -1,3 +1,3 @@
 module OnnxRuntime
-  VERSION = "0.10.2"
+  VERSION = "0.11.0"
 end

data/lib/onnxruntime.rb

@@ -6,6 +6,7 @@ require_relative "onnxruntime/datasets"
 require_relative "onnxruntime/inference_session"
 require_relative "onnxruntime/model"
 require_relative "onnxruntime/ort_value"
+require_relative "onnxruntime/pointer"
 require_relative "onnxruntime/utils"
 require_relative "onnxruntime/version"
 
@@ -15,24 +16,24 @@ module OnnxRuntime
   class << self
     attr_accessor :ffi_lib
   end
+  vendor = File.expand_path("../vendor", __dir__)
   lib_name =
     if Gem.win_platform?
-      "onnxruntime.dll"
+      "#{vendor}/onnxruntime.dll"
     elsif RbConfig::CONFIG["host_os"] =~ /darwin/i
       if RbConfig::CONFIG["host_cpu"] =~ /arm|aarch64/i
-        "libonnxruntime.arm64.dylib"
+        "#{vendor}/libonnxruntime.arm64.dylib"
       else
-        "libonnxruntime.dylib"
+        "/usr/local/opt/onnxruntime/lib/libonnxruntime.dylib"
       end
     else
       if RbConfig::CONFIG["host_cpu"] =~ /arm|aarch64/i
-        "libonnxruntime.arm64.so"
+        "#{vendor}/libonnxruntime.arm64.so"
       else
-        "libonnxruntime.so"
+        "#{vendor}/libonnxruntime.so"
       end
     end
-  vendor_lib = File.expand_path("../vendor/#{lib_name}", __dir__)
-  self.ffi_lib = [vendor_lib]
+  self.ffi_lib = [lib_name]
 
   def self.lib_version
     FFI.OrtGetApiBase[:GetVersionString].call.read_string

data/vendor/ThirdPartyNotices.txt

@@ -5806,41 +5806,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 _____
 
-composable_kernel
-
-https://github.com/ROCmSoftwarePlatform/composable_kernel
-
-Copyright (c) 2018-    , Advanced Micro Devices, Inc. (Chao Liu, Jing Zhang)
-Copyright (c) 2019-    , Advanced Micro Devices, Inc. (Letao Qin, Qianfeng Zhang, Liang Huang, Shaojie Wang)
-Copyright (c) 2022-    , Advanced Micro Devices, Inc. (Anthony Chang, Chunyu Lai, Illia Silin, Adam Osewski, Poyen Chen, Jehandad Khan)
-Copyright (c) 2019-2021, Advanced Micro Devices, Inc. (Hanwen Chang)
-Copyright (c) 2019-2020, Advanced Micro Devices, Inc. (Tejash Shah)
-Copyright (c) 2020     , Advanced Micro Devices, Inc. (Xiaoyan Zhou)
-Copyright (c) 2021-2022, Advanced Micro Devices, Inc. (Jianfeng Yan)
-
-SPDX-License-Identifier: MIT
-Copyright (c) 2018-2023, Advanced Micro Devices, Inc. All rights reserved.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-
-_____
-
 neural-speed
 
 https://github.com/intel/neural-speed

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: onnxruntime
 version: !ruby/object:Gem::Version
-  version: 0.10.2
+  version: 0.11.0
 platform: aarch64-linux
 authors:
 - Andrew Kane
@@ -37,6 +37,7 @@ files:
 - lib/onnxruntime/inference_session.rb
 - lib/onnxruntime/model.rb
 - lib/onnxruntime/ort_value.rb
+- lib/onnxruntime/pointer.rb
 - lib/onnxruntime/utils.rb
 - lib/onnxruntime/version.rb
 - vendor/LICENSE