onnxruntime 0.3.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1a31036492f6ad4f0ab17a2534a69f17ca05058267447089868f2ac5bf2c5e79
-  data.tar.gz: 6cd8be229992a0ea4c9fdb8529a229e31a777321e0971f0123bc2680ca828be3
+  metadata.gz: dc2115e3b32ec7d1d0ab2da64edfb5bf2ebf24ecc6ad705d4a53ae4793e60412
+  data.tar.gz: 5e53efd5de12ed5ac06a7e4472c8ee043ffbbba9c82b5f49e340f6a70a4dfcdf
 SHA512:
-  metadata.gz: 9bb61d56c9c4ddb17e0e085381226ab0c91e72de592deb6519bf6840ffb1a00eaa0fb9382eb0cba1d563165fb9d0528034da1f2ea9b6b3cb76b780813750ad21
-  data.tar.gz: b94b0b2772728ead241a0d16c3ca2db099cbf7ab6f3994384e3107f69d9aa2cdaa31ed4ba08bd4d3d9fae2eef0b13ea84aa70823be0ff2d24b921e8fb390246b
+  metadata.gz: 93f83646d23298213b971ea7462ce4e5cc970c49d7572b646a6f8003b05689a5a232a3acc05b9cacfbabf65534c046d687eecc80fbf5583b2691391d30b54872
+  data.tar.gz: fc0349312d70944a2169302e8b9f1f70f255e29b60c523f0ba1a688ac162cc230636f9ef333d6ac032d855d9387d88234181a69edade6407bde027050972a2da

data/CHANGELOG.md

@@ -1,3 +1,29 @@
+## 0.5.0 (2020-10-01)
+
+- Updated ONNX Runtime to 1.5.1
+- OpenMP is now required on Mac
+- Fixed `mul_1.onnx` example
+
+## 0.4.0 (2020-07-20)
+
+- Updated ONNX Runtime to 1.4.0
+- Added `providers` method
+- Fixed errors on Windows
+
+## 0.3.3 (2020-06-17)
+
+- Fixed segmentation fault on exit on Linux
+
+## 0.3.2 (2020-06-16)
+
+- Fixed error with FFI 1.13.0+
+- Added friendly graph optimization levels
+
+## 0.3.1 (2020-05-18)
+
+- Updated ONNX Runtime to 1.3.0
+- Added `custom_metadata_map` to model metadata
+
 ## 0.3.0 (2020-03-11)
 
 - Updated ONNX Runtime to 1.2.0

data/LICENSE.txt

@@ -1,23 +1,22 @@
-Copyright (c) 2019-2020 Andrew Kane
-Datasets Copyright (c) Microsoft Corporation
-
 MIT License
 
-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:
+Copyright (c) 2018 Microsoft Corporation
+Copyright (c) 2019-2020 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
+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 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.
+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.

data/README.md

