ndav 0.0.5 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0648fef27ca47ec51a45cacb90330e5fb2de53071d4223604752c04746ad9c2d'
-  data.tar.gz: 4af1dacda9bfa1258552bc271d773136b06ea414cce61c75c194c590f1361850
+  metadata.gz: ddc0e563bff86b51222b18b00f243b94b0f2e5a69dad3e7694c80a349775bf30
+  data.tar.gz: 0afbc73643e49372d2b5104358acdc7460b26d7e6cc8892d45a67e4530cbe3d9
 SHA512:
-  metadata.gz: b81a17db0cc3814963b47e590e2f3e021e86792326a98ad1f246df8f887c4f1e49aec42808c82aeceb522e28f05f7dac9d3a6eb65417fbfc9ff785cb75284723
-  data.tar.gz: 798ed5c4f2f84fa73b262af460e0054454a78d6f8a9eeacbb191f0b866c6c4e98ae72ed296af23b7a67d98d6894a988cc22dfc23484267d1773bd91ed7043a63
+  metadata.gz: f3a264a0204009e7f6b7505cae42667abe159e7ce7cbc5a27ffa88578c5691138b1b938795e14083b6f4cc9605dbc53b70a3990df495443ec9f5a8ebd664d5b5
+  data.tar.gz: bafa151218a7e1acb22acd915fe08acb5147228980a2f441cd928ba66ae4425fb4fcd7bf9509e8ac28f5113e555ee9927b9a71b3d13ca2064134f144a524958c

data/.yardopts

@@ -1,4 +1,4 @@
---title="NDAV - N-Dimensional Array View" -M commonmarker
+--title="NDAV - N-Dimensional Array View"
 -
 LICENSE.txt
 lib/ndav/ffi.rb

data/README.md

