pnmatrix 2.0.0 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c61ebac7b89f8d0fd43e09fdbe74aa0ef1564232c1f56224837cf8e1dd3ea7cc
-  data.tar.gz: 19c1789f16a5c87a91b2b0de44dbfa39bc024a117f166a43bd466528b7fe24c7
+  metadata.gz: a13074d0b3e5e2bbee2a456f42fe5d5d7a4b4e581e2ae42e149d74f4a1452211
+  data.tar.gz: 917446ac40ebe45b13a62c6c0e1e927227beee199a411e2c0cc1fa83f5e9f1bc
 SHA512:
-  metadata.gz: a53e78fa91ce0d8dbc30a5a0d9ad035d768238f3c9fba3de3f7eb1e181e4f1756c815db600bfc40e608c26aa6810083b69b4442a4a338904c7581209db9d0092
-  data.tar.gz: 2ef44f7c3f1079411c29c189d7c988c6432521f08d3291bcfbf9e555b400ac685a09673db8d07175a281a7973b774ebac4141cb176f004c38e2557b791486373
+  metadata.gz: 697596b71a0d302a785d4fe503676fe89392b60e84354fba5151b873f2bbf570e11f6086972c30bdf610eb9a2621387b5bf469c82280e8586888241773a3668f
+  data.tar.gz: 2a42bf5f5e4c97748e6d44aa631086e94c18bdb0b6f56503ce236d97a57cb8da0a272a016686b88d656f67f86d82124f9bef5bb7fbbfe39b91deefd6c657810d

data/ext/nmatrix/nmatrix.h

@@ -376,6 +376,14 @@ NM_DEF_STRUCT_POST(NM_GC_HOLDER);       // };
 // enum for a list of possible storage types.
 #define NM_STYPE(val)           (NM_STRUCT(val)->stype)
 
+/*
+ * Object dtype storage keeps Ruby VALUEs in malloc-backed arrays/lists, not in
+ * Ruby object fields. After mutating that native storage, make the wrapper
+ * object write-barrier-unprotected so minor GC runs nm_mark and sees newly
+ * assigned VALUEs before they can be collected.
+ */
+#define NM_OBJECT_STORAGE_WB_UNPROTECT(val) RB_OBJ_WB_UNPROTECT(val)
+
 // Get the shape of the ith dimension (int)
 #define NM_SHAPE(val,i)         (NM_STORAGE(val)->shape[(i)])
 

data/ext/nmatrix/ruby_nmatrix.c

@@ -412,8 +412,14 @@ static VALUE nm_alloc(VALUE klass) {
   mat->stype = nm::DENSE_STORE;
   mat->storage = NULL;
 
-  // DO NOT MARK This STRUCT. It has no storage allocated, and no stype, so mark will do an invalid something.
-  return Data_Wrap_Struct(klass, NULL, nm_delete, mat);
+  /*
+   * Newly allocated NMatrix wrappers do not have storage yet, but nm_mark is
+   * explicitly null-storage safe. Installing it here is required for object
+   * dtype matrices after initialization: otherwise Ruby never asks the matrix
+   * to mark VALUEs stored in native dense/list/Yale memory, so a later GC can
+   * reclaim objects that were assigned into the matrix.
+   */
+  return Data_Wrap_Struct(klass, nm_mark, nm_delete, mat);
 }
 
 /*

data/ext/nmatrix/storage/dense/dense.cpp

@@ -102,17 +102,21 @@ namespace nm { namespace dense_storage {
    * Recursive function, sets multiple values in a matrix from a single source value. Same basic pattern as slice_copy.
    */
   template <typename D>
