xnd 0.2.0dev7 → 0.2.0dev8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 88ae9320468c5a0d6129cbb1403f5c0cb4968bb3
-  data.tar.gz: 6ca5834d15f88f89a420ec841ad191855fa846d3
+  metadata.gz: a0032edbe644ff3632a9c8b31e39e8f2c115e066
+  data.tar.gz: 71a128e17b888289770f6237010a3547665b7173
 SHA512:
-  metadata.gz: 238cac8e9ce6e4aed41e57c55abaf68286781b642ed356ba6339eb2e262aae2c0081f2d6aabc63db104295452300eddb8daf20b9da90b512d1a5d055956bac4f
-  data.tar.gz: 4943e104993ca0910904feaab4c29b8d484faf3fe31c910e28980d59d9d7d69edcd45e2b6ad728a08fb5dc0669ac39f617c4877889510680f5e35d626d705917
+  metadata.gz: fe327a114d2fe24f3e00044df66d0d4ef706df05c1b75808febd4be8470545ea47fa37d3d83e8eeb50b5b99b876761169fe50930b2f497819704ecea4ab45b83
+  data.tar.gz: 9ef65d4867c3d04d5e2eb0533a04bace38d5c855ff895d24563640fa93fc341338c8671441c787a2e5c06a92eb60b23ea003480c93cc4bb4aa26d18be3717773

data/ext/ruby_xnd/include/ruby_xnd.h

@@ -54,6 +54,7 @@ extern "C" {
   VALUE rb_xnd_from_xnd(xnd_t *x);
   
   typedef struct XndObject XndObject;
+  extern VALUE cXND;
 
 #ifdef __cplusplus
 }

data/ext/ruby_xnd/ruby_xnd.c

@@ -35,7 +35,9 @@
  */
 
 #include "ruby_xnd_internal.h"
+#include "ruby_xnd.h"
 #include "xnd.h"
+#include "ruby.h"
 
 #define XND_CHECK_NUMERIC(obj) Check_Type(obj, T_FIXNUM); \
   Check_Type(obj, T_BIGNUM); Check_Type(obj, T_RATIONAL); \
@@ -148,10 +150,8 @@ mblock_alloc(void)
   if (self == NULL) {
     
   }
-
   self->type = NULL;
   self->xnd = NULL;
-
   return self;
 }
 
@@ -422,6 +422,28 @@ mblock_init(xnd_t * const x, VALUE data)
 
     return 0;
   }
+
+  case VarDimElem: {
+    int64_t start, step, shape;
+    shape = ndt_var_indices(&start, &step, t, x->index, &ctx);
+    if (shape < 0) {
+      seterr(&ctx);
+      raise_error();
+    }
+
+    const int64_t i = adjust_index(t->VarDimElem.index, shape, &ctx);
+    if (i < 0) {
+      seterr(&ctx);
+      raise_error();
+    }
+
+    xnd_t next = xnd_var_dim_next(x, start, step, i);
+    if (mblock_init(&next, data) < 0) {
+      return -1;
+    }
+
+    return 0;
+  }
     
   case Tuple: {
     const int64_t shape = t->Tuple.shape;
@@ -621,6 +643,10 @@ mblock_init(xnd_t * const x, VALUE data)
     return 0;
   }
 
+  case BFloat16: {
+    rb_raise(rb_eNotImpError, "bfloat16 not implemented.");    
+  }
+
   case Float16: {
     rb_raise(rb_eNotImpError, "float16 not implemented.");
   }
@@ -634,6 +660,10 @@ mblock_init(xnd_t * const x, VALUE data)
     double temp = NUM2DBL(data);
     return rb_xnd_pack_float64(temp, (unsigned char*)x->ptr, le(t->flags));
   }
+    
+  case BComplex32: {
+    rb_raise(rb_eNotImpError, "bcomplex32 not implemented.");
+  }
 
   case Complex32: {
     rb_raise(rb_eNotImpError, "complex32 not implemented.");
@@ -815,6 +845,38 @@ mblock_init(xnd_t * const x, VALUE data)
     return 0;
   }
 