@@ -14,6 +14,12 @@ Add this line to your application’s Gemfile:
 gem 'onnxruntime'
 ```
 
+On Mac, also install OpenMP:
+
+```sh
+brew install libomp
+```
+
 ## Getting Started
 
 Load a model and make predictions
@@ -63,8 +69,8 @@ OnnxRuntime::Model.new(path_or_bytes, {
   enable_cpu_mem_arena: true,
   enable_mem_pattern: true,
   enable_profiling: false,
-  execution_mode: :sequential,
-  graph_optimization_level: nil,
+  execution_mode: :sequential,    # :sequential or :parallel
+  graph_optimization_level: nil,  # :none, :basic, :extended, or :all
   inter_op_num_threads: nil,
   intra_op_num_threads: nil,
   log_severity_level: 2,

data/lib/onnxruntime.rb

@@ -19,7 +19,7 @@ module OnnxRuntime
   self.ffi_lib = [vendor_lib]
 
   def self.lib_version
-    FFI.OrtGetApiBase[:GetVersionString].call
+    FFI.OrtGetApiBase[:GetVersionString].call.read_string
   end
 
   # friendlier error message

data/lib/onnxruntime/ffi.rb

@@ -3,10 +3,13 @@ module OnnxRuntime
     extend ::FFI::Library
 
     begin
-      ffi_lib Array(OnnxRuntime.ffi_lib)
+      ffi_lib OnnxRuntime.ffi_lib
     rescue LoadError => e
-      raise e if ENV["ONNXRUNTIME_DEBUG"]
-      raise LoadError, "Could not find ONNX Runtime"
+      if e.message.include?("Library not loaded: /usr/local/opt/libomp/lib/libomp.dylib") && e.message.include?("Reason: image not found")
+        raise LoadError, "OpenMP not found. Run `brew install libomp`"
+      else
+        raise e
+      end
     end
 
     # https://github.com/microsoft/onnxruntime/blob/master/include/onnxruntime/core/session/onnxruntime_c_api.h
@@ -20,19 +23,19 @@ module OnnxRuntime
       layout \
         :CreateStatus, callback(%i[int string], :pointer),
         :GetErrorCode, callback(%i[pointer], :pointer),
-        :GetErrorMessage, callback(%i[pointer], :string),
+        :GetErrorMessage, callback(%i[pointer], :pointer),
         :CreateEnv, callback(%i[int string pointer], :pointer),
         :CreateEnvWithCustomLogger, callback(%i[], :pointer),
         :EnableTelemetryEvents, callback(%i[pointer], :pointer),
         :DisableTelemetryEvents, callback(%i[pointer], :pointer),
-        :CreateSession, callback(%i[pointer string pointer pointer], :pointer),
+        :CreateSession, callback(%i[pointer pointer pointer pointer], :pointer),
         :CreateSessionFromArray, callback(%i[pointer pointer size_t pointer pointer], :pointer),
         :Run, callback(%i[pointer pointer pointer pointer size_t pointer size_t pointer], :pointer),
         :CreateSessionOptions, callback(%i[pointer], :pointer),
-        :SetOptimizedModelFilePath, callback(%i[pointer string], :pointer),
+        :SetOptimizedModelFilePath, callback(%i[pointer pointer], :pointer),
         :CloneSessionOptions, callback(%i[], :pointer),
         :SetSessionExecutionMode, callback(%i[], :pointer),
-        :EnableProfiling, callback(%i[pointer string], :pointer),
+        :EnableProfiling, callback(%i[pointer pointer], :pointer),
         :DisableProfiling, callback(%i[pointer], :pointer),
         :EnableMemPattern, callback(%i[pointer], :pointer),
         :DisableMemPattern, callback(%i[pointer], :pointer),
@@ -136,7 +139,15 @@ module OnnxRuntime
         :ModelMetadataGetDescription, callback(%i[pointer pointer pointer], :pointer),
         :ModelMetadataLookupCustomMetadataMap, callback(%i[pointer pointer pointer pointer], :pointer),
         :ModelMetadataGetVersion, callback(%i[pointer pointer], :pointer),
-        :ReleaseModelMetadata, callback(%i[pointer], :void)
+        :ReleaseModelMetadata, callback(%i[pointer], :void),
+        :CreateEnvWithGlobalThreadPools, callback(%i[], :pointer),
+        :DisablePerSessionThreads, callback(%i[], :pointer),
+        :CreateThreadingOptions, callback(%i[], :pointer),
+        :ReleaseThreadingOptions, callback(%i[], :pointer),
+        :ModelMetadataGetCustomMetadataMapKeys, callback(%i[pointer pointer pointer pointer], :pointer),
+        :AddFreeDimensionOverrideByName, callback(%i[], :pointer),
+        :GetAvailableProviders, callback(%i[pointer pointer], :pointer),
+        :ReleaseAvailableProviders, callback(%i[pointer int], :pointer)
     end
 
     class ApiBase < ::FFI::Struct
@@ -144,9 +155,17 @@ module OnnxRuntime
       # to prevent "unable to resolve type" error on Ubuntu
       layout \
         :GetApi, callback(%i[uint32], Api.by_ref),
-        :GetVersionString, callback(%i[], :string)
+        :GetVersionString, callback(%i[], :pointer)
     end
 
     attach_function :OrtGetApiBase, %i[], ApiBase.by_ref
+
+    if Gem.win_platform?
+      class Libc
+        extend ::FFI::Library
+        ffi_lib ::FFI::Library::LIBC
+        attach_function :mbstowcs, %i[pointer string size_t], :size_t
+      end
+    end
   end
 end

data/lib/onnxruntime/inference_session.rb

@@ -8,26 +8,25 @@ module OnnxRuntime
       check_status api[:CreateSessionOptions].call(session_options)
       check_status api[:EnableCpuMemArena].call(session_options.read_pointer) if enable_cpu_mem_arena
       check_status api[:EnableMemPattern].call(session_options.read_pointer) if enable_mem_pattern
-      check_status api[:EnableProfiling].call(session_options.read_pointer, "onnxruntime_profile_") if enable_profiling
+      check_status api[:EnableProfiling].call(session_options.read_pointer, ort_string("onnxruntime_profile_")) if enable_profiling
       if execution_mode
-        mode =
-          case execution_mode
-          when :sequential
-            0
-          when :parallel
-            1
-          else
-            raise ArgumentError, "Invalid execution mode"
-          end
+        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)
       end
-      check_status api[:SetSessionGraphOptimizationLevel].call(session_options.read_pointer, graph_optimization_level) if graph_optimization_level
+      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)
+      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, optimized_model_filepath) if optimized_model_filepath
+      check_status api[:SetOptimizedModelFilePath].call(session_options.read_pointer, ort_string(optimized_model_filepath)) if optimized_model_filepath
 
       # session
       @session = ::FFI::MemoryPointer.new(:pointer)
@@ -40,17 +39,12 @@ module OnnxRuntime
           path_or_bytes.encoding == Encoding::BINARY
         end
 
-      # fix for Windows "File doesn't exist"
-      if Gem.win_platform? && !from_memory
-        path_or_bytes = File.binread(path_or_bytes)
-        from_memory = true
-      end
-
       if from_memory
         check_status api[:CreateSessionFromArray].call(env.read_pointer, path_or_bytes, path_or_bytes.bytesize, session_options.read_pointer, @session)
       else
-        check_status api[:CreateSession].call(env.read_pointer, path_or_bytes, session_options.read_pointer, @session)
+        check_status api[:CreateSession].call(env.read_pointer, ort_string(path_or_bytes), session_options.read_pointer, @session)
       end
+      ObjectSpace.define_finalizer(self, self.class.finalize(@session))
 
       # input info
       allocator = ::FFI::MemoryPointer.new(:pointer)
@@ -63,7 +57,7 @@ module OnnxRuntime
       # input
       num_input_nodes = ::FFI::MemoryPointer.new(:size_t)
       check_status api[:SessionGetInputCount].call(read_pointer, num_input_nodes)
-      read_size_t(num_input_nodes).times do |i|
+      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)
         typeinfo = ::FFI::MemoryPointer.new(:pointer)
@@ -74,13 +68,15 @@ module OnnxRuntime
       # output
       num_output_nodes = ::FFI::MemoryPointer.new(:size_t)
       check_status api[:SessionGetOutputCount].call(read_pointer, num_output_nodes)
-      read_size_t(num_output_nodes).times do |i|
+      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)
         typeinfo = ::FFI::MemoryPointer.new(:pointer)
         check_status api[:SessionGetOutputTypeInfo].call(read_pointer, i, typeinfo)
         @outputs << {name: name_ptr.read_pointer.read_string}.merge(node_info(typeinfo))
       end
+    ensure
+      # release :SessionOptions, session_options
     end
 
     # TODO support logid
@@ -106,9 +102,18 @@ module OnnxRuntime
       output_names.size.times.map do |i|
         create_from_onnx_value(output_tensor[i].read_pointer)
       end
+    ensure
+      release :RunOptions, run_options
+      if input_tensor
+        input_feed.size.times do |i|
+          release :Value, input_tensor[i]
+        end
+      end
     end
 
     def modelmeta
+      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)
@@ -117,36 +122,61 @@ module OnnxRuntime
 
       metadata = ::FFI::MemoryPointer.new(:pointer)
       check_status api[:SessionGetModelMetadata].call(read_pointer, metadata)
+
+      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 = keys.read_pointer[i * ::FFI::Pointer.size].read_pointer.read_string
+        value = ::FFI::MemoryPointer.new(:string)
+        check_status api[:ModelMetadataLookupCustomMetadataMap].call(metadata.read_pointer, @allocator.read_pointer, key, value)
+        custom_metadata_map[key] = value.read_pointer.read_string
+      end
+
       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[:ModelMetadataGetProducerName].call(metadata.read_pointer, @allocator.read_pointer, producer_name)
       check_status api[:ModelMetadataGetVersion].call(metadata.read_pointer, version)
-      api[:ReleaseModelMetadata].call(metadata.read_pointer)
-
-      # TODO add custom_metadata_map
-      # need a way to get keys
 
       {
+        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,
         producer_name: producer_name.read_pointer.read_string,
         version: version.read(:int64_t)
       }
+    ensure
+      release :ModelMetadata, metadata
     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
     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)
+      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
+      api[:ReleaseAvailableProviders].call(out_ptr.read_pointer, length)
+      providers
+    end
+
     private
 
     def create_input_tensor(input_feed)
       allocator_info = ::FFI::MemoryPointer.new(:pointer)
-      check_status = api[:CreateCpuMemoryInfo].call(1, 0, allocator_info)
+      check_status api[:CreateCpuMemoryInfo].call(1, 0, allocator_info)
       input_tensor = ::FFI::MemoryPointer.new(:pointer, input_feed.size)
 
       input_feed.each_with_index do |(input_name, input), idx|
@@ -164,7 +194,7 @@ module OnnxRuntime
 
         # TODO support more types
         inp = @inputs.find { |i| i[:name] == input_name.to_s }
-        raise "Unknown input: #{input_name}" unless inp
+        raise Error, "Unknown input: #{input_name}" unless inp
 
         input_node_dims = ::FFI::MemoryPointer.new(:int64, shape.size)
         input_node_dims.write_array_of_int64(shape)
@@ -206,7 +236,7 @@ module OnnxRuntime
 
     def create_from_onnx_value(out_ptr)
       out_type = ::FFI::MemoryPointer.new(:int)
-      check_status = api[:GetValueType].call(out_ptr, out_type)
+      check_status api[:GetValueType].call(out_ptr, out_type)
       type = FFI::OnnxType[out_type.read_int]
 
       case type
@@ -221,7 +251,9 @@ module OnnxRuntime
 
         out_size = ::FFI::MemoryPointer.new(:size_t)
         output_tensor_size = api[:GetTensorShapeElementCount].call(typeinfo.read_pointer, out_size)
-        output_tensor_size = read_size_t(out_size)
+        output_tensor_size = out_size.read(:size_t)
+
+        release :TensorTypeAndShapeInfo, typeinfo
 
         # TODO support more types
         type = FFI::TensorElementDataType[type]
@@ -240,7 +272,7 @@ module OnnxRuntime
         out = ::FFI::MemoryPointer.new(:size_t)
         check_status api[:GetValueCount].call(out_ptr, out)
 
-        read_size_t(out).times.map do |i|
+        out.read(:size_t).times.map do |i|
           seq = ::FFI::MemoryPointer.new(:pointer)
           check_status api[:GetValue].call(out_ptr, i, @allocator.read_pointer, seq)
           create_from_onnx_value(seq.read_pointer)
@@ -255,6 +287,7 @@ module OnnxRuntime
         check_status api[:GetValue].call(out_ptr, 1, @allocator.read_pointer, map_values)
         check_status api[:GetTensorTypeAndShape].call(map_keys.read_pointer, type_shape)
         check_status api[:GetTensorElementType].call(type_shape.read_pointer, elem_type)
+        release :TensorTypeAndShapeInfo, type_shape
 
         # TODO support more types
         elem_type = FFI::TensorElementDataType[elem_type.read_int]
@@ -281,9 +314,9 @@ module OnnxRuntime
 
     def check_status(status)
       unless status.null?
-        message = api[:GetErrorMessage].call(status)
+        message = api[:GetErrorMessage].call(status).read_string
         api[:ReleaseStatus].call(status)
-        raise OnnxRuntime::Error, message
+        raise Error, message
       end
     end
 
@@ -295,6 +328,7 @@ module OnnxRuntime
       case type
       when :tensor
         tensor_info = ::FFI::MemoryPointer.new(:pointer)
+        # don't free tensor_info
         check_status api[:CastTypeInfoToTensorInfo].call(typeinfo.read_pointer, tensor_info)
 
         type, shape = tensor_type_and_shape(tensor_info)
@@ -335,7 +369,7 @@ module OnnxRuntime
         unsupported_type("ONNX", type)
       end
     ensure
-      api[:ReleaseTypeInfo].call(typeinfo.read_pointer)
+      release :TypeInfo, typeinfo
     end
 
     def tensor_type_and_shape(tensor_info)
@@ -344,7 +378,7 @@ module OnnxRuntime
 
       num_dims_ptr = ::FFI::MemoryPointer.new(:size_t)
       check_status api[:GetDimensionsCount].call(tensor_info.read_pointer, num_dims_ptr)
-      num_dims = read_size_t(num_dims_ptr)
+      num_dims = num_dims_ptr.read(:size_t)
 
       node_dims = ::FFI::MemoryPointer.new(:int64, num_dims)
       check_status api[:GetDimensions].call(tensor_info.read_pointer, node_dims, num_dims)
@@ -353,20 +387,43 @@ module OnnxRuntime
     end
 
     def unsupported_type(name, type)
-      raise "Unsupported #{name} type: #{type}"
+      raise Error, "Unsupported #{name} type: #{type}"
     end
 
-    # read(:size_t) not supported in FFI JRuby
-    def read_size_t(ptr)
-      if RUBY_PLATFORM == "java"
-        ptr.read_long
-      else
-        ptr.read(:size_t)
-      end
+    def api
+      self.class.api
     end
 
-    def api
-      @api ||= FFI.OrtGetApiBase[:GetApi].call(1)
+    def release(*args)
+      self.class.release(*args)
+    end
+
+    def self.api
+      @api ||= FFI.OrtGetApiBase[:GetApi].call(4)
+    end
+
+    def self.release(type, pointer)
+      api[:"Release#{type}"].call(pointer.read_pointer) if pointer && !pointer.null?
+    end
+
+    def self.finalize(session)
+      # must use proc instead of stabby lambda
+      proc { release :Session, session }
+    end
+
+    # wide string on Windows
+    # char string on Linux
+    # see ORTCHAR_T in onnxruntime_c_api.h
+    def ort_string(str)
+      if Gem.win_platform?
+        max = str.size + 1 # for null byte
+        dest = ::FFI::MemoryPointer.new(:wchar_t, max)
+        ret = FFI::Libc.mbstowcs(dest, str, max)
+        raise Error, "Expected mbstowcs to return #{str.size}, got #{ret}" if ret != str.size
+        dest
+      else
+        str
+      end
     end
 
     def env
@@ -375,7 +432,7 @@ module OnnxRuntime
         @@env ||= begin
           env = ::FFI::MemoryPointer.new(:pointer)
           check_status api[:CreateEnv].call(3, "Default", env)
-          at_exit { api[:ReleaseEnv].call(env.read_pointer) }
+          at_exit { release :Env, env }
           # disable telemetry
           # https://github.com/microsoft/onnxruntime/blob/master/docs/Privacy.md
           check_status api[:DisableTelemetryEvents].call(env)