pnmatrix 1.2.4 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: be16fe762b002a63a7d2542fb5eb50ed02cf9fd86bc9bb783a480dbeee9aca8a
-  data.tar.gz: c0427a16637c1ed803ce4249d238ef419a903340f81e9705d59f99cd376697ad
+  metadata.gz: a13074d0b3e5e2bbee2a456f42fe5d5d7a4b4e581e2ae42e149d74f4a1452211
+  data.tar.gz: 917446ac40ebe45b13a62c6c0e1e927227beee199a411e2c0cc1fa83f5e9f1bc
 SHA512:
-  metadata.gz: 215cd7e47e75a13afb836e630a61d2f34057452601ca7cd9a70dd9a216258cd0b0763d6c064e36754475833c0ff8cec0144bdedf36f774d65a6498ae705c4954
-  data.tar.gz: b6f3078f05c24952b3dc8bab939a9b5f63cd673bda80450c5e229cc909913382d71adb5e9ff361a293c7e762ea741d0bc78d509567fc52fcdd1b13bb840e5670
+  metadata.gz: 697596b71a0d302a785d4fe503676fe89392b60e84354fba5151b873f2bbf570e11f6086972c30bdf610eb9a2621387b5bf469c82280e8586888241773a3668f
+  data.tar.gz: 2a42bf5f5e4c97748e6d44aa631086e94c18bdb0b6f56503ce236d97a57cb8da0a272a016686b88d656f67f86d82124f9bef5bb7fbbfe39b91deefd6c657810d

data/ext/nmatrix/extconf.rb

@@ -54,13 +54,13 @@ $srcs = basenames.map { |b| "#{b}.cpp" }
 create_conf_h("nmatrix_config.h")
 create_makefile("nmatrix")
 
-Dir.mkdir("data") unless Dir.exists?("data")
-Dir.mkdir("util") unless Dir.exists?("util")
-Dir.mkdir("storage") unless Dir.exists?("storage")
+Dir.mkdir("data") unless Dir.exist?("data")
+Dir.mkdir("util") unless Dir.exist?("util")
+Dir.mkdir("storage") unless Dir.exist?("storage")
 Dir.chdir("storage") do
-  Dir.mkdir("yale")  unless Dir.exists?("yale")
-  Dir.mkdir("list")  unless Dir.exists?("list")
-  Dir.mkdir("dense") unless Dir.exists?("dense")
+  Dir.mkdir("yale")  unless Dir.exist?("yale")
+  Dir.mkdir("list")  unless Dir.exist?("list")
+  Dir.mkdir("dense") unless Dir.exist?("dense")
 end
 
 # to clean up object files in subdirectories:

data/ext/nmatrix/math/math.h

@@ -339,12 +339,12 @@ namespace smmp_sort {
     if (a < b) {
       if (b < c) return b; // a b c
       if (a < c) return c; // a c b
-                 return a; // c a b
+      return a; // c a b
 
     } else { // a > b
       if (a < c) return a; // b a c
       if (b < c) return c; // b c a
-                 return b; // c b a
+      return b; // c b a
     }
   }
 

data/ext/nmatrix/nmatrix.h

@@ -338,6 +338,7 @@ NM_DEF_STRUCT_POST(NMATRIX);  // };
 /* Structs for dealing with VALUEs in use so that they don't get GC'd */
 
 NM_DEF_STRUCT_PRE(NM_GC_LL_NODE);       // struct NM_GC_LL_NODE {
+  VALUE* key;                           //   VALUE* key;
   VALUE* val;                           //   VALUE* val;
   size_t n;                             //   size_t n;
   NM_DECL_STRUCT(NM_GC_LL_NODE*, next); //   NM_GC_LL_NODE* next;
@@ -375,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)])
 
@@ -401,7 +410,7 @@ NM_DEF_STRUCT_POST(NM_GC_HOLDER);       // };
 
 #define NM_CHECK_ALLOC(x) if (!x) rb_raise(rb_eNoMemError, "insufficient memory");
 
-#define RB_FILE_EXISTS(fn)   (rb_funcall(rb_const_get(rb_cObject, rb_intern("File")), rb_intern("exists?"), 1, (fn)) == Qtrue)
+#define RB_FILE_EXISTS(fn)   (rb_funcall(rb_const_get(rb_cObject, rb_intern("File")), rb_intern("exist?"), 1, (fn)) == Qtrue)
 
 #define IsNMatrixType(v)  (RB_TYPE_P(v, T_DATA) && (RDATA(v)->dfree == (RUBY_DATA_FUNC)nm_delete || RDATA(v)->dfree == (RUBY_DATA_FUNC)nm_delete_ref))
 #define CheckNMatrixType(v)   if (!IsNMatrixType(v)) rb_raise(rb_eTypeError, "expected NMatrix on left-hand side of operation");