+  case Array: {
+    bool overflow = false;
+    
+    Check_Type(data, T_ARRAY);
+
+    const size_t shape = rb_ary_size(data);
+    const int64_t size = MULi64(shape, t->Array.itemsize, &overflow);
+    if (overflow) {
+      ndt_err_format(&ctx, NDT_ValueError, "datasize of flexible array to large.");
+      seterr(&ctx);
+      raise_error();
+    }
+
+    char * aligned = ndt_aligned_calloc(t->align, size);
+    if (data == NULL) {
+      rb_raise(rb_eNoMemError, "ndt_aligned_calloc failed.");
+    }
+
+    xnd_clear(x, XND_OWN_EMBEDDED);
+    XND_ARRAY_SHAPE(x->ptr) = shape;
+    XND_ARRAY_DATA(x->ptr) = aligned;
+
+    for (int64_t i = 0; i < shape; i++) {
+      xnd_t next = xnd_array_next(x, i);
+      if (mblock_init(&next, rb_ary_entry(data, i)) < 0) {
+        return -1;
+      }
+    }
+
+    return 0;
+  }
+
   case Categorical: {
     int64_t k;
     
@@ -937,7 +999,7 @@ static VALUE XND_size(VALUE self);
 
 /* Allocate an XndObject and return wrapped in a Ruby object. */
 static VALUE
-XndObject_alloc(void)
+XndObject_alloc(VALUE klass)
 {
   XndObject *xnd;
 
@@ -952,7 +1014,7 @@ XndObject_alloc(void)
   xnd->xnd.type  = NULL;
   xnd->xnd.ptr = NULL;
 
-  return WRAP_XND(cXND, xnd);
+  return WRAP_XND(klass, xnd);
 }
 
 /* Mark Ruby objects within XndObject. */
@@ -1385,6 +1447,10 @@ _XND_value(const xnd_t * const x, const int64_t maxshape)
     return ULL2NUM(temp);
   }
 
+  case BFloat16: {
+    rb_raise(rb_eNotImpError, "bfloat16 is not implemented.");
+  }
+
   case Float16: {
     rb_raise(rb_eNotImpError, "float16 is not implemented.");
   }
@@ -1403,6 +1469,10 @@ _XND_value(const xnd_t * const x, const int64_t maxshape)
     return DBL2NUM(temp);
   }
 
+  case BComplex32: {
+    rb_raise(rb_eNotImpError, "bcomplex32 not implemented.");    
+  }
+
   case Complex32: {
     rb_raise(rb_eNotImpError, "complex32 not implemented.");
   }
@@ -1481,6 +1551,34 @@ _XND_value(const xnd_t * const x, const int64_t maxshape)
     return bytes_from_string_and_size(s, size);
   }
 
+  case Array: {
+    VALUE lst, v;
+    int64_t shape;
+
+    shape = XND_ARRAY_SHAPE(x->ptr);
+    if (shape > maxshape) {
+      shape = maxshape;
+    }
+
+    lst = rb_ary_new2(shape);
+
+    for (int i = 0; i < shape; ++i) {
+      if (i == maxshape-1) {
+        rb_ary_store(lst, i, xnd_ellipsis());
+        break;
+      }
+
+      const xnd_t next = xnd_array_next(x, i);
+      v = _XND_value(&next, maxshape);
+      if (v == NULL) {
+        return NULL;
+      }
+      rb_ary_store(lst, i, v);
+    }
+
+    return lst;
+  }
+
   case Categorical: {
     int64_t k;
 
@@ -1568,7 +1666,7 @@ RubyXND_view_move_type(XndObject *src_p, xnd_t *x)
   type = rb_ndtypes_from_type(x->type);
   ndt_decref(x->type);
   
-  view = XndObject_alloc();
+  view = XndObject_alloc(cXND);
   GET_XND(view, view_p);
 
   view_p->mblock = src_p->mblock;
@@ -2149,7 +2247,7 @@ XND_copy_contiguous(int argc, VALUE *argv, VALUE self)
     seterr(&ctx);
   }
 
-  dest = rb_xnd_empty_from_type(t, 0);
+  dest = rb_xnd_empty_from_type(cXND, t, 0);
   ndt_decref(t);
 
   GET_XND(dest, dest_p);
