ndav 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0648fef27ca47ec51a45cacb90330e5fb2de53071d4223604752c04746ad9c2d'
-  data.tar.gz: 4af1dacda9bfa1258552bc271d773136b06ea414cce61c75c194c590f1361850
+  metadata.gz: '0194ddf5f19c3e973cb1ef947c125b598295db76eeca5998776612a592c40067'
+  data.tar.gz: 59f077dfdf2cdb48c675cde2e9addd7094a01417210fe28f8d786b93213ff8f8
 SHA512:
-  metadata.gz: b81a17db0cc3814963b47e590e2f3e021e86792326a98ad1f246df8f887c4f1e49aec42808c82aeceb522e28f05f7dac9d3a6eb65417fbfc9ff785cb75284723
-  data.tar.gz: 798ed5c4f2f84fa73b262af460e0054454a78d6f8a9eeacbb191f0b866c6c4e98ae72ed296af23b7a67d98d6894a988cc22dfc23484267d1773bd91ed7043a63
+  metadata.gz: e0ff36126d7192ace3dba90a706ec0f45032c590dd5085c0ca1e4166c6a6708b518ad7077ef9af54a6def14911e3a62c3bbda0e0d904cea0dd51ab46a9fb25dd
+  data.tar.gz: 97026defa9b86987290f46a5f04ae0133ca280a87bea04989954fb49055ccc230a5f33d5ac90a8d68c046a05dcfaa97c46c7d6f93fda90f4234f7bf074ae1293

data/README.md

@@ -57,7 +57,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 +108,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 +155,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;
@@ -31,8 +31,25 @@ 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;
@@ -42,8 +59,8 @@ ndav_get_memory_view(const VALUE ndav, rb_memory_view_t *view, int flags)
     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);
+  bool row_major_contiguous = RTEST(rb_hash_aref(desc, sym_row_major_contiguous_p));
+  bool column_major_contiguous = RTEST(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;
@@ -58,7 +75,7 @@ ndav_get_memory_view(const VALUE ndav, rb_memory_view_t *view, int flags)
     return false;
   }
   bool writable_requested = (flags & RUBY_MEMORY_VIEW_WRITABLE) == RUBY_MEMORY_VIEW_WRITABLE;
-  // TODO: Handle flags
+  // TODO: Handle other flags
 
   VALUE readonly_v = rb_hash_aref(desc, sym_readonly_p);
   bool readonly = NIL_P(readonly_v) || RTEST(readonly_v);
@@ -66,120 +83,112 @@ ndav_get_memory_view(const VALUE ndav, rb_memory_view_t *view, int flags)
     rb_warn("not writable");
     return false;
   }
-  view->readonly = readonly;
-  view->obj = ndav;
-  VALUE val = rb_hash_aref(desc, sym_data);
-  char *data = StringValuePtr(val);
-  view->data = data;
+  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;
+  }
+  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");
+    release_memview_common(&tmp);
+    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);
+    release_memview_common(&tmp);
+    rb_warn("strides is not an array");
     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) {
+      release_memview_common(&tmp);
       rb_warn("indirect requested but sub_offsets is NULL");
-      free((void *)view->shape);
-      free((void *)view->strides);
       return false;
     }
-    view->sub_offsets = NULL;
+    tmp.sub_offsets = NULL;
   } else if (!RB_TYPE_P(sub_offsets, T_ARRAY)) {
+    release_memview_common(&tmp);
     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);
+    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 +200,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
@@ -218,7 +232,7 @@ 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"));

data/lib/ndav/memory_viewable.rb

@@ -1,4 +1,48 @@
 class NDAV
+  # +include+ this module and define +#ndav_descriptor+ method in your class,
+  # and then the class exports a MemoryView.
+  # 
+  # +#ndav_descriptor+'s 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:            true,
+  #       writable:          false,
+  #       format:            false,
+  #       multi_dimensional: false,
+  #       strides:           false,
+  #       row_major:         false,
+  #       column_major:      false,
+  #       any_contiguous:    false,
+  #       indirect:          false
+  #     )
+  #       {
+  #         data:,
+  #         shape:,
+  #         strides:,
+  #         format:,
+  #         byte_size:,
+  #         readonly?:,
+  #         sub_offsets:
+  #       }
+  #     end
+  #     #  :
+  #   end
   module MemoryViewable
     class << self
       def included(base)
@@ -8,34 +52,23 @@ class NDAV
 
     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
       [:data, :shape, :strides, :format, :byte_size, :readonly?].each do |key|
         unless desc.key? key
           warn ":#{key} not in descriptor"
           return false
         end
       end
+      item_size = NDAV::ITEM_SIZES[desc[:format]]
+      unless desc[:shape].reduce(item_size, :*) == desc[:byte_size]
+        warn "item size from format and shape not match byte_size"
+        return false
+      end
       desc.merge(
+        addr: ::Fiddle::Pointer.to_ptr(desc[:data]).to_i,
         ndim: desc[:shape].length,
-        item_size: NDAV::ITEM_SIZES[desc[:format]],
+        item_size:,
         row_major_contiguous?: ::NDAV.row_major_contiguous?(**desc),
         column_major_contiguous?: ::NDAV.column_major_contiguous?(**desc)
       )

data/ndav.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = "ndav"
-  s.version = "0.0.5"
+  s.version = "0.0.6"
   s.summary = "N-Dimensional Array View"
   s.authors = ["Kitaiti Makoto"]
   s.licenses = ["BSD-2-Clause"]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ndav
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors:
 - Kitaiti Makoto