ruby-hdf5 0.0.2 → 0.0.4

data/lib/hdf5/dtype.rb

@@ -0,0 +1,214 @@
+module HDF5
+  class DType
+    TYPES = {
+      int8: [Numo::Int8, :H5T_NATIVE_INT8_g, :H5T_STD_I8LE_g, :integer, 1],
+      uint8: [Numo::UInt8, :H5T_NATIVE_UINT8_g, :H5T_STD_U8LE_g, :integer, 1],
+      int16: [Numo::Int16, :H5T_NATIVE_INT16_g, :H5T_STD_I16LE_g, :integer, 2],
+      uint16: [Numo::UInt16, :H5T_NATIVE_UINT16_g, :H5T_STD_U16LE_g, :integer, 2],
+      int32: [Numo::Int32, :H5T_NATIVE_INT32_g, :H5T_STD_I32LE_g, :integer, 4],
+      uint32: [Numo::UInt32, :H5T_NATIVE_UINT32_g, :H5T_STD_U32LE_g, :integer, 4],
+      int64: [Numo::Int64, :H5T_NATIVE_INT64_g, :H5T_STD_I64LE_g, :integer, 8],
+      uint64: [Numo::UInt64, :H5T_NATIVE_UINT64_g, :H5T_STD_U64LE_g, :integer, 8],
+      float32: [Numo::SFloat, :H5T_NATIVE_FLOAT, :H5T_IEEE_F32LE_g, :float, 4],
+      float64: [Numo::DFloat, :H5T_NATIVE_DOUBLE, :H5T_IEEE_F64LE_g, :float, 8],
+      bool: [Numo::Bit, nil, nil, :bool, 1],
+      complex64: [Numo::SComplex, nil, nil, :complex, 8],
+      complex128: [Numo::DComplex, nil, nil, :complex, 16]
+    }.freeze
+
+    attr_reader :numo_class, :memory_type_name, :storage_type_name, :kind, :itemsize, :byteorder, :precision, :offset,
+                :hdf5_class, :encoding
+
+    def self.for_numo(value)
+      type = TYPES.values.find { |numo_class,| value.is_a?(numo_class) }
+      raise HDF5::Error, "Unsupported Numo type: #{value.class}" unless type
+
+      symbol = TYPES.key(type)
+      new(symbol, *type)
+    end
+
+    def self.for_symbol(symbol)
+      type = TYPES.fetch(symbol) { raise HDF5::Error, "Unsupported dtype: #{symbol.inspect}" }
+      new(symbol, *type)
+    end
+
+    def self.for_hdf5(type_id)
+      type_class = HDF5::FFI.H5Tget_class(type_id)
+      itemsize = HDF5::FFI.H5Tget_size(type_id)
+      if type_class == :H5T_STRING
+        return new(:string, Numo::RObject, nil, nil, :string, itemsize, byteorder: :none,
+                   hdf5_class: type_class, encoding: StringCodec.encoding_for(type_id))
+      end
+      return for_bool_hdf5(type_id, itemsize) if type_class == :H5T_ENUM
+      return for_complex_hdf5(type_id, itemsize) if type_class == :H5T_COMPOUND
+
+      symbol = case type_class
+               when :H5T_INTEGER
+                 prefix = HDF5::FFI.H5Tget_sign(type_id) == :H5T_SGN_NONE ? 'uint' : 'int'
+                 "#{prefix}#{itemsize * 8}".to_sym
+               when :H5T_FLOAT
+                 "float#{itemsize * 8}".to_sym
+               else
+                 raise UnsupportedTypeError, "Unsupported HDF5 datatype: #{type_class}"
+               end
+
+      precision = HDF5::FFI.H5Tget_precision(type_id)
+      offset = HDF5::FFI.H5Tget_offset(type_id)
+      unless precision == itemsize * 8
+        raise UnsupportedTypeError,
+              "Unsupported #{precision}-bit datatype in #{itemsize * 8}-bit storage"
+      end
+      raise UnsupportedTypeError, "Unsupported datatype bit offset: #{offset}" unless offset.zero?
+
+      order = HDF5::FFI.H5Tget_order(type_id)
+      byteorder = { H5T_ORDER_LE: :little, H5T_ORDER_BE: :big, H5T_ORDER_NONE: :none }.fetch(order) do
+        raise UnsupportedTypeError, "Unsupported datatype byte order: #{order}"
+      end
+      new(symbol, *TYPES.fetch(symbol), byteorder:, precision:, offset:, hdf5_class: type_class)
+    end
+
+    def self.for_bool_hdf5(type_id, itemsize)
+      false_value = ::FFI::MemoryPointer.new(:int8)
+      true_value = ::FFI::MemoryPointer.new(:int8)
+      valid = itemsize == 1 && HDF5::FFI.H5Tget_nmembers(type_id) == 2 &&
+              HDF5::FFI.H5Tenum_valueof(type_id, 'FALSE', false_value) >= 0 &&
+              HDF5::FFI.H5Tenum_valueof(type_id, 'TRUE', true_value) >= 0 &&
+              false_value.read_int8.zero? && true_value.read_int8 == 1
+      raise UnsupportedTypeError, 'Unsupported HDF5 enum datatype' unless valid
+
+      new(:bool, *TYPES.fetch(:bool), byteorder: :none, hdf5_class: :H5T_ENUM)
+    end
+
+    def self.for_complex_hdf5(type_id, itemsize)
+      component_size = itemsize / 2
+      real_index = HDF5::FFI.H5Tget_member_index(type_id, 'r')
+      imaginary_index = HDF5::FFI.H5Tget_member_index(type_id, 'i')
+      valid = [8, 16].include?(itemsize) && real_index >= 0 && imaginary_index >= 0 &&
+              HDF5::FFI.H5Tget_nmembers(type_id) == 2 &&
+              HDF5::FFI.H5Tget_member_offset(type_id, real_index) == 0 &&
+              HDF5::FFI.H5Tget_member_offset(type_id, imaginary_index) == component_size
+      byteorders = []
+      [real_index, imaginary_index].each do |index|
+        next unless index >= 0
+
+        member_type_id = HDF5::FFI.H5Tget_member_type(type_id, index)
+        begin
+          member_dtype = member_type_id >= 0 ? for_hdf5(member_type_id) : nil
+          valid &&= member_dtype && member_dtype.kind == :float && member_dtype.itemsize == component_size
+          byteorders << member_dtype.byteorder if member_dtype
+        ensure
+          HDF5::FFI.H5Tclose(member_type_id) if member_type_id >= 0
+        end
+      end
+      valid &&= byteorders.length == 2 && byteorders.uniq.length == 1
+      raise UnsupportedTypeError, 'Unsupported HDF5 compound datatype' unless valid
+
+      symbol = itemsize == 8 ? :complex64 : :complex128
+      new(symbol, *TYPES.fetch(symbol), byteorder: byteorders.first, hdf5_class: :H5T_COMPOUND)
+    end
+
+    def initialize(symbol, numo_class, memory_type_name, storage_type_name, kind, itemsize, byteorder: :little,
+                   precision: itemsize * 8, offset: 0, hdf5_class: nil, encoding: nil)
+      @symbol = symbol
+      @numo_class = numo_class
+      @memory_type_name = memory_type_name
+      @storage_type_name = storage_type_name
+      @kind = kind
+      @itemsize = itemsize
+      @byteorder = byteorder
+      @precision = precision
+      @offset = offset
+      @encoding = encoding
+      @hdf5_class = hdf5_class || (kind == :integer ? :H5T_INTEGER : :H5T_FLOAT)
+      freeze
+    end
+
+    def memory_type_id
+      return self.class.bool_type_id(native: true) if kind == :bool
+      return self.class.complex_type_id(itemsize, native: true) if kind == :complex
+
+      HDF5::FFI.public_send(memory_type_name)
+    end
+
+    def storage_type_id
+      return self.class.bool_type_id(native: false) if kind == :bool
+      return self.class.complex_type_id(itemsize, native: false) if kind == :complex
+
+      HDF5::FFI.public_send(storage_type_name)
+    end
+
+    def to_sym
+      @symbol
+    end
+
+    def castable_to?(target, casting: :safe)
+      raise ArgumentError, "Unsupported casting mode: #{casting.inspect}" unless %i[safe unsafe].include?(casting)
+      return true if casting == :unsafe || to_sym == target.to_sym
+
+      if kind == :integer && target.kind == :integer
+        return itemsize <= target.itemsize if unsigned? == target.unsigned?
+        return false unless unsigned? && !target.unsigned?
+
+        return itemsize < target.itemsize
+      end
+      return itemsize <= target.itemsize if kind == :float && target.kind == :float
+      return itemsize <= target.itemsize if kind == :complex && target.kind == :complex
+      return itemsize <= target.itemsize / 2 if kind == :float && target.kind == :complex
+
+      if kind == :integer && %i[float complex].include?(target.kind)
+        significant_bits = unsigned? ? itemsize * 8 : itemsize * 8 - 1
+        size = target.kind == :complex ? target.itemsize / 2 : target.itemsize
+        mantissa_bits = size == 4 ? 24 : 53
+        return significant_bits <= mantissa_bits
+      end
+
+      false
+    end
+
+    def unsigned?
+      @symbol.to_s.start_with?('uint')
+    end
+
+    class << self
+      def bool_type_id(native:)
+        @bool_type_ids ||= {}
+        @bool_type_ids[native] ||= begin
+          base_id = HDF5::FFI.public_send(native ? :H5T_NATIVE_INT8_g : :H5T_STD_I8LE_g)
+          type_id = HDF5::FFI.H5Tenum_create(base_id)
+          raise HDF5::Error, 'Failed to create bool datatype' if type_id < 0
+
+          false_value = ::FFI::MemoryPointer.new(:int8).tap { |pointer| pointer.write_int8(0) }
+          true_value = ::FFI::MemoryPointer.new(:int8).tap { |pointer| pointer.write_int8(1) }
+          if HDF5::FFI.H5Tenum_insert(type_id, 'FALSE', false_value) < 0 ||
+             HDF5::FFI.H5Tenum_insert(type_id, 'TRUE', true_value) < 0
+            HDF5::FFI.H5Tclose(type_id)
+            raise HDF5::Error, 'Failed to define bool datatype'
+          end
+
+          type_id
+        end
+      end
+
+      def complex_type_id(size, native:)
+        @complex_type_ids ||= {}
+        @complex_type_ids[[size, native]] ||= begin
+          component_id = if native
+                           HDF5::FFI.public_send(size == 8 ? :H5T_NATIVE_FLOAT : :H5T_NATIVE_DOUBLE)
+                         else
+                           HDF5::FFI.public_send(size == 8 ? :H5T_IEEE_F32LE_g : :H5T_IEEE_F64LE_g)
+                         end
+          type_id = HDF5::FFI.H5Tcreate(:H5T_COMPOUND, size)
+          raise HDF5::Error, 'Failed to create complex datatype' if type_id < 0
+
+          if HDF5::FFI.H5Tinsert(type_id, 'r', 0, component_id) < 0 ||
+             HDF5::FFI.H5Tinsert(type_id, 'i', size / 2, component_id) < 0
+            HDF5::FFI.H5Tclose(type_id)
+            raise HDF5::Error, 'Failed to define complex datatype'
+          end
+
+          type_id
+        end
+      end
+    end
+  end
+end