-  static void slice_set(DENSE_STORAGE* dest, size_t* lengths, size_t pdest, size_t rank, D* const v, size_t v_size, size_t& v_offset) {
+  static void slice_set(VALUE owner, DENSE_STORAGE* dest, size_t* lengths, size_t pdest, size_t rank, D* const v, size_t v_size, size_t& v_offset) {
     if (dest->dim - rank > 1) {
       for (size_t i = 0; i < lengths[rank]; ++i) {
-        slice_set<D>(dest, lengths, pdest + dest->stride[rank] * i, rank + 1, v, v_size, v_offset);
+        slice_set<D>(owner, dest, lengths, pdest + dest->stride[rank] * i, rank + 1, v, v_size, v_offset);
       }
     } else {
       for (size_t p = 0; p < lengths[rank]; ++p, ++v_offset) {
         if (v_offset >= v_size) v_offset %= v_size;
 
         D* elem = reinterpret_cast<D*>(dest->elements);
-        elem[p + pdest] = v[v_offset];
+        if (dest->dtype == nm::RUBYOBJ) {
+          RB_OBJ_WRITE(owner, reinterpret_cast<VALUE*>(elem) + p + pdest, reinterpret_cast<VALUE*>(v)[v_offset]);
+        } else {
+          elem[p + pdest] = v[v_offset];
+        }
       }
     }
   }
@@ -127,6 +131,9 @@ namespace nm { namespace dense_storage {
     NM_CONSERVATIVE(nm_register_value(&right));
 
     DENSE_STORAGE* s = NM_STORAGE_DENSE(left);
+    if (s->dtype == nm::RUBYOBJ) {
+      NM_OBJECT_STORAGE_WB_UNPROTECT(left);
+    }
 
     std::pair<NMATRIX*,bool> nm_and_free =
       interpret_arg_as_dense_nmatrix(right, s->dtype);
@@ -158,10 +165,15 @@ namespace nm { namespace dense_storage {
     }
 
     if (slice->single) {
-      reinterpret_cast<D*>(s->elements)[nm_dense_storage_pos(s, slice->coords)] = *v;
+      size_t pos = nm_dense_storage_pos(s, slice->coords);
+      if (s->dtype == nm::RUBYOBJ) {
+        RB_OBJ_WRITE(left, reinterpret_cast<VALUE*>(s->elements) + pos, *reinterpret_cast<VALUE*>(v));
+      } else {
+        reinterpret_cast<D*>(s->elements)[pos] = *v;
+      }
     } else {
       size_t v_offset = 0;
-      slice_set(s, slice->lengths, nm_dense_storage_pos(s, slice->coords), 0, v, v_size, v_offset);
+      slice_set(left, s, slice->lengths, nm_dense_storage_pos(s, slice->coords), 0, v, v_size, v_offset);
     }
 
     // Only free v if it was allocated in this function.
@@ -311,14 +323,25 @@ void nm_dense_storage_mark(STORAGE* storage_base) {
   DENSE_STORAGE* storage = (DENSE_STORAGE*)storage_base;
 
   if (storage && storage->dtype == nm::RUBYOBJ) {
-    VALUE* els = reinterpret_cast<VALUE*>(storage->elements);
-
-    if (els) {
-      rb_gc_mark_locations(els, &(els[nm_storage_count_max_elements(storage)-1]));
+    /*
+     * Dense slice references share the source storage's elements pointer and
+     * may start at a non-zero offset. Marking only the reference's element
+     * count from offset zero can miss Ruby objects that are visible through
+     * the reference. Mark the backing source storage so every object that a
+     * live reference can expose stays alive.
+     */
+    DENSE_STORAGE* src = reinterpret_cast<DENSE_STORAGE*>(storage->src);
+
+    size_t count = src ? nm_storage_count_max_elements(src) : 0;
+    if (src && src->elements && count > 0) {
+      VALUE* els = reinterpret_cast<VALUE*>(src->elements);
+      /*
+       * This storage holds exact Ruby VALUEs, not arbitrary machine words.
+       * Mark each slot explicitly so objects assigned into malloc-backed
+       * matrix memory are kept alive just like Ruby object fields would be.
+       */
+      for (size_t i = 0; i < count; ++i) rb_gc_mark(els[i]);
     }
-    //for (size_t index = nm_storage_count_max_elements(storage); index-- > 0;) {
-    //  rb_gc_mark(els[index]);
-    //}
   }
 }
 

data/ext/nmatrix/storage/list/list.cpp

@@ -538,6 +538,9 @@ void set(VALUE left, SLICE* slice, VALUE right) {
   NM_CONSERVATIVE(nm_register_value(&left));
   NM_CONSERVATIVE(nm_register_value(&right));
   LIST_STORAGE* s = NM_STORAGE_LIST(left);
+  if (s->dtype == nm::RUBYOBJ) {
+    NM_OBJECT_STORAGE_WB_UNPROTECT(left);
+  }
 
   std::pair<NMATRIX*,bool> nm_and_free =
     interpret_arg_as_dense_nmatrix(right, NM_DTYPE(left));

data/ext/nmatrix/storage/yale/class.h

@@ -50,7 +50,18 @@ public:
    : s(reinterpret_cast<YALE_STORAGE*>(storage->src)),
      slice(storage != storage->src),
      slice_shape(storage->shape),
-     slice_offset(storage->offset)
+     slice_offset(storage->offset),
+     owner(Qnil)
+  {
+    nm_yale_storage_register(storage->src);
+  }
+
+  YaleStorage(const YALE_STORAGE* storage, VALUE owner_)
+   : s(reinterpret_cast<YALE_STORAGE*>(storage->src)),
+     slice(storage != storage->src),
+     slice_shape(storage->shape),
+     slice_offset(storage->offset),
+     owner(owner_)
   {
     nm_yale_storage_register(storage->src);
   }
@@ -59,7 +70,8 @@ public:
    : s(reinterpret_cast<YALE_STORAGE*>(storage->src)),
      slice(storage != storage->src),
      slice_shape(storage->shape),
-     slice_offset(storage->offset)
+     slice_offset(storage->offset),
+     owner(Qnil)
   {
     nm_yale_storage_register(reinterpret_cast<STORAGE*>(storage->src));
   }
@@ -96,6 +108,17 @@ public:
   inline const D& a(size_t p) const   { return a_p()[p]; }
   inline D& a(size_t p)               { return a_p()[p]; }
 
+  // Object matrices store Ruby VALUEs in native memory, so replacing a value must
+  // go through Ruby's write barrier. Without it, generational GC can collect a
+  // newly assigned object before the matrix is marked again.
+  inline void write_a(size_t p, const D& val) {
+    if (dtype() == nm::RUBYOBJ && owner != Qnil) {
+      RB_OBJ_WRITE(owner, reinterpret_cast<VALUE*>(s->a) + p, reinterpret_cast<const VALUE*>(&val)[0]);
+    } else {
+      a(p) = val;
+    }
+  }
+
   bool real_row_empty(size_t i) const { return ija(i+1) - ija(i) == 0 ? true : false; }
 
   inline size_t* shape_p()        const { return slice_shape;      }
@@ -467,7 +490,7 @@ public:
    * A pseudo-insert operation, since the diagonal portion of the A array is constant size.
    */
   stored_diagonal_iterator insert(stored_diagonal_iterator position, const D& val) {
-    *position = val;
+    write_a(position.p(), val);
     return position;
   }
 
@@ -694,24 +717,37 @@ public:
 
     E* ns_a    = reinterpret_cast<E*>(ns.a);
     size_t sz  = shape(0) + 1; // current used size of ns
-    nm_yale_storage_register(&ns);
+    E converted = val;
+    if (ns.dtype == nm::RUBYOBJ) {
+      nm_register_value(reinterpret_cast<VALUE*>(&converted));
+    }
 
     // FIXME: If diagonals line up, it's probably faster to do this with stored diagonal and stored non-diagonal iterators
     for (const_row_iterator it = cribegin(); it != criend(); ++it) {
       for (auto jt = it.begin(); !jt.end(); ++jt) {
         if (it.i() == jt.j()) {
-          if (Yield)  ns_a[it.i()] = rb_yield(~jt);
-          else        ns_a[it.i()] = static_cast<E>(*jt);
+          if (Yield)  converted = E(rb_yield(~jt));
+          else        converted = static_cast<E>(*jt);
+          if (ns.dtype == nm::RUBYOBJ) {
+            nm_register_value(reinterpret_cast<VALUE*>(&converted));
+          }
+          ns_a[it.i()] = converted;
         } else if (*jt != const_default_obj()) {
-          if (Yield)  ns_a[sz]     = rb_yield(~jt);
-          else        ns_a[sz]     = static_cast<E>(*jt);
+          if (Yield)  converted = E(rb_yield(~jt));
+          else        converted = static_cast<E>(*jt);
+          if (ns.dtype == nm::RUBYOBJ) {
+            nm_register_value(reinterpret_cast<VALUE*>(&converted));
+          }
+          ns_a[sz]     = converted;
           ns.ija[sz]    = jt.j();
           ++sz;
         }
       }
       ns.ija[it.i()+1]  = sz;
     }
-    nm_yale_storage_unregister(&ns);
+    if (ns.dtype == nm::RUBYOBJ) {
+      nm_unregister_value(reinterpret_cast<VALUE*>(&converted));
+    }
 
     //ns.ija[shape(0)] = sz;                // indicate end of last row
     ns.ndnz          = sz - shape(0) - 1; // update ndnz count
@@ -751,14 +787,24 @@ public:
 
       E* la = reinterpret_cast<E*>(lhs->a);
 
-      nm_yale_storage_register(lhs);
+      E converted;
+      if (lhs->dtype == nm::RUBYOBJ) {
+        nm_register_value(reinterpret_cast<VALUE*>(&converted));
+      }
       for (size_t m = 0; m < size(); ++m) {
         if (Yield) {
-    la[m] = rb_yield(nm::yale_storage::nm_rb_dereference(a(m)));
-  }
-        else       la[m] = static_cast<E>(a(m));
+          converted = E(rb_yield(nm::yale_storage::nm_rb_dereference(a(m))));
+        } else {
+          converted = static_cast<E>(a(m));
+        }
+        if (lhs->dtype == nm::RUBYOBJ) {
+          nm_register_value(reinterpret_cast<VALUE*>(&converted));
+        }
+        la[m] = converted;
+      }
+      if (lhs->dtype == nm::RUBYOBJ) {
+        nm_unregister_value(reinterpret_cast<VALUE*>(&converted));
       }
-      nm_yale_storage_unregister(lhs);
 
     }
 
@@ -995,10 +1041,18 @@ protected:
         if (v_offset >= v_size) v_offset %= v_size;
 
         if (j + real_j == i + real_i) { // modify diagonal
-          new_a[real_i + i] = v[v_offset];
+          if (s->dtype == nm::RUBYOBJ && owner != Qnil) {
+            RB_OBJ_WRITE(owner, reinterpret_cast<VALUE*>(new_a) + real_i + i, reinterpret_cast<const VALUE*>(v)[v_offset]);
+          } else {
+            new_a[real_i + i] = v[v_offset];
+          }
         } else if (v[v_offset] != const_default_obj()) {
           new_ija[q]        = j + real_j;
-          new_a[q]          = v[v_offset];
+          if (s->dtype == nm::RUBYOBJ && owner != Qnil) {
+            RB_OBJ_WRITE(owner, reinterpret_cast<VALUE*>(new_a) + q, reinterpret_cast<const VALUE*>(v)[v_offset]);
+          } else {
+            new_a[q]        = v[v_offset];
+          }
           ++q; // move on to next q location
         }
 
@@ -1132,6 +1186,7 @@ protected:
   bool          slice;
   size_t*       slice_shape;
   size_t*       slice_offset;
+  VALUE         owner;
 };
 
 } // end of nm namespace

data/ext/nmatrix/storage/yale/iterators/row.h

@@ -303,7 +303,7 @@ public:
     while (!position.end() && position.j() < jj) ++position; // position is just a hint. (This loop ideally only has to happen once.)
 
     if (!position.end() && position.j() == jj) {
-      *position = val;      // replace existing
+      y.write_a(position.p(), val);      // replace existing
     } else {
 
       if (sz + 1 > y.capacity()) {
@@ -313,7 +313,7 @@ public:
         y.update_real_row_sizes_from(real_i(), 1);
       }
       ija(position.p()) = jj + y.offset(1);    // set column ID
-      a(position.p())   = val;
+      y.write_a(position.p(), val);
       adjust_length(1);
     }
 
@@ -331,7 +331,7 @@ public:
    */
   //template <typename = typename std::enable_if<!std::is_const<RefType>::value>::type>
   void insert(size_t j, const D& val) {
-    if (j + y.offset(1) == real_i())  a(real_i()) = val;
+    if (j + y.offset(1) == real_i())  y.write_a(real_i(), val);
     else {
       row_stored_nd_iterator jt = ndfind(j);
       if (!jt.end() && jt.j() == j) {
@@ -404,10 +404,10 @@ public:
       if (v_offset >= v_size) v_offset %= v_size; // reset v position.
 
       if (jc + y.offset(1) == real_i()) {
-        y.a(real_i())   = v[v_offset];  // modify diagonal
+        y.write_a(real_i(), v[v_offset]);  // modify diagonal
       } else if (v[v_offset] != y.const_default_obj()) {
         y.ija(pp)       = jc;           // modify non-diagonal
-        y.a(pp)         = v[v_offset];
+        y.write_a(pp, v[v_offset]);
         ++pp;
       }
     }

data/ext/nmatrix/storage/yale/yale.cpp

@@ -369,7 +369,10 @@ YALE_STORAGE* ref(YALE_STORAGE* s, SLICE* slice) {
 template <typename DType>
 void set(VALUE left, SLICE* slice, VALUE right) {
   YALE_STORAGE* storage = NM_STORAGE_YALE(left);
-  YaleStorage<DType> y(storage);
+  if (storage->dtype == nm::RUBYOBJ) {
+    NM_OBJECT_STORAGE_WB_UNPROTECT(left);
+  }
+  YaleStorage<DType> y(storage, left);
   y.insert(slice, right);
 }
 
@@ -1456,9 +1459,25 @@ void nm_yale_storage_mark(STORAGE* storage_base) {
   YALE_STORAGE* storage = (YALE_STORAGE*)storage_base;
 
   if (storage && storage->dtype == nm::RUBYOBJ) {
-
-    VALUE* a = (VALUE*)(storage->a);
-    rb_gc_mark_locations(a, &(a[storage->capacity-1]));
+    /*
+     * Yale slice references are lightweight wrappers around another
+     * YALE_STORAGE. They may have no A array or capacity of their own, but
+     * Ruby objects returned through the reference still live in the source
+     * storage. Mark the source's initialized A entries so GC cannot reclaim
+     * those objects while the reference is alive.
+     */
+    YALE_STORAGE* src = reinterpret_cast<YALE_STORAGE*>(storage->src);
+
+    size_t size = src ? nm::yale_storage::get_size(src) : 0;
+    if (src && src->a && size > 0) {
+      VALUE* a = reinterpret_cast<VALUE*>(src->a);
+      /*
+       * Yale object storage keeps real Ruby VALUEs in the native A array.
+       * Marking them exactly is important after mutation, because otherwise
+       * GC may reclaim recently assigned objects before later iteration.
+       */
+      for (size_t i = 0; i < size; ++i) rb_gc_mark(a[i]);
+    }
   }
 }
 

data/lib/nmatrix/mkmf.rb

@@ -32,7 +32,7 @@ def find_newer_gplusplus #:nodoc:
   [9,8,7,6,5,4,3].each do |minor|
     ver = "4.#{minor}"
     gpp = "g++-#{ver}"
-    result = `which #{gpp}`
+    result = `type #{gpp}`
     next if result.empty?
     CONFIG['CXX'] = gpp
     puts ver

data/lib/nmatrix/nmatrix.rb

@@ -727,7 +727,7 @@ class NMatrix
     end
 
     # Do the actual construction.
-    n = NMatrix.new(new_shape, opts)
+    n = NMatrix.new(new_shape, **opts)
 
     # Figure out where to start concatenation. We don't know where it will end,
     # because each matrix may have own size along concat dimension.

data/lib/nmatrix/version.rb

@@ -29,11 +29,10 @@ class NMatrix
   module VERSION #:nodoc:
     MAJOR = 2
     MINOR = 0
-    TINY = 0
+    TINY = 1
     #PRE = "a"
 
     STRING = [MAJOR, MINOR, TINY].compact.join(".")
     #STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end
 end
-

data/spec/io_spec.rb

@@ -51,6 +51,7 @@ describe NMatrix::IO do
   end
 
   it "reads MATLAB .mat file containing a single square sparse matrix" do
+    skip "Mat5Reader was removed from pnmatrix" unless defined?(NMatrix::IO::Matlab::Mat5Reader)
     pending("not yet implemented for NMatrix-JRuby") if jruby?
     n = NMatrix::IO::Matlab.load_mat("spec/4x4_sparse.mat")
     expect(n[0,0]).to eq(2)
@@ -62,19 +63,20 @@ describe NMatrix::IO do
   end
 
   it "reads MATLAB .mat file containing a single dense integer matrix" do
+    skip "Mat5Reader was removed from pnmatrix" unless defined?(NMatrix::IO::Matlab::Mat5Reader)
     n = NMatrix::IO::Matlab.load_mat("spec/4x5_dense.mat")
     m = NMatrix.new([4,5], [16,17,18,19,20,15,14,13,12,11,6,7,8,9,10,5,4,3,2,1])
     expect(n).to eq(m)
   end
 
   it "reads MATLAB .mat file containing a single dense double matrix" do
+    skip "Mat5Reader was removed from pnmatrix" unless defined?(NMatrix::IO::Matlab::Mat5Reader)
     n = NMatrix::IO::Matlab.load_mat("spec/2x2_dense_double.mat")
     m = NMatrix.new(2, [1.1, 2.0, 3.0, 4.0], dtype: :float64)
     expect(n).to eq(m)
   end
 
   it "loads and saves MatrixMarket .mtx file containing a single large sparse double matrix" do
-    pending "spec disabled because it's so slow"
     n = NMatrix::IO::Market.load("spec/utm5940.mtx")
     NMatrix::IO::Market.save(n, "spec/utm5940.saved.mtx")
     expect(`wc -l spec/utm5940.mtx`.split[0]).to eq(`wc -l spec/utm5940.saved.mtx`.split[0])

data/spec/lapack_core_spec.rb

@@ -273,8 +273,9 @@ describe "NMatrix::LAPACK functions with internal implementations" do
               end
 
         expect(s).to be_within(err).of(s_true)
-        expect(u).to be_within(err).of(u_true)
-        expect(vt).to be_within(err).of(vt_true)
+        # Singular vectors are only defined up to sign (or complex phase).
+        expect(u.abs).to be_within(err).of(u_true.abs)
+        expect(vt.abs).to be_within(err).of(vt_true.abs)
 
         expect(s.dtype).to eq(a.abs_dtype)
         expect(u.dtype).to eq(dtype)
@@ -306,8 +307,9 @@ describe "NMatrix::LAPACK functions with internal implementations" do
               end
 
         expect(s).to be_within(err).of(s_true)
-        expect(u).to be_within(err).of(u_true)
-        expect(vt).to be_within(err).of(vt_true)
+        # Singular vectors are only defined up to sign (or complex phase).
+        expect(u.abs).to be_within(err).of(u_true.abs)
+        expect(vt.abs).to be_within(err).of(vt_true.abs)
       end
 
 
@@ -337,8 +339,9 @@ describe "NMatrix::LAPACK functions with internal implementations" do
               end
 
         expect(eigenvalues).to be_within(err).of(eigenvalues_true)
-        expect(vr).to be_within(err).of(vr_true)
-        expect(vl).to be_within(err).of(vl_true)
+        # Eigenvectors are only defined up to sign (or complex phase).
+        expect(vr.abs).to be_within(err).of(vr_true.abs)
+        expect(vl.abs).to be_within(err).of(vl_true.abs)
 
         expect(eigenvalues.dtype).to eq(NMatrix.upcast(dtype, :complex64))
         expect(vr.dtype).to eq(NMatrix.upcast(dtype, :complex64))
@@ -384,7 +387,8 @@ describe "NMatrix::LAPACK functions with internal implementations" do
               end
 
         expect(eigenvalues).to be_within(err).of(eigenvalues_true)
-        expect(vr).to be_within(err).of(vr_true)
+        # Eigenvectors are only defined up to sign (or complex phase).
+        expect(vr.abs).to be_within(err).of(vr_true.abs)
         expect(vl).to be_within(err).of(vl_true)
 
         expect(eigenvalues.dtype).to eq(dtype)
@@ -441,7 +445,8 @@ describe "NMatrix::LAPACK functions with internal implementations" do
               end
 
         expect(eigenvalues).to be_within(err).of(eigenvalues_true)
-        expect(vr).to be_within(err).of(vr_true)
+        # Eigenvectors are only defined up to sign (or complex phase).
+        expect(vr.abs).to be_within(err).of(vr_true.abs)
       end
     end
   end

data/spec/math_spec.rb

@@ -82,8 +82,10 @@ describe "math" do
             end
 
             it "should correctly apply elementwise natural log" do
-              expect(@m.log).to eq N.new(@size, [0, Math.log(2), Math.log(3), Math.log(4)],
-                                        dtype: :float64, stype: stype)
+              expect(@m.log).to be_within(1e-14).of(
+                N.new(@size, [0, Math.log(2), Math.log(3), Math.log(4)],
+                      dtype: :float64, stype: stype)
+              )
             end
 
             it "should correctly apply elementwise log with arbitrary base" do
@@ -264,6 +266,7 @@ describe "math" do
           expect(r).to eq(b)
         rescue NotImplementedError
           pending "potrf! not implemented without plugins"
+          raise
         end
       end
 
@@ -280,6 +283,7 @@ describe "math" do
           expect(r).to eq(b)
         rescue NotImplementedError
           pending "potrf! not implemented without plugins"
+          raise
         end
       end
 
@@ -295,6 +299,7 @@ describe "math" do
           expect(l).to eq(l_true)
         rescue NotImplementedError
           pending "potrf! not implemented without plugins"
+          raise
         end
       end
     end
@@ -325,11 +330,13 @@ describe "math" do
         begin
           q,r = a.factorize_qr
 
-          expect(q).to be_within(err).of(q_solution)
-          expect(r).to be_within(err).of(r_solution)
+          # QR factors are only defined up to matched column/row signs.
+          expect(q.abs).to be_within(err).of(q_solution.abs)
+          expect(r.abs).to be_within(err).of(r_solution.abs)
 
         rescue NotImplementedError
           pending "Suppressing a NotImplementedError when the lapacke plugin is not available"
+          raise
         end
       end
 
@@ -359,11 +366,13 @@ describe "math" do
         begin
           q,r = a.factorize_qr
 
-          expect(q).to be_within(err).of(q_solution)
-          expect(r).to be_within(err).of(r_solution)
+          # QR factors are only defined up to matched column/row signs.
+          expect(q.abs).to be_within(err).of(q_solution.abs)
+          expect(r.abs).to be_within(err).of(r_solution.abs)
 
         rescue NotImplementedError
           pending "Suppressing a NotImplementedError when the lapacke plugin is not available"
+          raise
         end
       end
 
@@ -387,11 +396,13 @@ describe "math" do
         begin
           q,r = a.factorize_qr
 
-          expect(q).to be_within(err).of(q_solution)
-          expect(r).to be_within(err).of(r_solution)
+          # QR factors are only defined up to matched column/row signs.
+          expect(q.abs).to be_within(err).of(q_solution.abs)
+          expect(r.abs).to be_within(err).of(r_solution.abs)
 
         rescue NotImplementedError
           pending "Suppressing a NotImplementedError when the lapacke plugin is not available"
+          raise
         end
       end
 
@@ -416,6 +427,7 @@ describe "math" do
 
         rescue NotImplementedError
           pending "Suppressing a NotImplementedError when the lapacke plugin is not available"
+          raise
         end
       end
 
@@ -444,6 +456,7 @@ describe "math" do
 
         rescue NotImplementedError
           pending "Suppressing a NotImplementedError when the lapacke plugin is not available"
+          raise
         end
       end
     end
@@ -461,7 +474,7 @@ describe "math" do
             end
 
       it "should correctly invert a matrix in place (bang)" do
-        pending("not yet implemented for :object dtype") if dtype == :object
+        pending("not yet implemented for :object dtype") if dtype == :object && defined?(NMatrix::LAPACKE)
         a = NMatrix.new(:dense, 5, [1, 8,-9, 7, 5,
                                     0, 1, 0, 4, 4,
                                     0, 0, 1, 2, 5,
@@ -529,6 +542,7 @@ describe "math" do
             expect(a.dot(a.pinv)).to be_within(err).of(b)
           rescue NotImplementedError
             pending "Suppressing a NotImplementedError when the atlas plugin is not available"
+            raise
           end
 
         else
@@ -539,6 +553,7 @@ describe "math" do
             expect(a.dot(a.pinv)).to be_within(err).of(b)
           rescue NotImplementedError
             pending "Suppressing a NotImplementedError when the atlas plugin is not available"
+            raise
           end
         end
       end
@@ -556,6 +571,7 @@ describe "math" do
             expect(b.dot(a.dot(b))).to be_within(err).of(b)
           rescue NotImplementedError
             pending "Suppressing a NotImplementedError when the atlas plugin is not available"
+            raise
           end
 
         else
@@ -567,6 +583,7 @@ describe "math" do
             expect(b.dot(a.dot(b))).to be_within(err).of(b)
           rescue NotImplementedError
             pending "Suppressing a NotImplementedError when the atlas plugin is not available"
+            raise
           end
         end
       end
@@ -1134,7 +1151,6 @@ describe "math" do
           expect(@c.det).to be_within(@err).of(-18)
         end
         it "computes the exact determinant of 2x2 matrix" do
-          pending("not yet implemented for :object dtype") if dtype == :object
           if dtype == :byte
             expect{@a.det_exact}.to raise_error(DataTypeError)
           else
@@ -1166,7 +1182,6 @@ describe "math" do
           end
 
           it "scales the matrix by a given factor and return the result" do
-            pending("not yet implemented for :object dtype") if dtype == :object
             if integer_dtype? dtype
               expect{@m.scale 2.0}.to raise_error(DataTypeError)
             else
@@ -1178,7 +1193,6 @@ describe "math" do
           end
 
           it "scales the matrix in place by a given factor" do
-            pending("not yet implemented for :object dtype") if dtype == :object
             if dtype == :int8
               expect{@m.scale! 2}.to raise_error(DataTypeError)
             else
@@ -1196,7 +1210,6 @@ describe "math" do
   context "matrix_norm" do
     ALL_DTYPES.each do |dtype|
       context dtype do
-        pending("not yet implemented for :object dtype") if dtype == :object
         before do
           @n = NMatrix.new([3,3], [-4,-3,-2,
                                    -1, 0, 1,
@@ -1215,6 +1228,7 @@ describe "math" do
 
               rescue NotImplementedError
                 pending "Suppressing a NotImplementedError when the lapacke plugin is not available"
+                raise
             end
           end
         end
@@ -1240,6 +1254,7 @@ describe "math" do
               expect(@n.matrix_norm(-2)).to be_within(@matrix_norm_TOLERANCE).of(0.0)
               rescue NotImplementedError
                 pending "Suppressing a NotImplementedError when the lapacke plugin is not available"
+                raise
             end
             expect(@n.matrix_norm(-1)).to eq(6)
           end
@@ -1293,6 +1308,7 @@ describe "math" do
 
           rescue NotImplementedError
             pending "Suppressing a NotImplementedError when the lapacke plugin is not available" 
+            raise
           end         
         end
 
@@ -1308,6 +1324,7 @@ describe "math" do
 
           rescue NotImplementedError
              pending "Suppressing a NotImplementedError when the lapacke plugin is not available" 
+             raise
           end
         end
 
@@ -1323,6 +1340,7 @@ describe "math" do
 
           rescue NotImplementedError
              pending "Suppressing a NotImplementedError when the lapacke plugin is not available" 
+             raise
           end
         end
 
@@ -1338,6 +1356,7 @@ describe "math" do
 
           rescue NotImplementedError
              pending "Suppressing a NotImplementedError when the lapacke plugin is not available" 
+             raise
           end
         end
 
@@ -1353,6 +1372,7 @@ describe "math" do
 
           rescue NotImplementedError
              pending "Suppressing a NotImplementedError when the lapacke plugin is not available" 
+             raise
           end
         end
 

data/spec/stress_test_spec.rb

@@ -1,6 +1,94 @@
 require 'spec_helper'
 
 describe NMatrix do
+  def force_gc
+    20.times do
+      Array.new(1_000) { |i| "gc-pressure-#{i}" }
+      GC.start
+    end
+  end
+
+  def build_dense_object_reference
+    values = Array.new(64 * 64) { |i| "dense-object-#{i}" }
+    matrix = NMatrix.new([64, 64], values, stype: :dense, dtype: :object)
+
+    matrix[50...64, 45...64]
+  end
+
+  def build_yale_object_reference
+    rng = Random.new(5678)
+    matrix = NMatrix.new([35, 35], nil, stype: :yale, dtype: :object, capacity: 1)
+
+    700.times do |i|
+      matrix[rng.rand(35), rng.rand(35)] = "yale-object-#{i}"
+    end
+
+    matrix[3...30, 4...32]
+  end
+
+  def build_nested_yale_object_reference
+    rng = Random.new(6789)
+    matrix = NMatrix.new([45, 45], nil, stype: :yale, dtype: :object, capacity: 1)
+
+    1_000.times do |i|
+      matrix[rng.rand(45), rng.rand(45)] = "nested-yale-object-#{i}"
+    end
+
+    matrix[5...40, 6...39][7...28, 8...30]
+  end
+
+  def build_list_object_reference
+    matrix = NMatrix.new([30, 30], nil, stype: :list, dtype: :object)
+
+    30.times do |i|
+      matrix[i, (i * 7) % 30] = "list-object-#{i}"
+    end
+
+    matrix[4...28, 2...29]
+  end
+
+  def mutate_dense_object_matrix_without_external_references
+    rng = Random.new(555)
+    matrix = NMatrix.new([80, 80], nil, stype: :dense, dtype: :object)
+
+    5_000.times do |i|
+      matrix[rng.rand(80), rng.rand(80)] = "mut-dense-#{i}"
+      GC.start if (i % 25).zero?
+    end
+
+    matrix
+  end
+
+  def mutate_yale_object_matrix_without_external_references
+    rng = Random.new(333)
+    matrix = NMatrix.new([80, 80], nil, stype: :yale, dtype: :object, capacity: 1)
+
+    5_000.times do |i|
+      matrix[rng.rand(80), rng.rand(80)] = "mut-yale-#{i}"
+      GC.start if (i % 25).zero?
+    end
+
+    matrix
+  end
+
+  def mutate_list_object_matrix_without_external_references
+    rng = Random.new(888)
+    matrix = NMatrix.new([30, 30], nil, stype: :list, dtype: :object)
+
+    500.times do |i|
+      matrix[rng.rand(30), rng.rand(30)] = "mut-list-#{i}"
+      GC.start if (i % 10).zero?
+    end
+
+    matrix
+  end
+
+  def touch_reference(reference)
+    reference.each_stored_with_indices do |value, _i, _j|
+      value.to_s.hash
+    end
+  end
+
   specify do
     200.times do |i|
       size = rand(500..1000)
@@ -15,4 +103,79 @@ describe NMatrix do
       (m1*m2).det
     end
   end
+
+  specify "does not segfault when iterating a GC-stressed object Yale reference" do
+    reference = build_yale_object_reference
+
+    force_gc
+
+    touch_reference(reference)
+  end
+
+  specify "does not segfault when iterating a GC-stressed nested object Yale reference" do
+    reference = build_nested_yale_object_reference
+
+    force_gc
+
+    touch_reference(reference)
+  end
+
+  specify "does not segfault when iterating a GC-stressed object dense reference" do
+    reference = build_dense_object_reference
+
+    force_gc
+
+    reference.each_with_indices do |value, _i, _j|
+      value.to_s.hash
+    end
+  end
+
+  specify "does not segfault when iterating a GC-stressed object list reference" do
+    reference = build_list_object_reference
+
+    force_gc
+
+    touch_reference(reference)
+  end
+
+  specify "does not segfault after GC-stressed object dense mutation" do
+    matrix = mutate_dense_object_matrix_without_external_references
+
+    force_gc
+
+    matrix.each do |value|
+      value.to_s.hash
+    end
+  end
+
+  specify "does not segfault after GC-stressed object Yale mutation" do
+    matrix = mutate_yale_object_matrix_without_external_references
+
+    force_gc
+
+    touch_reference(matrix)
+  end
+
+  specify "does not segfault after GC-stressed object list mutation" do
+    matrix = mutate_list_object_matrix_without_external_references
+
+    force_gc
+
+    touch_reference(matrix)
+  end
+
+  specify "does not expose partially built Yale object storage during a cast" do
+    previous_gc_stress = GC.stress
+    GC.stress = true
+
+    current_stock = NMatrix.new([30, 1], 0, stype: :yale, dtype: :float64)
+    current_stock[3] = -4
+    current_stock[7] = 10
+    current_stock[11] = 50
+
+    quantity_made = (current_stock < 0).cast(dtype: :int32) * current_stock * -1
+    expect(quantity_made[3]).to eq(4)
+  ensure
+    GC.stress = previous_gc_stress
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pnmatrix
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.0.1
 platform: ruby
 authors:
 - John Woods