@@ -9,6 +9,10 @@ It provides an interoperability layer for multi-dimensional arrays which can be
 
 ![NDAV converts library data each other](https://i.gyazo.com/905f541f15c0d57db5fc7ea3f6edaf07.png)
 
+* Homepage: https://kitaitimakoto.gitlab.io/ndav/
+* Source Code: https://gitlab.com/KitaitiMakoto/ndav
+* RubyGems: https://rubygems.org/gems/ndav
+
 SYNOPSIS
 --------
 
@@ -57,7 +61,9 @@ It might not be difficult, but a little bit cumbersome. Additionally, Red Arrow
 USAGE
 -----
 
-`ndav` gem is just a base library. You need to install bridges as well. Say, assume you want to make conversions between Numo::NArray each other.
+`ndav` gem is just a base library. You need to install bridges as well.
+
+Say, assume you want to make conversions between Numo::NArray each other.
 
     require "numo/narray"
     require "ndav"
@@ -106,6 +112,12 @@ On the other hand, it also exports MemoryView. You can pass NDAV arrays *directl
     samples = waveform.to_ndav
     whisper.full(params, samples)
 
+Additinally, classes that `include` `NDAV::MemoryViewable`, including `Numo::NArray`, `OnnxRuntime::OrtValue` and `Torch::Tensor`, export MemoryViews:
+
+    memory_view = Fiddle::MemoryView.new(numo)
+    memory_view = Fiddle::MemoryView.new(ort_value)
+    memory_view = Fiddle::MemoryView.new(torch_tensor)
+
 ### Notice On Memory Sharing ###
 
 Notice that NDAV is just a memory view and libraries share a memory address. If you change source data destructively, it affects converted data.
@@ -147,7 +159,7 @@ Refer to existing bridge implementations listed above to create your bridge.
 
 The points are:
 
-* Implement `FromNDAV#from_ndav`, `ToNDAV#to_ndav`, {NDAV.register register} them, and `NDAV.from_your_data` and `NDAV#to_your_data` are automatically derived
+* Implement `FromNDAV#from_ndav`, `MemoryViewable#ndav_descriptor`, optionally `ToNDAV#to_ndav`, {NDAV.register register} them, and `NDAV.from_your_data` and `NDAV#to_your_data` are automatically derived and the array become to able to export a MemoryView
 * When initializing NDAV object from your object, use `lifetime` keyword argument for {NDAV#initialize} effectively to prevent Ruby from GCing your object, which would lead to a dangling pointer
 * When initializing your object from NDAV object, keep NDAV object alive to prevent Ruby from GCing NDAV object, which would lead to a dangling pointer, [ndav-numo-narray][], for instance, embeds the NDAV object in an instance variable
 

data/ext/ndav.c

@@ -2,7 +2,7 @@
 #include <ruby/memory_view.h>
 
 static ID id_ndav_validated_descriptor;
-static VALUE sym_data;
+static VALUE sym_addr;
 static VALUE sym_shape;
 static VALUE sym_strides;
 static VALUE sym_format;
@@ -11,8 +11,8 @@ static VALUE sym_readonly_p;
 static VALUE sym_sub_offsets;
 static VALUE sym_ndim;
 static VALUE sym_item_size;
-static VALUE sym_row_major_contiguous_p;
-static VALUE sym_column_major_contiguous_p;
+static ID id_new;
+static VALUE cItemComponent;
 
 typedef struct {
   VALUE descriptor;
@@ -31,155 +31,115 @@ fill_size_array(VALUE src, ssize_t *dest, ssize_t size)
   return true;
 }
 
+static void
+release_memview_common(rb_memory_view_t *view)
+{
+    if (view->shape) {
+      free((void *)view->shape);
+      view->shape = NULL;
+    }
+    if (view->strides) {
+      free((void *)view->strides);
+      view->strides = NULL;
+    }
+    if (view->sub_offsets) {
+      free((void *)view->sub_offsets);
+      view->sub_offsets = NULL;
+    }
+}
+
 static bool
-ndav_get_memory_view(const VALUE ndav, rb_memory_view_t *view, int flags)
+ndav_memory_viewable_get_memory_view(const VALUE ndav, rb_memory_view_t *view, int flags)
 {
-  bool row_major_requested = (flags & RUBY_MEMORY_VIEW_ROW_MAJOR) == RUBY_MEMORY_VIEW_ROW_MAJOR;
-  bool column_major_requested = (flags & RUBY_MEMORY_VIEW_COLUMN_MAJOR) == RUBY_MEMORY_VIEW_COLUMN_MAJOR;
-  bool indirect_requested = (flags & RUBY_MEMORY_VIEW_INDIRECT) == RUBY_MEMORY_VIEW_INDIRECT;
   VALUE desc = rb_funcall(ndav, id_ndav_validated_descriptor, 1, INT2NUM(flags));
   if (!RB_TYPE_P(desc, T_HASH)) {
     rb_warn("descriptor not Hash");
     return false;
   }
-  bool row_major_contiguous = rb_hash_aref(desc, sym_row_major_contiguous_p);
-  bool column_major_contiguous = rb_hash_aref(desc, sym_column_major_contiguous_p);
-  if (row_major_requested && column_major_requested) { // row-major OR column-major requested
-    if (!row_major_contiguous && !column_major_contiguous) {
-      return false;
-    }
-  }
-  // Currently, non-contiguous array not supported
-  else if (row_major_requested && !row_major_contiguous) {
-    return false;
-  }
-  // Currently, non-contiguous array not supported
-  else if (column_major_requested && !column_major_contiguous) {
-    return false;
-  }
-  bool writable_requested = (flags & RUBY_MEMORY_VIEW_WRITABLE) == RUBY_MEMORY_VIEW_WRITABLE;
-  // TODO: Handle flags
 
   VALUE readonly_v = rb_hash_aref(desc, sym_readonly_p);
   bool readonly = NIL_P(readonly_v) || RTEST(readonly_v);
-  if (writable_requested && readonly) {
-    rb_warn("not writable");
+  VALUE byte_size_v = rb_hash_aref(desc, sym_byte_size);
+  ssize_t byte_size = NUM2SSIZET(byte_size_v);
+  VALUE addr = rb_hash_aref(desc, sym_addr);
+  rb_memory_view_t tmp = {0};
+  if (!rb_memory_view_init_as_byte_array(&tmp, ndav, NUM2PTR(addr), byte_size, readonly)) {
+    rb_warn("failed to initialize");
     return false;
   }
-  view->readonly = readonly;
-  view->obj = ndav;
-  VALUE val = rb_hash_aref(desc, sym_data);
-  char *data = StringValuePtr(val);
-  view->data = data;
+  tmp.readonly = readonly;
+  tmp.obj = ndav;
   // TODO: Commonalize
-  // TODO: Consider:
-  // * Use TypedData?
-  //   * If so, calling attr readers at Ruby layer has performance disadvantage.
-  //   * Freezing instance vars in #initialize and then embed them to TypedData may be a solution
   VALUE item_size = rb_hash_aref(desc, sym_item_size);
-  view->item_size = NUM2SSIZET(item_size);
-  VALUE byte_size = rb_hash_aref(desc, sym_byte_size);
-  view->byte_size = NUM2SSIZET(byte_size);
+  tmp.item_size = NUM2SSIZET(item_size);
+  tmp.byte_size = byte_size;
   VALUE ndim = rb_hash_aref(desc, sym_ndim);
-  view->ndim = NUM2SSIZET(ndim);
+  tmp.ndim = NUM2SSIZET(ndim);
   VALUE format = rb_hash_aref(desc, sym_format);
-  view->format = StringValueCStr(format);
+  tmp.format = StringValueCStr(format);
 
   // TODO: Commonalize
   VALUE shape = rb_hash_aref(desc, sym_shape);
-  if (!RB_TYPE_P(shape, T_ARRAY)) {
-    rb_warn("@shape is not an array");
-    return false;
-  }
-  ssize_t *view_shape = (ssize_t *)malloc(sizeof(ssize_t) * view->ndim);
+  ssize_t *view_shape = (ssize_t *)malloc(sizeof(ssize_t) * tmp.ndim);
   if (!view_shape) {
+    release_memview_common(&tmp);
     return false;
   }
-  if (!fill_size_array(shape, view_shape, view->ndim)) {
-    free((void *)view_shape);
+  if (!fill_size_array(shape, view_shape, tmp.ndim)) {
+    free(view_shape);
+    release_memview_common(&tmp);
     return false;
   }
-  view->shape = view_shape;
+  tmp.shape = view_shape;
 
   VALUE strides = rb_hash_aref(desc, sym_strides);
-  if (!RB_TYPE_P(strides, T_ARRAY)) {
-    rb_warn("@strides is not an array");
-    free((void *)view->shape);
-    return false;
-  }
-  ssize_t *view_strides = (ssize_t *)malloc(sizeof(ssize_t) * view->ndim);
+  ssize_t *view_strides = (ssize_t *)malloc(sizeof(ssize_t) * tmp.ndim);
   if (!view_strides) {
-    free((void *)view->shape);
+    release_memview_common(&tmp);
     return false;
   }
-  if (!fill_size_array(strides, view_strides, view->ndim)) {
-    free((void *)view->shape);
-    free((void *)view_strides);
+  if (!fill_size_array(strides, view_strides, tmp.ndim)) {
+    free(view_strides);
+    release_memview_common(&tmp);
     return false;
   }
-  view->strides = view_strides;
+  tmp.strides = view_strides;
 
   VALUE sub_offsets = rb_hash_aref(desc, sym_sub_offsets);
-  if (NIL_P(sub_offsets)) {
-    if (indirect_requested) {
-      rb_warn("indirect requested but sub_offsets is NULL");
-      free((void *)view->shape);
-      free((void *)view->strides);
-      return false;
-    }
-    view->sub_offsets = NULL;
-  } else if (!RB_TYPE_P(sub_offsets, T_ARRAY)) {
-    rb_warn("sub_offsets is not an array");
-    free((void *)view->shape);
-    free((void *)view->strides);
-    return false;
-  } else {
-    ssize_t *view_sub_offsets = (ssize_t *)malloc(sizeof(ssize_t) * view->ndim);
+  if (!NIL_P(sub_offsets)) {
+    ssize_t *view_sub_offsets = (ssize_t *)malloc(sizeof(ssize_t) * tmp.ndim);
     if (!view_sub_offsets) {
-      free((void *)view->shape);
-      free((void *)view->strides);
+      release_memview_common(&tmp);
       return false;
     }
-    if (!fill_size_array(sub_offsets, view_sub_offsets, view->ndim)) {
-      free((void *)view->shape);
-      free((void *)view->strides);
-      free((void *)view_sub_offsets);
+    if (!fill_size_array(sub_offsets, view_sub_offsets, tmp.ndim)) {
+      free(view_sub_offsets);
+      release_memview_common(&tmp);
       return false;
     }
-    view->sub_offsets = view_sub_offsets;
+    tmp.sub_offsets = view_sub_offsets;
   }
 
   private_data_t *private_data = malloc(sizeof(private_data_t));
   if (!private_data) {
-    free((void *)view->shape);
-    free((void *)view->strides);
-    free((void *)view->sub_offsets);
+    release_memview_common(&tmp);
     rb_warn("failed to alloc private_data");
     return false;
   }
   private_data->descriptor = Qnil;
   rb_gc_register_address(&private_data->descriptor);
   private_data->descriptor = desc;
-  view->private_data = private_data;
+  tmp.private_data = private_data;
+
+  *view = tmp;
 
   return true;
 }
 
 static bool
-ndav_release_memory_view(const VALUE ndav, rb_memory_view_t *view)
+ndav_memory_viewable_release_memory_view(const VALUE ndav, rb_memory_view_t *view)
 {
-  if (view->shape) {
-    free((void *)view->shape);
-    view->shape = NULL;
-  }
-  if (view->strides) {
-    free((void *)view->strides);
-    view->strides = NULL;
-  }
-  if (view->sub_offsets) {
-    free((void *)view->sub_offsets);
-    view->sub_offsets = NULL;
-  }
+  release_memview_common(view);
   if (view->private_data) {
     private_data_t *private_data = (private_data_t *)view->private_data;
     rb_gc_unregister_address(&private_data->descriptor);
@@ -191,16 +151,21 @@ ndav_release_memory_view(const VALUE ndav, rb_memory_view_t *view)
 }
 
 static bool
-ndav_memory_view_available_p(const VALUE obj)
+ndav_memory_viewable_memory_view_available_p(const VALUE obj)
 {
   VALUE descriptor = rb_funcall(obj, id_ndav_validated_descriptor, 0);
-  return RTEST(descriptor);
+  if (RB_TYPE_P(descriptor, T_HASH)) {
+    return true;
+  } else {
+    rb_warn("descriptor not Hash");
+    return false;
+  }
 }
 
 const struct rb_memory_view_entry ndav_view_entry = {
-  ndav_get_memory_view,
-  ndav_release_memory_view,
-  ndav_memory_view_available_p
+  ndav_memory_viewable_get_memory_view,
+  ndav_memory_viewable_release_memory_view,
+  ndav_memory_viewable_memory_view_available_p
 };
 
 static VALUE
@@ -214,11 +179,74 @@ ndav_memory_viewable_s_register(VALUE mod, VALUE klass)
   return Qtrue;
 }
 
+typedef struct init_item_components_args {
+  rb_memory_view_item_component_t *members;
+  size_t n_members;
+} init_item_components_args;
+
+static VALUE
+init_item_components(VALUE args_v)
+{
+  init_item_components_args *args = (init_item_components_args *)args_v;
+  VALUE members = rb_ary_new_capa(args->n_members);
+
+  for (size_t i = 0; i < args->n_members; i++) {
+    rb_ary_push(members, rb_funcall(
+      cItemComponent,
+      id_new,
+      6,
+      rb_str_new(&args->members[i].format, 1),
+      args->members[i].native_size_p ? Qtrue : Qfalse,
+      args->members[i].little_endian_p ? Qtrue : Qfalse,
+      SIZET2NUM(args->members[i].offset),
+      SIZET2NUM(args->members[i].size),
+      SIZET2NUM(args->members[i].repeat)
+    ));
+  }
+
+  return members;
+}
+
+// Want to be implemented in Fiddle gem
+static VALUE
+ndav_s_parse_item_format(VALUE klass, VALUE format)
+{
+  rb_memory_view_item_component_t *members;
+  size_t n_members;
+  const char *err;
+
+  ssize_t byte_size = rb_memory_view_parse_item_format(
+    StringValueCStr(format),
+    &members,
+    &n_members,
+    &err
+  );
+  if (byte_size < 0) {
+    rb_raise(rb_eRuntimeError, "Parse error at: %s", err);
+  }
+  if (n_members == 0) {
+    xfree(members);
+    return rb_ary_new();
+  }
+  init_item_components_args args = {
+    .members = members,
+    .n_members = n_members
+  };
+  int state = 0;
+  VALUE members_v = rb_protect(init_item_components, (VALUE)&args, &state);
+  xfree(members);
+  if (state != 0) {
+    rb_jump_tag(state);
+  }
+
+  return members_v;
+}
+
 void
 Init_ndav(void)
 {
   id_ndav_validated_descriptor = rb_intern("ndav_validated_descriptor");
-  sym_data = ID2SYM(rb_intern("data"));
+  sym_addr = ID2SYM(rb_intern("addr"));
   sym_shape = ID2SYM(rb_intern("shape"));
   sym_strides = ID2SYM(rb_intern("strides"));
   sym_format = ID2SYM(rb_intern("format"));
@@ -227,10 +255,13 @@ Init_ndav(void)
   sym_sub_offsets = ID2SYM(rb_intern("sub_offsets"));
   sym_ndim = ID2SYM(rb_intern("ndim"));
   sym_item_size = ID2SYM(rb_intern("item_size"));
-  sym_row_major_contiguous_p = ID2SYM(rb_intern("row_major_contiguous?"));
-  sym_column_major_contiguous_p = ID2SYM(rb_intern("column_major_contiguous?"));
+  id_new = rb_intern("new");
 
   VALUE cNDAV = rb_define_class("NDAV", rb_cObject);
   VALUE mMemoryViewable = rb_define_module_under(cNDAV, "MemoryViewable");
   rb_define_singleton_method(mMemoryViewable, "register", ndav_memory_viewable_s_register, 1);
+
+  rb_require("ndav/item_component");
+  cItemComponent = rb_path2class("NDAV::ItemComponent");
+  rb_define_singleton_method(cNDAV, "parse_item_format", ndav_s_parse_item_format, 1);
 }

data/lib/ndav/ffi.rb

@@ -20,7 +20,7 @@ class NDAV
       module ToNDAV
         def to_ndav(format: TYPE_SIZE_TO_FORMAT[type_size], lifetime: self, **)
           shape = [size / type_size]
-          byte_size = shape.reduce(ITEM_SIZES[format], :*)
+          byte_size = shape.reduce(::NDAV::ITEM_SIZES[format], :*)
           ptr = ::Fiddle::Pointer.new(address, byte_size)
           ::NDAV.new(ptr, shape:, format:, lifetime:, **)
         end
@@ -30,7 +30,7 @@ class NDAV
         def ndav_descriptor(**)
           shape = [size / type_size]
           format = TYPE_SIZE_TO_FORMAT[type_size]
-          item_size = ITEM_SIZES[format]
+          item_size = ::NDAV::ITEM_SIZES[format]
           byte_size = shape.reduce(item_size, :*)
           ptr = ::Fiddle::Pointer.new(address, byte_size)
 
@@ -69,7 +69,7 @@ class NDAV
 
       module ToNDAV
         def to_ndav(shape:, format: TYPE_SIZE_TO_FORMAT[type_size], lifetime: self, **)
-          byte_size = shape.reduce(ITEM_SIZES[format], :*)
+          byte_size = shape.reduce(::NDAV::ITEM_SIZES[format], :*)
           ptr = ::Fiddle::Pointer.new(address, byte_size)
           ::NDAV.new(ptr, shape:, format:, lifetime:, **)
         end

data/lib/ndav/flags.rb

@@ -15,11 +15,15 @@ class NDAV
 
     def decode(flags)
       FLAGS.each_with_object({}) {|(name, value), state|
-        if name == :simple
-          state[name] = flags == 0
-        else
-          state[name] = flags & value == value
-        end
+        state[name] = case name
+                      when :simple
+                        flags == value
+                      when :any_contiguous
+                        (flags & FLAGS[:row_major]) == FLAGS[:row_major] ||
+                        (flags & FLAGS[:column_major]) == FLAGS[:column_major]
+                      else
+                        flags & value == value
+                      end
       }
     end
   end

data/lib/ndav/import.rb

@@ -0,0 +1,9 @@
+class NDAV
+  module Import
+    require "fiddle/import"
+
+    extend Fiddle::Importer
+    dlload Fiddle::Handle::DEFAULT
+    extern "ssize_t rb_memory_view_item_size_from_format(const char *format, const char **err)"
+  end
+end

data/lib/ndav/item_component.rb

@@ -0,0 +1,13 @@
+class NDAV
+  ItemComponent = Data.define(
+    :format,
+    :native_size_p,
+    :little_endian_p,
+    :offset,
+    :size,
+    :repeat
+  ) {
+    def native_size? = native_size_p
+    def little_endian? = little_endian_p
+  }
+end

data/lib/ndav/memory_viewable.rb

@@ -1,43 +1,114 @@
 class NDAV
+  # +include+ this module and define +#ndav_descriptor+ method in your class,
+  # and then the class exports a MemoryView.
+  # 
+  # +#ndav_descriptor+ 's keyword arguments are flags of MemoryView including
+  # +simple+, +writable+, +format+, +multi_dimensional+, +strides+, +row_major+, +column_major+, +any_contiguous+, +indirect+.
+  # For the meaning of them, see MemoryView document.
+  # 
+  # It must return a Hash whose keys includes:
+  # 
+  # * +:data+: Required. Binary +String+, pointer address +Integer+ or +Fiddle::Pointer+. This is passed to +Fiddle::Pointer.to_ptr+, so should be valid for the method.
+  # * +:shape+: Required. See MemoryView document.
+  # * +:strides+: Required. See MemoryView document.
+  # * +:format+: Required. See MemoryView document.
+  # * +:byte_size+: Required. See MemoryView document.
+  # * +:readonly?+: Required. See MemoryView document.
+  # * +:sub_offsets+: Optional. See MemoryView document.
+  # 
+  # @example
+  #   class YourClass
+  #     include NDAV::MemoryViewable
+  #     #  :
+  #     def ndav_descriptor(
+  #       simple:,
+  #       writable:,
+  #       format:,
+  #       multi_dimensional:,
+  #       strides:,
+  #       row_major:,
+  #       column_major:,
+  #       any_contiguous:,
+  #       indirect:
+  #     )
+  #       {
+  #         data:,
+  #         shape:,
+  #         strides:,
+  #         format:,
+  #         byte_size:,
+  #         readonly?:,
+  #         sub_offsets:
+  #       }
+  #     end
+  #     #  :
+  #   end
   module MemoryViewable
     class << self
       def included(base)
-        ::NDAV::MemoryViewable.register base
+        register base
       end
     end
 
     private
 
-    # Overwrite this method or define each ndav_xxx method
-    def ndav_descriptor(simple: true, writable: false, format: false, multi_dimensional: false, strides: false, row_major: false, column_major: false, any_contiguous: false, indirect: false)
-      {
-        data: ndav_data,
-        shape: ndav_shape,
-        strides: ndav_strides,
-        format: ndav_format,
-        byte_size: ndav_byte_size,
-        readonly?: ndav_readonly?,
-        sub_offsets: ndav_sub_offsets
-      }
-    end
-
     def ndav_validated_descriptor(flags = ::NDAV::Flags::FLAGS[:simple])
-      desc = ndav_descriptor(**NDAV::Flags.decode(flags)).to_h
-      unless desc.kind_of? Hash
-        warn "descriptor not Hash"
-        return false
-      end
+      flags = ::NDAV::Flags.decode(flags)
+      desc = ndav_descriptor(**flags).to_h
+      desc => {data:, shape:, strides:, format:, byte_size:, readonly?: readonly}
+      sub_offsets = desc[:sub_offsets]
+
       [:data, :shape, :strides, :format, :byte_size, :readonly?].each do |key|
-        unless desc.key? key
-          warn ":#{key} not in descriptor"
+        if desc[key].nil?
+          warn ":#{key} is nil"
+          return false
+        end
+      end
+      [:shape, :strides].each do |key|
+        unless desc[key].instance_of? Array
+          warn "#{key} not Array"
           return false
         end
       end
+      if sub_offsets && !sub_offsets.instance_of?(Array)
+        warn "sub_offsets not Array"
+        return false
+      end
+      item_size = ::NDAV::ITEM_SIZES[format]
+      unless shape.reduce(item_size, :*) == byte_size
+        warn "item size from format and shape not match byte_size"
+        return false
+      end
+
+      if flags[:writable] && readonly
+        warn "not writable"
+        return false
+      end
+
+      # TODO: Research the meaning of MULTI_DIMENSIONAL and validate it
+
+      if flags[:indirect] && !sub_offsets
+        warn "indirect requested but sub_offsets is NULL"
+        return false
+      end
+
+      row_major_contiguous = ::NDAV.row_major_contiguous?(format:, shape:, strides:)
+      column_major_contiguous = ::NDAV.column_major_contiguous?(format:, shape:, strides:)
+      if flags[:row_major] && !row_major_contiguous
+        return false
+      end
+      if flags[:column_major] && !column_major_contiguous
+        return false
+      end
+      if flags[:any_contiguous] && !row_major_contiguous && !column_major_contiguous
+        return false
+      end
+
       desc.merge(
-        ndim: desc[:shape].length,
-        item_size: NDAV::ITEM_SIZES[desc[:format]],
-        row_major_contiguous?: ::NDAV.row_major_contiguous?(**desc),
-        column_major_contiguous?: ::NDAV.column_major_contiguous?(**desc)
+        addr: ::Fiddle::Pointer.to_ptr(data).to_i,
+        ndim: shape.length,
+        item_size:,
+        sub_offsets:
       )
     rescue => err
       warn err

data/lib/ndav.rb

@@ -3,19 +3,52 @@ require "ndav.so"
 require "ndav/flags"
 require "ndav/converter"
 require "ndav/memory_viewable"
+require "ndav/import"
 
-# TODO: Manage flags of internal data object
 class NDAV
   include MemoryViewable
 
-  # TODO: Want to use return value of rb_memory_view_parse_item_format
-  ITEM_SIZES = ["c", "C", "s", "S", "l", "L", "q", "Q", "f", "d", "s!", "S!", "n", "v", "i", "i!", "I", "I!", "l!", "L!", "N", "V", "e", "g", "q!", "Q!", "E", "G"].collect {|format|
-    [format, [0].pack(format).bytesize]
-  }.to_h
+  ITEM_SIZES = Hash.new {|sizes, format| sizes[format] = item_size_from_format(format)}
+  ITEM_DESCS = Hash.new {|descs, format| descs[format] = parse_item_format(format)}
+  DEFAULT_FORMATS = {
+    1 => "C",
+    2 => "s",
+    4 => "l",
+    8 => "q"
+  }
 
-  attr_reader :ndim, :shape, :format, :item_size, :byte_size, :strides, :to_s, :lifetime
+  attr_reader :ndim, :shape, :format, :item_size, :byte_size, :strides, :sub_offsets, :to_s, :lifetime
 
   class << self
+    # * Doesn't modify byte_size
+    # * Keyword arguments override obj's MemoryView members
+    # * Overrides obj's members as required by keyword arguments
+    #     * ex) format: "C" requires item_size = 1 even if obj's item_size isn't it
+    # * Raises exception if keyword arguments conflict
+    alias new_override new
+
+    # * Raises exception when a keyword argument is not nil and obj's corresponding member is not nil
+    def new(obj, shape: nil, strides: nil, format: nil, lifetime: nil)
+      is_fmv = obj.kind_of? Fiddle::MemoryView
+      fmv = is_fmv ? obj : Fiddle::MemoryView.new(obj)
+
+      if shape && fmv.shape
+        raise ArgumentError, "shape is already set. Cannot override."
+      end
+      if strides && fmv.strides
+        raise ArgumentError, "strides is already set. Cannot override."
+      end
+      if format && fmv.format
+        raise ArgumentError, "format is already set. Cannot override."
+      end
+
+      new_override(obj, shape:, strides:, format:, lifetime:)
+    ensure
+      unless is_fmv
+        fmv&.release
+      end
+    end
+
     def default_strides(shape:, item_size:, row_major: true)
       each_shape = row_major ? shape.reverse_each : shape.each
       each_shape.reduce([[], item_size]) {|(strides, stride), s|
@@ -57,50 +90,78 @@ class NDAV
 
       true
     end
+
+    def item_size_from_format(format)
+      err = Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP)
+      size = Import.rb_memory_view_item_size_from_format(format, err)
+      if size < 0
+        raise ArgumentError, "Invalid format character: #{err.ptr.to_s}"
+      else
+        size
+      end
+    ensure
+      err&.free
+    end
   end
 
-  # TODO: More options to trick for the case of MemoryView export is wrong but developer don't fix it
-  def initialize(obj, shape: nil, strides: nil, format: nil, lifetime: nil)
-    fmv = obj.kind_of?(::Fiddle::MemoryView) ? obj : ::Fiddle::MemoryView.new(obj)
+  def initialize(obj, readonly: nil, format: nil, item_size: nil, shape: nil, strides: nil, sub_offsets: nil, lifetime: nil)
+    # We cannot determine flags until ndav_descriptor is called but some MemoryView producer like Fiddle::Pointer and IO::Buffer determines some members by flags.
+    # For instance, Fiddle::Pointer's MemoryView is readonly when writable flag is not passed and is not readonly when writable flag is passed.
+    # How should we solve this mismatching? Delaying to determine the flags?
+    # Considers when it becomes actual problem.
+    @fmv = obj.kind_of?(::Fiddle::MemoryView) ? obj : ::Fiddle::MemoryView.new(obj)
     # Fiddle::MemoryView#to_s is zero-copy
     # Fiddle::MemoryView#to_s embeds obj into the String, so we can prevent GC from collecting it
-    @to_s = fmv.to_s
+    @to_s = @fmv.to_s
     @lifetime = lifetime
+    @byte_size = @fmv.byte_size
 
-    @format = format || fmv.format
-    raise ArgumentError, %Q|unsupported format: #{@format.to_s.dump}, currently supported: #{ITEM_SIZES.keys}| unless ITEM_SIZES.key?(@format)
-
-    item_size_by_format = ITEM_SIZES[@format]
+    case [format, item_size]
+    in [nil, nil]
+      @format = @fmv.format || "C"
+      @item_size = @fmv.item_size
+    in [_, nil]
+      @format = format
+      @item_size = ITEM_SIZES[@format]
+    in [nil, _]
+      @item_size = item_size
+      @format = DEFAULT_FORMATS[@item_size] || @fmv.format
+    else
+      @format = format
+      @item_size = item_size
+    end
 
-    @byte_size = fmv.byte_size
-    @item_size = obj.kind_of?(::Fiddle::Pointer) ? item_size_by_format : fmv.item_size || item_size_by_format
-    @shape = shape || fmv.shape
-    case [@shape, @byte_size]
+    case [shape, @byte_size]
     in [nil, nil]
-      raise ArgumentError, "either shape or byte_size must be present in obj or arguments"
+      @shape = @fmv.shape
+      @byte_size = @shape.reduce(@item_size, :*)
     in [_, nil]
+      @shape = shape
       @byte_size = @shape.reduce(@item_size, :*)
     in [nil, _]
-      n, r = @byte_size.divmod(@item_size)
-      raise ArgumentError, "byte_size must be n-times of item_size" unless r.zero?
-      @shape = [n]
+      @shape = @fmv.shape || [@byte_size / @item_size]
     else
-      # noop
+      @shape = shape
     end
+
     @ndim = @shape.size
-    @readonly = fmv.readonly?
-    @strides = strides || fmv.strides || self.class.default_strides(shape: @shape, item_size: @item_size)
-    @sub_offsets = fmv.sub_offsets
+    @readonly = readonly.nil? ? @fmv.readonly? : readonly
+    @strides = strides || @fmv.strides || self.class.default_strides(shape: @shape, item_size: @item_size)
+    @sub_offsets = sub_offsets || @fmv.sub_offsets
     @row_major_contiguous = self.class.row_major_contiguous?(format: @format, shape: @shape, strides: @strides)
     @column_major_contiguous = self.class.column_major_contiguous?(format: @format, shape: @shape, strides: @strides)
 
-    validate fmv
+    validate
   end
 
   def readonly?
     @readonly
   end
 
+  def item_desc
+    ITEM_DESCS[@format]
+  end
+
   def row_major_contiguous?
     @row_major_contiguous
   end
@@ -114,9 +175,16 @@ class NDAV
   end
   alias to_fiddle_pointer to_ptr
 
+  def release
+    @fmv.release
+    @fmv = @ndim = @readonly = @shape = @format = @item_size = @byte_size = @strides = @sub_offsets = @lifetime = @to_s = @row_major_contiguous = @column_major_contiguous = nil
+  end
+
   private
 
   def ndav_descriptor(**)
+    return false unless @fmv
+
     {
       data: @to_s,
       shape: @shape,
@@ -128,16 +196,47 @@ class NDAV
     }
   end
 
-  def validate(fmv)
+  def validate
+    raise ArgumentError, "byte_size must be present" unless @byte_size
+
     unless @item_size == ITEM_SIZES[@format]
-      raise ArgumentError, "item_size does not match format"
+      raise ArgumentError, "item_size does not match format. item_size: #{@item_size.inspect}, format: #{@format.inspect}"
     end
 
+    r = @byte_size % @item_size
+    raise ArgumentError, "byte_size must be n-times of item_size" unless r.zero?
+
+    raise ArgumentError, "shape length doen't match ndim" unless @shape.length == @ndim
     if @row_major_contiguous || @column_major_contiguous
-      byte_size = @shape.reduce(@item_size, :*)
-      unless byte_size == @byte_size
-        raise ArgumentError, "strides not match byte_size"
+      unless @byte_size == @shape.reduce(@item_size, :*)
+        raise ArgumentError, "shape not match byte_size"
+      end
+    end
+
+    raise ArgumentError, "strides length doen't match ndim" unless @strides.length == @ndim
+    if @row_major_contiguous
+      stride = @item_size
+      @strides.reverse_each.with_index do |s, i|
+        raise ArgumentError, "invalid strides" unless s == stride
+        stride *= @shape[@ndim - i - 1]
+      end
+    else
+      max_offset = 0
+      min_offset = 0
+      @shape.zip(@strides) do |s, stride|
+        next if s == 0
+
+        extent = (s - 1) * stride
+        max_offset += [extent, 0].max
+        min_offset += [extent, 0].min
+      end
+      if min_offset < 0
+        # NDAV uses Fiddle::MemoryView#to_s and it doesn't allow negative min offset
+        # Some MemoryView might allow negative min offset
+        # Remove this check if such the MemoryView producer is found
+        raise ArgumentError, "min offset must be positive"
       end
+      raise ArgumentError, "max offset too large" if max_offset + @item_size > @byte_size
     end
   end
 end

data/ndav.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = "ndav"
-  s.version = "0.0.5"
+  s.version = "0.0.7"
   s.summary = "N-Dimensional Array View"
   s.authors = ["Kitaiti Makoto"]
   s.licenses = ["BSD-2-Clause"]
@@ -22,5 +22,4 @@ Gem::Specification.new do |s|
   s.add_development_dependency "red-arrow"
   s.add_development_dependency "ffi"
   s.add_development_dependency "yard"
-  s.add_development_dependency "commonmarker"
 end

data/test/test_flags.rb

@@ -0,0 +1,28 @@
+require_relative "helper"
+
+class TestFlags < TestBase
+  include NDAV::Flags
+
+  def test_any_contiguous
+    decoded = decode(combine_flags(:any_contiguous))
+    assert_true decoded[:row_major]
+    assert_true decoded[:column_major]
+    assert_true decoded[:any_contiguous]
+
+    decoded = decode(combine_flags(:row_major))
+    assert_true decoded[:row_major]
+    assert_false decoded[:column_major]
+    assert_true decoded[:any_contiguous]
+
+    decoded = decode(combine_flags(:column_major))
+    assert_false decoded[:row_major]
+    assert_true decoded[:column_major]
+    assert_true decoded[:any_contiguous]
+  end
+
+  private
+
+  def combine_flags(*flags)
+    flags.reduce(0) {|composed, name| composed | FLAGS[name]}
+  end
+end

data/test/test_ndav.rb

@@ -36,6 +36,19 @@ class TestNDAV < TestBase
     assert_int_array ndav
   end
 
+  def test_item_descs
+    assert_equal [
+      NDAV::ItemComponent.new(
+        format: "s",
+        native_size_p: false,
+        little_endian_p: true,
+        offset: 0,
+        size: 2,
+        repeat: 1
+      )
+    ], NDAV.new(@array).item_desc
+  end
+
   def test_column_major
     str = [1, 2, 3,
            4, 5, 6].pack("s*")
@@ -43,4 +56,151 @@ class TestNDAV < TestBase
 
     assert_true ndav.column_major_contiguous?
   end
+
+  def test_release
+    ndav = NDAV.new(@array)
+
+    ndav.release
+    [:ndim, :shape, :format, :item_size, :byte_size, :strides, :sub_offsets, :lifetime, :to_s].each do |attr|
+      assert_nil ndav.send(attr)
+    end
+    assert_nil ndav.readonly?
+    assert_nil ndav.row_major_contiguous?
+    assert_nil ndav.column_major_contiguous?
+  end
+
+  def test_parse_item_format
+    assert_equal [
+      NDAV::ItemComponent.new("f", false, IO::Buffer::HOST_ENDIAN == IO::Buffer::LITTLE_ENDIAN, 0, 4, 1)
+    ], NDAV.parse_item_format("f")
+
+    assert_equal [
+      NDAV::ItemComponent.new("s", false, true, 0, 2, 1)
+    ], NDAV.parse_item_format("s<")
+
+    assert_equal [
+      NDAV::ItemComponent.new("C", false, true, 0, 1, 1),
+      NDAV::ItemComponent.new("C", false, true, 1, 1, 1),
+      NDAV::ItemComponent.new("C", false, true, 2, 1, 1),
+    ], NDAV.parse_item_format("CCC")
+
+    assert_equal [
+      NDAV::ItemComponent.new("C", false, true, 0, 1, 3)
+    ], NDAV.parse_item_format("C3")
+  end
+
+  class TestOverwrite < self
+    def test_format
+      assert_raise ArgumentError do
+        NDAV.new(@array, format: "C")
+      end
+
+      ndav = NDAV.new_override(@array, format: "C")
+      Fiddle::MemoryView.export ndav do |memview|
+        assert_equal "C", memview.format
+        assert_equal 1, memview.item_size
+        assert_equal 6, memview.byte_size
+      end
+
+      assert_raise ArgumentError do
+        NDAV.new(@array, format: "f")
+      end
+    end
+
+    def test_item_size
+      assert_raise ArgumentError do
+        NDAV.new(@array, item_size: 1)
+      end
+
+      ndav = NDAV.new_override(@array, item_size: 1)
+      Fiddle::MemoryView.export ndav do |memview|
+        assert_equal 1, memview.item_size
+        assert_equal "C", memview.format
+        assert_equal 6, memview.byte_size
+      end
+
+      assert_raise ArgumentError do
+        NDAV.new_override(@array, item_size: 4)
+      end
+    end
+
+    def test_format_and_item_size
+      assert_raise ArgumentError do
+        NDAV.new(@array, format: "C", item_size: 1)
+      end
+
+      ndav = NDAV.new_override(@array, format: "C", item_size: 1)
+      Fiddle::MemoryView.export ndav do |memview|
+        assert_equal "C", memview.format
+        assert_equal 1, memview.item_size
+        assert_equal 6, memview.byte_size
+      end
+
+      assert_raise ArgumentError do
+        NDAV.new_override(@array, format: "C", item_size: 2)
+      end
+    end
+
+    def test_shape
+      array_with_shape = NDAV.new(@array)
+      assert_raise ArgumentError do
+        NDAV.new(array_with_shape, shape: [3, 1])
+      end
+
+      ndav = NDAV.new_override(@array, shape: [3, 1])
+      Fiddle::MemoryView.export ndav do |memview|
+        assert_equal [3, 1], memview.shape
+        assert_equal 2, memview.ndim
+        assert_equal 6, memview.byte_size
+      end
+
+      assert_raise ArgumentError do
+        NDAV.new_override(@array, shape: [2, 3, 4])
+      end
+    end
+
+    def test_strides
+      array_with_shape = NDAV.new(@array)
+      assert_raise ArgumentError do
+        NDAV.new(array_with_shape, strides: [2])
+      end
+
+      ndav = NDAV.new_override(@array, strides: [2])
+      Fiddle::MemoryView.export ndav do |memview|
+        assert_equal [2], memview.strides
+        assert_equal [3], memview.shape
+        assert_equal 2, memview.item_size
+        assert_equal 6, memview.byte_size
+      end
+
+      assert_raise ArgumentError do
+        NDAV.new_override(@array, strides: [4])
+      end
+
+      assert_raise ArgumentError do
+        NDAV.new_override(@array, strides: [6])
+      end
+    end
+
+    def test_shape_and_strides
+      ndav = NDAV.new_override(@array, shape: [1, 3], strides: [6, 2])
+      Fiddle::MemoryView.export ndav do |memview|
+        assert_equal [1, 3], memview.shape
+        assert_equal [6, 2], memview.strides
+        assert_equal 6, memview.byte_size
+      end
+    end
+
+    def test_overwrite_readonly?
+      assert_raise ArgumentError do
+        NDAV.new(@array, readonly: false)
+      end
+
+      ndav = NDAV.new_override(@array, readonly: false)
+      Fiddle::MemoryView.export ndav do |memview|
+        assert_false memview.readonly?
+        assert_equal 6, memview.byte_size
+      end
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ndav
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.7
 platform: ruby
 authors:
 - Kitaiti Makoto
@@ -163,20 +163,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: commonmarker
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 executables: []
 extensions:
 - ext/extconf.rb
@@ -195,12 +181,15 @@ files:
 - lib/ndav/converter.rb
 - lib/ndav/ffi.rb
 - lib/ndav/flags.rb
+- lib/ndav/import.rb
+- lib/ndav/item_component.rb
 - lib/ndav/memory_viewable.rb
 - ndav.gemspec
 - test/helper.rb
 - test/test_converter.rb
 - test/test_export.rb
 - test/test_ffi.rb
+- test/test_flags.rb
 - test/test_ndav.rb
 - test/test_package.rb
 - test/test_ractor.rb