@@ -2274,7 +2372,7 @@ XND_s_deserialize(VALUE klass, VALUE v)
   
   memcpy(mblock_p->xnd->master.ptr, s, mblock_size);
 
-  self = XndObject_alloc();
+  self = XndObject_alloc(cXND);
   GET_XND(self, self_p);
   XND_from_mblock(self_p, mblock);
     
@@ -2297,7 +2395,7 @@ RubyXND_s_empty(VALUE klass, VALUE origin_type, VALUE device)
   VALUE mblock_type, xnd_type;
   uint32_t flags = 0;
 
-  self = XndObject_alloc();
+  self = XndObject_alloc(cXND);
   GET_XND(self, self_p);
 
   if (device != Qnil) {
@@ -2366,7 +2464,7 @@ rb_xnd_from_xnd(xnd_t *x)
   MemoryBlockObject *mblock_p;
   
   mblock = mblock_from_xnd(x);
-  xnd = XndObject_alloc();
+  xnd = XndObject_alloc(cXND);
   GET_XND(xnd, xnd_p);
   GET_MBLOCK(mblock, mblock_p);
   type = mblock_p->type;
@@ -2382,7 +2480,7 @@ rb_xnd_from_xnd(xnd_t *x)
 
 /* Create an XND object of type ndt_t */
 VALUE
-rb_xnd_empty_from_type(const ndt_t *t, uint32_t flags)
+rb_xnd_empty_from_type(VALUE klass, const ndt_t *t, uint32_t flags)
 {
   MemoryBlockObject *mblock_p;
   XndObject *xnd_p;
@@ -2390,7 +2488,7 @@ rb_xnd_empty_from_type(const ndt_t *t, uint32_t flags)
 
   type = rb_ndtypes_from_type(t);
   mblock = mblock_empty(type, flags);
-  xnd = XndObject_alloc();
+  xnd = XndObject_alloc(klass);
 
   GET_XND(xnd, xnd_p);
 
@@ -2409,6 +2507,34 @@ rb_xnd_get_type(void)
   
 }
 
+XndObject *
+rb_xnd_get_xnd_object(VALUE obj)
+{
+  XndObject *xnd_p;
+  GET_XND(obj, xnd_p);
+  return xnd_p;
+}
+
+MemoryBlockObject *
+rb_xnd_get_mblock_object(VALUE mblock)
+{
+  MemoryBlockObject *mblock_p;
+  GET_MBLOCK(mblock, mblock_p);
+  return mblock_p;
+}
+
+int
+rb_xnd_is_cuda_managed(VALUE xnd)
+{
+  XndObject *xnd_p;
+  MemoryBlockObject *mblock_p;
+
+  GET_XND(xnd, xnd_p);
+  GET_MBLOCK(xnd_p->mblock, mblock_p);
+
+  return (mblock_p->xnd->flags & XND_CUDA_MANAGED);
+}
+
 /*
  * This function handles two common view cases:
  *

data/ext/ruby_xnd/ruby_xnd.h

@@ -45,16 +45,21 @@ extern "C" {
 #include "xnd.h"
 #include "overflow.h"
 
+  typedef struct MemoryBlockObject MemoryBlockObject;
+  typedef struct XndObject XndObject;
+  extern VALUE cXND;
+  
   size_t rb_xnd_hash_size(VALUE hash);
   int rb_xnd_get_complex_values(VALUE comp, double *real, double *imag);
   /* Return true if obj is of type XND. */
   int rb_xnd_check_type(VALUE obj);
   const xnd_t * rb_xnd_const_xnd(VALUE xnd);
-  VALUE rb_xnd_empty_from_type(const ndt_t *t, uint32_t flags);
+  VALUE rb_xnd_empty_from_type(VALUE klass, const ndt_t *t, uint32_t flags);
   VALUE rb_xnd_from_xnd(xnd_t *x);
-  
-  typedef struct XndObject XndObject;
-
+  XndObject * rb_xnd_get_xnd_object(VALUE obj);
+  MemoryBlockObject * rb_xnd_get_mblock_object(VALUE mblock);
+  int rb_xnd_is_cuda_managed(VALUE xnd);
+ 
 #ifdef __cplusplus
 }
 #endif

data/ext/ruby_xnd/util.c