data/ext/nmatrix/ruby_nmatrix.c

@@ -409,10 +409,17 @@ void Init_nmatrix() {
  */
 static VALUE nm_alloc(VALUE klass) {
   NMATRIX* mat = NM_ALLOC(NMATRIX);
+  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);
 }
 
 /*
@@ -454,6 +461,8 @@ static VALUE nm_capacity(VALUE self) {
  * Mark function.
  */
 void nm_mark(NMATRIX* mat) {
+  if (!mat || !mat->storage) return;
+
   STYPE_MARK_TABLE(mark)
   mark[mat->stype](mat->storage);
 }
@@ -463,12 +472,17 @@ void nm_mark(NMATRIX* mat) {
  * Destructor.
  */
 void nm_delete(NMATRIX* mat) {
+  if (!mat) return;
+
   static void (*ttable[nm::NUM_STYPES])(STORAGE*) = {
     nm_dense_storage_delete,
     nm_list_storage_delete,
     nm_yale_storage_delete
   };
-  ttable[mat->stype](mat->storage);
+
+  if (mat->storage && mat->stype < nm::NUM_STYPES) {
+    ttable[mat->stype](mat->storage);
+  }
 
   NM_FREE(mat);
 }
@@ -477,12 +491,17 @@ void nm_delete(NMATRIX* mat) {
  * Slicing destructor.
  */
 void nm_delete_ref(NMATRIX* mat) {
+  if (!mat) return;
+
   static void (*ttable[nm::NUM_STYPES])(STORAGE*) = {
     nm_dense_storage_delete_ref,
     nm_list_storage_delete_ref,
     nm_yale_storage_delete_ref
   };
-  ttable[mat->stype](mat->storage);
+
+  if (mat->storage && mat->stype < nm::NUM_STYPES) {
+    ttable[mat->stype](mat->storage);
+  }
 
   NM_FREE(mat);
 }
@@ -503,7 +522,9 @@ static void __nm_mark_value_container(NM_GC_HOLDER* gc_value_holder_struct) {
   if (gc_value_holder_struct && gc_value_holder_struct->start) {
     NM_GC_LL_NODE* curr = gc_value_holder_struct->start;
     while (curr) {
-      rb_gc_mark_locations(curr->val, curr->val + curr->n);
+      if (curr->val && curr->n) {
+        rb_gc_mark_locations(curr->val, curr->val + curr->n);
+      }
       curr = curr->next;
     }
   }
@@ -540,7 +561,13 @@ void nm_register_values(VALUE* values, size_t n) {
     } else {
       to_insert = NM_ALLOC_NONRUBY(NM_GC_LL_NODE);
     }
-    to_insert->val = values;
+    to_insert->key = values;
+    if (n) {
+      to_insert->val = NM_ALLOC_N(VALUE, n);
+      memcpy(to_insert->val, values, sizeof(VALUE) * n);
+    } else {
+      to_insert->val = NULL;
+    }
     to_insert->n = n;
     to_insert->next = gc_value_holder_struct->start;
     gc_value_holder_struct->start = to_insert;
@@ -557,13 +584,17 @@ void nm_unregister_values(VALUE* values, size_t n) {
       NM_GC_LL_NODE* curr = gc_value_holder_struct->start;
       NM_GC_LL_NODE* last = NULL;
       while (curr) {
-        if (curr->val == values) {
+        if (curr->key == values) {
           if (last) {
             last->next = curr->next;
           } else {
             gc_value_holder_struct->start = curr->next;
           }
+          if (curr->val) {
+            NM_FREE(curr->val);
+          }
           curr->next = allocated_pool->start;
+          curr->key = NULL;
           curr->val = NULL;
           curr->n = 0;
           allocated_pool->start = curr;
@@ -602,14 +633,18 @@ void nm_completely_unregister_value(VALUE* val) {
     NM_GC_LL_NODE* curr = gc_value_holder_struct->start;
     NM_GC_LL_NODE* last = NULL;
     while (curr) {
-      if (curr->val == val) {
+      if (curr->key == val) {
         if (last) {
           last->next = curr->next;
         } else {
           gc_value_holder_struct->start = curr->next;
         }
         NM_GC_LL_NODE* temp_next = curr->next;
+        if (curr->val) {
+          NM_FREE(curr->val);
+        }
         curr->next = allocated_pool->start;
+        curr->key = NULL;
         curr->val = NULL;
         curr->n = 0;
         allocated_pool->start = curr;
@@ -1144,7 +1179,7 @@ static VALUE nm_init_new_version(int argc, VALUE* argv, VALUE self) {
   // Get the shape.
   size_t  dim;
   size_t* shape = interpret_shape(shape_ary, &dim);
-  void*   init;
+  void*   init = NULL;
   void*   v = NULL;
   size_t  v_size = 0;
 

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));
@@ -779,7 +782,7 @@ void nm_list_storage_unregister(const STORAGE* s) {
  */
 static NODE* list_storage_get_single_node(LIST_STORAGE* s, SLICE* slice) {
   LIST* l = s->rows;
-  NODE* n;
+  NODE* n = NULL;
 
   for (size_t r = 0; r < s->dim; r++) {
     n = nm::list::find(l, s->offset[r] + slice->coords[r]);
@@ -1160,11 +1163,12 @@ void* nm_list_storage_get(const STORAGE* storage, SLICE* slice) {
 void* nm_list_storage_ref(const STORAGE* storage, SLICE* slice) {
   LIST_STORAGE* s = (LIST_STORAGE*)storage;
   LIST_STORAGE* ns = NULL;
+  NODE* n = NULL;
   nm_list_storage_register(s);
 
   //TODO: It needs a refactoring.
   if (slice->single) {
-    NODE* n = list_storage_get_single_node(s, slice);
+    n = list_storage_get_single_node(s, slice);
     nm_list_storage_unregister(s);
     return (n ? n->val : s->default_val);
   } else {

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/homogeneous.rb

@@ -69,7 +69,7 @@ class NMatrix
       NMatrix.new(4, [1.0, 0.0, 0.0, 0.0,
                       0.0, c,   -s,  0.0,
                       0.0, s,    c,  0.0,
-                      0.0, 0.0, 0.0, 1.0], {dtype: :float64}.merge(opts))
+                      0.0, 0.0, 0.0, 1.0], **{dtype: :float64}.merge(opts))
     end
 
     def y_rotation angle_in_radians, opts={}
@@ -78,7 +78,7 @@ class NMatrix
       NMatrix.new(4, [ c,  0.0,  s,  0.0,
                       0.0, 1.0, 0.0, 0.0,
                       -s,  0.0,  c,  0.0,
-                      0.0, 0.0, 0.0, 1.0], {dtype: :float64}.merge(opts))
+                      0.0, 0.0, 0.0, 1.0], **{dtype: :float64}.merge(opts))
     end
 
     def z_rotation angle_in_radians, opts={}
@@ -87,7 +87,7 @@ class NMatrix
       NMatrix.new(4, [ c,  -s,  0.0, 0.0,
                        s,   c,  0.0, 0.0,
                       0.0, 0.0, 1.0, 0.0,
-                      0.0, 0.0, 0.0, 1.0], {dtype: :float64}.merge(opts))
+                      0.0, 0.0, 0.0, 1.0], **{dtype: :float64}.merge(opts))
     end
 
 

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
@@ -69,14 +69,17 @@ if CONFIG['CXX'] == 'clang++'
   $CXX_STANDARD = 'c++11'
 else
   version = gplusplus_version
-  if version < '4.3.0' && CONFIG['CXX'] == 'g++'  # see if we can find a newer G++, unless it's been overridden by user
+  major_version = version.split('.')[0].to_i # string comparison fails past 10.0.0
+
+  if major_version < 5 and
+    version < '4.3.0' && CONFIG['CXX'] == 'g++'  # see if we can find a newer G++, unless it's been overridden by user
     if !find_newer_gplusplus
       raise("You need a version of g++ which supports -std=c++0x or -std=c++11. If you're on a Mac and using Homebrew, we recommend using mac-brew-gcc.sh to install a more recent g++.")
     end
     version = gplusplus_version
   end
 
-  if version < '4.7.0'
+  if major_version < 5 and version < '4.7.0'
     $CXX_STANDARD = 'c++0x'
   else
     $CXX_STANDARD = 'c++11'

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.
@@ -1034,7 +1034,7 @@ class NMatrix
   def clone_structure(capacity = nil)
     opts = {stype: self.stype, default: self.default_value, dtype: self.dtype}
     opts = {capacity: capacity}.merge(opts) if self.yale?
-    NMatrix.new(self.shape, opts)
+    NMatrix.new(self.shape, **opts)
   end
 
   #
@@ -1099,7 +1099,7 @@ protected
       # We can generally predict the change in capacity for Yale.
       opts = {capacity: self.capacity - self.shape[0] + new_shape[0]}.merge(opts)
     end
-    NMatrix.new(new_shape, opts)
+    NMatrix.new(new_shape, **opts)
   end