data/lib/hdf5/ffi.rb

@@ -2,6 +2,8 @@ module HDF5
   module FFI
     extend ::FFI::Library
 
+    require 'monitor'
+
     class << self
       attr_reader :backend
     end
@@ -28,6 +30,20 @@ module HDF5
       warn e.message # if $VERBOSE
     end
 
+    def self.backend_for_version(major, minor, release)
+      case [major, minor]
+      in [1, 10..13]
+        'ffi_10'
+      in [1, 14]
+        'ffi_14'
+      in [2, 0..2]
+        'ffi_20'
+      else
+        raise "Unsupported HDF5 version #{major}.#{minor}.#{release}"
+      end
+    end
+    private_class_method :backend_for_version
+
     attach_function 'H5get_libversion', %i[
       pointer
       pointer
@@ -43,17 +59,39 @@ module HDF5
     minor = minor_ptr.read_uint
     release = release_ptr.read_uint
 
-    @backend = case [major, minor]
-               in [1, 10..13]
-                 'ffi_10'
-               in [1, 14..]
-                 'ffi_14'
-               in [2.., _]
-                 'ffi_14'
-               else
-                 raise "Unsupported HDF5 version #{major}.#{minor}.#{release}"
-               end
+    @backend = backend_for_version(major, minor, release)
 
     require_relative @backend
+
+    REQUIRED_FUNCTIONS = %i[
+      H5Fopen H5Fcreate H5Fclose H5Fflush
+      H5Gopen2 H5Gcreate2 H5Gclose
+      H5Dopen2 H5Dcreate2 H5Dclose H5Dread H5Dwrite H5Dget_type H5Dget_space H5Dset_extent H5Dget_create_plist
+      H5Aopen H5Acreate2 H5Aclose H5Aread H5Awrite H5Aexists H5Adelete H5Aiterate2 H5Aget_type H5Aget_space
+      H5Screate H5Screate_simple H5Sclose H5Sget_simple_extent_type H5Sget_simple_extent_ndims
+      H5Sget_simple_extent_dims H5Sselect_hyperslab H5Sget_select_npoints
+      H5Tcopy H5Tclose H5Tget_class H5Tget_size H5Tget_sign H5Tget_order H5Tget_precision H5Tget_offset
+      H5Tset_size H5Tset_cset H5Tget_cset H5Tis_variable_str H5Tcreate H5Tinsert H5Tenum_create H5Tenum_insert
+      H5Tenum_valueof H5Tget_nmembers H5Tget_member_index H5Tget_member_offset H5Tget_member_type H5Tget_super
+      H5Pcreate H5Pclose H5Pset_chunk H5Pget_chunk H5Pget_layout H5Pset_deflate H5Pset_shuffle H5Pset_fletcher32
+      H5Pset_fill_value H5Pget_fill_value H5Zfilter_avail H5Zget_filter_info
+      H5Lexists H5Ldelete H5Lmove H5Lcreate_hard H5Lcreate_soft H5Lget_val H5Dvlen_reclaim
+    ].freeze
+    version_functions = if MiV == 10
+                          %i[H5Literate H5Lget_info H5Oget_info_by_name]
+                        else
+                          %i[H5Literate2 H5Lget_info2 H5Oget_info_by_name1]
+                        end
+    missing = (REQUIRED_FUNCTIONS + version_functions).reject { |name| respond_to?(name) }
+    raise LoadError, "Loaded HDF5 library is missing required APIs: #{missing.join(', ')}" unless missing.empty?
+
+    CALL_LOCK = Monitor.new
+    synchronized_calls = Module.new
+    singleton_methods.grep(/^H5/).each do |name|
+      synchronized_calls.define_method(name) do |*args, **kwargs, &block|
+        CALL_LOCK.synchronize { super(*args, **kwargs, &block) }
+      end
+    end
+    singleton_class.prepend(synchronized_calls)
   end
 end