onnxruntime 0.10.1 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ddf24b881b18a6adf439e7d835baa3092222b3e7bfb87f15be0b1b6668cc0bbf
-  data.tar.gz: f9a52098345b401b706d5675b1ca3e1e6b209a4e1f446ff8441e8d27a722ea25
+  metadata.gz: d6e2e19cb7a47b9fcf2adfeebb1606ef754e9a72497f3a75effa61b0bd20679b
+  data.tar.gz: 3f7d7ffd49dda192c7bc835912cdfbbe2726930cbe4615b75c84c6de41af9d8e
 SHA512:
-  metadata.gz: 84b0e4d4c623f57689d25e1658fc3abba1ce0fffa41641b2474ad8ada83de7ef4f592dd28f4929e2cb388bee7408cc007d69fe8ea46a612803924cb90ce8e24f
-  data.tar.gz: bf122bd7ba8048c7d5b6336ec33375632cbbe979db253d0b61c5f80e35097097a353f85ffd4f6a33f470266513b64f698cc21942375b67337be095325ffab4ce
+  metadata.gz: d60433135876cd75dfef93832ae691e4845b14197f980ec77a0e954ca5795271a51620beff55e44d65839313d613f80e64754058a753895f8bf48807120b081a
+  data.tar.gz: fa3d7e675b8e3401948391b8d61b48f03a8e2b3972d1257a91bfd23fb4bc67771b20fc3ac29bf4d10e641295ffcf2ef13c6d9923694ea428de7083fd29383bc9

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+## 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`
+- Fixed memory leak with `map` and `seq` outputs
+
 ## 0.10.1 (2025-09-30)
 
 - Updated ONNX Runtime to 1.23.0

data/LICENSE.txt

@@ -1,7 +1,7 @@
 MIT License
 
 Copyright (c) Microsoft Corporation
-Copyright (c) 2019-2025 Andrew Kane
+Copyright (c) 2019-2026 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

@@ -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

@@ -3,10 +3,12 @@ module OnnxRuntime
     attr_reader :inputs, :outputs
 
     def initialize(path_or_bytes, enable_cpu_mem_arena: true, enable_mem_pattern: true, enable_profiling: false, execution_mode: nil, free_dimension_overrides_by_denotation: nil, free_dimension_overrides_by_name: nil, graph_optimization_level: nil, inter_op_num_threads: nil, intra_op_num_threads: nil, log_severity_level: nil, log_verbosity_level: nil, logid: nil, optimized_model_filepath: nil, profile_file_prefix: nil, session_config_entries: nil, providers: [])
+      # create environment first to prevent uncaught exception with CoreMLExecutionProvider
+      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)
@@ -64,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)
@@ -103,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] }
 
@@ -115,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
@@ -126,88 +124,76 @@ 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 = keys.read_pointer
-
-      custom_metadata_map = {}
-      num_keys.read(:int64_t).times do |i|
-        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.read_pointer
-      end
+      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.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 = 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 = 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 = 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 = 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 = 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)
 
       {
         custom_metadata_map: custom_metadata_map,
-        description: description.read_pointer.read_string,
-        domain: domain.read_pointer.read_string,
-        graph_name: graph_name.read_pointer.read_string,
-        graph_description: graph_description.read_pointer.read_string,
-        producer_name: producer_name.read_pointer.read_string,
+        description: description.read_string,
+        domain: domain.read_string,
+        graph_name: graph_name.read_string,
+        graph_description: graph_description.read_string,
+        producer_name: producer_name.read_string,
         version: version.read(:int64_t)
       }
-    ensure
-      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(:pointer)
-      check_status api[:SessionEndProfiling].call(@session, @allocator, out)
-      begin
-        out.read_pointer.read_string
-      ensure
-        allocator_free out.read_pointer
-      end
+      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
-      providers = out_ptr.read_pointer.read_array_of_pointer(length).map(&:read_string)
-      api[:ReleaseAvailableProviders].call(out_ptr.read_pointer, length)
-      providers
+      begin
+        out_ptr.read_array_of_pointer(length).map(&:read_string)
+      ensure
+        api[:ReleaseAvailableProviders].call(out_ptr, length)
+      end
     end
 
     private
@@ -222,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
@@ -236,16 +222,13 @@ 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_str = name_ptr.read_pointer.read_string
-        allocator_free name_ptr.read_pointer
+        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_str}.merge(Utils.node_info(typeinfo))
+        {name: name_ptr.read_string}.merge(Utils.node_info(typeinfo))
       end
     end
 
@@ -254,16 +237,13 @@ 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_str = name_ptr.read_pointer.read_string
-        allocator_free name_ptr.read_pointer
+        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_str}.merge(Utils.node_info(typeinfo))
+        {name: name_ptr.read_string}.merge(Utils.node_info(typeinfo))
       end
     end
 
@@ -334,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,20 +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)
-          create_from_onnx_value(seq.read_pointer, output_type)
+          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 = 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 = 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.read_pointer, 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)
@@ -220,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.read_pointer, output_type)
-          values = create_from_onnx_value(map_values.read_pointer, output_type)
-          keys.zip(values).each do |k, v|
-            ret[k] = v
-          end
-          ret
+          keys = create_from_onnx_value(map_keys, output_type)
+          values = create_from_onnx_value(map_values, output_type)
+          keys.zip(values).to_h
         else
           Utils.unsupported_type("element", elem_type)
         end
@@ -261,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.1"
+  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.1
+  version: 0.11.0
 platform: ruby
 authors:
 - Andrew Kane
@@ -37,13 +37,13 @@ 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
 - vendor/ThirdPartyNotices.txt
 - vendor/libonnxruntime.arm64.dylib
 - vendor/libonnxruntime.arm64.so
-- vendor/libonnxruntime.dylib
 - vendor/libonnxruntime.so
 - vendor/onnxruntime.dll
 homepage: https://github.com/ankane/onnxruntime-ruby
@@ -64,7 +64,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.3
 specification_version: 4
 summary: High performance scoring engine for ML models
 test_files: []