@@ -163,3 +163,18 @@ ndt_exists(void)
 {
   return RTEST(rb_const_get(rb_cObject, rb_intern("NDT")));
 }
+
+int
+rb_ary_size(VALUE array)
+{
+  Check_Type(array, T_ARRAY);
+  return FIX2INT(rb_funcall(array, rb_intern("size"), 0, NULL));
+}
+
+void
+rb_puts(VALUE v) {
+  ID sym_puts = rb_intern("puts");
+  ID sym_inspect = rb_intern("inspect");
+  rb_funcall(rb_mKernel, sym_puts, 1,
+             rb_funcall(v, sym_inspect, 0));
+}

data/ext/ruby_xnd/util.h

@@ -58,4 +58,8 @@ VALUE bytes_from_string_and_size(const char *str, int64_t size);
 
 int ndt_exists(void);
 
+int rb_ary_size(VALUE array);
+
+void rb_puts(VALUE v);
+
 #endif  /* UTIL_H */

data/ext/ruby_xnd/xnd/config.log

@@ -12,9 +12,9 @@ generated by GNU Autoconf 2.69.  Invocation command line was
 
 hostname = sameer-K401UB
 uname -m = x86_64
-uname -r = 5.0.0-23-generic
+uname -r = 5.0.0-27-generic
 uname -s = Linux
-uname -v = #24~18.04.1-Ubuntu SMP Mon Jul 29 16:12:28 UTC 2019
+uname -v = #28~18.04.1-Ubuntu SMP Thu Aug 22 03:00:32 UTC 2019
 
 /usr/bin/uname -p = unknown
 /bin/uname -X     = unknown
@@ -29,6 +29,7 @@ uname -v = #24~18.04.1-Ubuntu SMP Mon Jul 29 16:12:28 UTC 2019
 
 PATH: /home/sameer/.rvm/gems/ruby-2.4.1/bin
 PATH: /home/sameer/anaconda3/condabin
+PATH: /home/sameer/anaconda3/bin
 PATH: /home/sameer/gitrepos/starpu-1.2.8/bin
 PATH: /home/sameer/.rvm/gems/ruby-2.4.1@global/bin
 PATH: /home/sameer/.rvm/rubies/ruby-2.4.1/bin

data/lib/xnd.rb

@@ -298,7 +298,6 @@ class XND < RubyXND
     end
   end
 
-  
   def initialize data, type: nil, dtype: nil, levels: nil, typedef: nil,
       dtypedef: nil, device: nil
     if [type, dtype, levels, typedef, dtypedef].count(nil) < 2
@@ -346,5 +345,17 @@ class XND < RubyXND
     _transpose(permute)
   end
 
-  alias :to_a :value
+  def inspect
+    str = "#<#{self.class}:#{object_id}>\n"
+    str += "\t type= " + self.type.to_s + "\n"
+    str += "\t value= "
+    str += self.short_value(10).to_s
+    str += "\n"
+    
+    str
+  end
+
+  def to_s
+    short_value(10).to_s
+  end
 end # class XND

data/lib/xnd/version.rb

@@ -1,6 +1,6 @@
 class RubyXND
   # VERSION number should be the version of libxnd this is built against.
-  VERSION = "0.2.0dev7"
+  VERSION = "0.2.0dev8"
   # Working commit in xnd repo
   COMMIT = '6f305cd40d90b4f3fc2fe51ae144b433d186a6cc'
 end

data/xnd.gemspec

@@ -45,5 +45,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'pry'
   spec.add_development_dependency 'pry-byebug'
 
-  spec.add_runtime_dependency 'ndtypes', '>= 0.2.0dev6'
+  spec.add_runtime_dependency 'ndtypes', '>= 0.2.0dev8'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: xnd
 version: !ruby/object:Gem::Version
-  version: 0.2.0dev7
+  version: 0.2.0dev8
 platform: ruby
 authors:
 - Sameer Deshmukh
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-06 00:00:00.000000000 Z
+date: 2019-09-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -100,14 +100,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.2.0dev6
+        version: 0.2.0dev8
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.2.0dev6
+        version: 0.2.0dev8
 description: 'XND is a library for typed data arrays in Ruby. It is a wrapper over
   the libxnd C library.