nmatrix 0.0.9 → 0.1.0.rc1

data/ext/nmatrix/storage/{dense.h → dense/dense.h}

@@ -9,8 +9,8 @@
 //
 // == Copyright Information
 //
-// SciRuby is Copyright (c) 2010 - 2013, Ruby Science Foundation
-// NMatrix is Copyright (c) 2013, Ruby Science Foundation
+// SciRuby is Copyright (c) 2010 - 2014, Ruby Science Foundation
+// NMatrix is Copyright (c) 2012 - 2014, John Woods and the Ruby Science Foundation
 //
 // Please see LICENSE.txt for additional copyright notices.
 //
@@ -43,7 +43,7 @@
 
 #include "data/data.h"
 
-#include "common.h"
+#include "../common.h"
 
 #include "nmatrix.h"
 
@@ -73,8 +73,9 @@ DENSE_STORAGE*	nm_dense_storage_create(nm::dtype_t dtype, size_t* shape, size_t
 void						nm_dense_storage_delete(STORAGE* s);
 void						nm_dense_storage_delete_ref(STORAGE* s);
 void						nm_dense_storage_mark(STORAGE*);
-void            nm_dense_storage_register_values(VALUE* values, size_t n);
-void            nm_dense_storage_unregister_values(VALUE* values, size_t n);
+void            nm_dense_storage_register(const STORAGE* s);
+void            nm_dense_storage_unregister(const STORAGE* s);
+
 
 ///////////////
 // Accessors //

data/ext/nmatrix/storage/{list.cpp → list/list.cpp}

@@ -9,8 +9,8 @@
 //
 // == Copyright Information
 //
-// SciRuby is Copyright (c) 2010 - 2013, Ruby Science Foundation
-// NMatrix is Copyright (c) 2013, Ruby Science Foundation
+// SciRuby is Copyright (c) 2010 - 2014, Ruby Science Foundation
+// NMatrix is Copyright (c) 2012 - 2014, John Woods and the Ruby Science Foundation
 //
 // Please see LICENSE.txt for additional copyright notices.
 //
@@ -25,7 +25,6 @@
 //
 // List-of-lists n-dimensional matrix storage. Uses singly-linked
 // lists.
-
 /*
  * Standard Includes
  */
@@ -34,21 +33,22 @@
 #include <algorithm> // std::min
 #include <iostream>
 #include <vector>
+#include <list>
 
 /*
  * Project Includes
  */
 
-#include "types.h"
+#include "../../types.h"
 
-#include "data/data.h"
+#include "../../data/data.h"
 
-#include "dense.h"
-#include "common.h"
+#include "../dense/dense.h"
+#include "../common.h"
 #include "list.h"
 
-#include "math/math.h"
-#include "util/sl_list.h"
+#include "../../math/math.h"
+#include "../../util/sl_list.h"
 
 /*
  * Macros
@@ -61,6 +61,8 @@
 
 extern "C" {
 static void slice_set_single(LIST_STORAGE* dest, LIST* l, void* val, size_t* coords, size_t* lengths, size_t n);
+static void __nm_list_storage_unregister_temp_value_list(std::list<VALUE*>& temp_vals);
+static void __nm_list_storage_unregister_temp_list_list(std::list<LIST*>& temp_vals, size_t recursions);
 }
 
 namespace nm { namespace list_storage {
@@ -78,11 +80,20 @@ public:
         offsets[i] += actual->offset[i];
       actual = reinterpret_cast<LIST_STORAGE*>(actual->src);
     }
+    nm_list_storage_register(actual);
+    nm_list_storage_register(ref);
     actual_shape_ = actual->shape;
 
     if (init_obj_ == Qnil) {
       init_obj_ = s->dtype == nm::RUBYOBJ ? *reinterpret_cast<VALUE*>(s->default_val) : rubyobj_from_cval(s->default_val, s->dtype).rval;
     }
+    nm_register_value(init_obj_);
+  }
+
+  ~RecurseData() {
+    nm_unregister_value(init_obj_);
+    nm_list_storage_unregister(ref);
+    nm_list_storage_unregister(actual);
   }
 
   dtype_t dtype() const { return ref->dtype; }
@@ -95,13 +106,13 @@ public:
   }
 
   size_t* copy_alloc_shape() const {
-    size_t* new_shape = ALLOC_N(size_t, ref->dim);
+    size_t* new_shape = NM_ALLOC_N(size_t, ref->dim);
     memcpy(new_shape, shape_, sizeof(size_t)*ref->dim);
     return new_shape;
   }
 
   size_t actual_shape(size_t rec) const {
-    return actual_shape_[ref->dim - rec - 1];
+    return actual_shape_[actual->dim - rec - 1];
   }
 
   size_t offset(size_t rec) const {
@@ -140,53 +151,157 @@ static bool eqeq_r(RecurseData& left, RecurseData& right, const LIST* l, const L
 template <typename SDType, typename TDType>
 static bool eqeq_empty_r(RecurseData& s, const LIST* l, size_t rec, const TDType* t_init);
 
-
 /*
  * Recursive helper for map_merged_stored_r which handles the case where one list is empty and the other is not.
  */
 static void map_empty_stored_r(RecurseData& result, RecurseData& s, LIST* x, const LIST* l, size_t rec, bool rev, const VALUE& t_init) {
+  if (s.dtype() == nm::RUBYOBJ) {
+    nm_list_storage_register_list(l, rec);
+  }
+  if (result.dtype() == nm::RUBYOBJ) {
+    nm_list_storage_register_list(x, rec);
+  }
+
   NODE *curr  = l->first,
        *xcurr = NULL;
 
   // For reference matrices, make sure we start in the correct place.
-  size_t offset   = result.offset(rec);
-  size_t x_shape  = result.ref_shape(rec);
+  size_t offset   = s.offset(rec);
+  size_t x_shape  = s.ref_shape(rec);
 
   while (curr && curr->key < offset) {  curr = curr->next;  }
   if (curr && curr->key - offset >= x_shape) curr = NULL;
 
   if (rec) {
+    std::list<LIST*> temp_vals;
     while (curr) {
       LIST* val = nm::list::create();
       map_empty_stored_r(result, s, val, reinterpret_cast<const LIST*>(curr->val), rec-1, rev, t_init);
 
       if (!val->first) nm::list::del(val, 0);
-      else nm::list::insert_helper(x, xcurr, curr->key - offset, val);
-
+      else {
+        nm_list_storage_register_list(val, rec-1);
+	temp_vals.push_front(val);
+        nm::list::insert_helper(x, xcurr, curr->key - offset, val);
+      } 
       curr = curr->next;
       if (curr && curr->key - offset >= x_shape) curr = NULL;
     }
+    __nm_list_storage_unregister_temp_list_list(temp_vals, rec-1);
   } else {
+    std::list<VALUE*> temp_vals;
     while (curr) {
       VALUE val, s_val = rubyobj_from_cval(curr->val, s.dtype()).rval;
       if (rev) val = rb_yield_values(2, t_init, s_val);
       else     val = rb_yield_values(2, s_val, t_init);
 
-      if (rb_funcall(val, rb_intern("!="), 1, result.init_obj()) == Qtrue)
+      nm_register_value(val);
+
+      if (rb_funcall(val, rb_intern("!="), 1, result.init_obj()) == Qtrue) {
         xcurr = nm::list::insert_helper(x, xcurr, curr->key - offset, val);
+        temp_vals.push_front(reinterpret_cast<VALUE*>(xcurr->val));
+        nm_register_value(*reinterpret_cast<VALUE*>(xcurr->val));
+      }
+      nm_unregister_value(val);
 
       curr = curr->next;
       if (curr && curr->key - offset >= x_shape) curr = NULL;
     }
+    __nm_list_storage_unregister_temp_value_list(temp_vals);
+  }
+
+  if (s.dtype() == nm::RUBYOBJ){
+    nm_list_storage_unregister_list(l, rec);
+  }
+  if (result.dtype() == nm::RUBYOBJ) {
+    nm_list_storage_unregister_list(x, rec);
   }
 
 }
 
 
+/*
+ * Recursive helper function for nm_list_map_stored
+ */
+static void map_stored_r(RecurseData& result, RecurseData& left, LIST* x, const LIST* l, size_t rec) {
+  if (left.dtype() == nm::RUBYOBJ) {
+    nm_list_storage_register_list(l, rec);
+  }
+  if (result.dtype() == nm::RUBYOBJ) {
+    nm_list_storage_register_list(x, rec);
+  }
+  NODE *lcurr = l->first,
+       *xcurr = x->first;
+
+  // For reference matrices, make sure we start in the correct place.
+  while (lcurr && lcurr->key < left.offset(rec))  {  lcurr = lcurr->next;  }
+
+  if (lcurr && lcurr->key - left.offset(rec) >= result.ref_shape(rec))  lcurr = NULL;
+
+  if (rec) {
+    std::list<LIST*> temp_vals;
+    while (lcurr) {
+      size_t key;
+      LIST*  val = nm::list::create();
+      map_stored_r(result, left, val, reinterpret_cast<const LIST*>(lcurr->val), rec-1);
+      key        = lcurr->key - left.offset(rec);
+      lcurr      = lcurr->next;
+
+      if (!val->first) nm::list::del(val, 0); // empty list -- don't insert
+      else {
+        nm_list_storage_register_list(val, rec-1);
+        temp_vals.push_front(val);
+        xcurr = nm::list::insert_helper(x, xcurr, key, val);
+      }
+      if (lcurr && lcurr->key - left.offset(rec) >= result.ref_shape(rec)) lcurr = NULL;
+    }
+    __nm_list_storage_unregister_temp_list_list(temp_vals, rec-1);
+  } else {
+    std::list<VALUE*> temp_vals;
+    while (lcurr) {
+      size_t key;
+      VALUE  val;
+
+      val   = rb_yield_values(1, rubyobj_from_cval(lcurr->val, left.dtype()).rval);
+      key   = lcurr->key - left.offset(rec);
+      lcurr = lcurr->next;
+
+      if (!rb_equal(val, result.init_obj())) {
+        xcurr = nm::list::insert_helper(x, xcurr, key, val);
+        temp_vals.push_front(reinterpret_cast<VALUE*>(xcurr->val));
+        nm_register_value(*reinterpret_cast<VALUE*>(xcurr->val));
+      }
+
+      if (lcurr && lcurr->key - left.offset(rec) >= result.ref_shape(rec)) lcurr = NULL;
+    }
+    __nm_list_storage_unregister_temp_value_list(temp_vals);
+  }
+
+  if (left.dtype() == nm::RUBYOBJ) {
+    nm_list_storage_unregister_list(l, rec);
+  }
+  if (result.dtype() == nm::RUBYOBJ) {
+    nm_list_storage_unregister_list(x, rec);
+  }
+}
+
+
+
 /*
  * Recursive helper function for nm_list_map_merged_stored
  */
 static void map_merged_stored_r(RecurseData& result, RecurseData& left, RecurseData& right, LIST* x, const LIST* l, const LIST* r, size_t rec) {
+  if (left.dtype() == nm::RUBYOBJ) {
+    nm_list_storage_register_list(l, rec);
+  }
+  if (right.dtype() == nm::RUBYOBJ) {
+    nm_list_storage_register_list(r, rec);
+  }
+  if (result.dtype() == nm::RUBYOBJ) {
+    nm_list_storage_register_list(x, rec);
+  }
+
+
   NODE *lcurr = l->first,
        *rcurr = r->first,
        *xcurr = x->first;
@@ -199,6 +314,7 @@ static void map_merged_stored_r(RecurseData& result, RecurseData& left, RecurseD
   if (lcurr && lcurr->key - left.offset(rec) >= result.ref_shape(rec))  lcurr = NULL;
 
   if (rec) {
+    std::list<LIST*> temp_vals;
     while (lcurr || rcurr) {
       size_t key;
       LIST*  val = nm::list::create();
@@ -218,13 +334,19 @@ static void map_merged_stored_r(RecurseData& result, RecurseData& left, RecurseD
         rcurr = rcurr->next;
       }
 
-      if (!val->first) nm::list::del(val, 0); // empty list -- don't insert
-      else xcurr = nm::list::insert_helper(x, xcurr, key, val);
 
+      if (!val->first) nm::list::del(val, 0); // empty list -- don't insert
+      else {
+        nm_list_storage_register_list(val, rec-1);
+        temp_vals.push_front(val);
+        xcurr = nm::list::insert_helper(x, xcurr, key, val);
+      }
       if (rcurr && rcurr->key - right.offset(rec) >= result.ref_shape(rec)) rcurr = NULL;
       if (lcurr && lcurr->key - left.offset(rec) >= result.ref_shape(rec)) lcurr = NULL;
     }
+    __nm_list_storage_unregister_temp_list_list(temp_vals, rec-1);
   } else {
+    std::list<VALUE*> temp_vals;
     while (lcurr || rcurr) {
       size_t key;
       VALUE  val;
@@ -234,7 +356,7 @@ static void map_merged_stored_r(RecurseData& result, RecurseData& left, RecurseD
         key   = lcurr->key - left.offset(rec);
         lcurr = lcurr->next;
       } else if (!lcurr || (rcurr && (rcurr->key - right.offset(rec) < lcurr->key - left.offset(rec)))) {
-        val   = rb_yield_values(2, left.init_obj(), rubyobj_from_cval(rcurr->val, right.dtype()).rval);
+	      val   = rb_yield_values(2, left.init_obj(), rubyobj_from_cval(rcurr->val, right.dtype()).rval);
         key   = rcurr->key - right.offset(rec);
         rcurr = rcurr->next;
       } else { // == and both present
@@ -243,15 +365,35 @@ static void map_merged_stored_r(RecurseData& result, RecurseData& left, RecurseD
         lcurr = lcurr->next;
         rcurr = rcurr->next;
       }
-      if (rb_funcall(val, rb_intern("!="), 1, result.init_obj()) == Qtrue)
+
+      nm_register_value(val);
+
+      if (rb_funcall(val, rb_intern("!="), 1, result.init_obj()) == Qtrue) {
         xcurr = nm::list::insert_helper(x, xcurr, key, val);
+        temp_vals.push_front(reinterpret_cast<VALUE*>(xcurr->val));
+        nm_register_value(*reinterpret_cast<VALUE*>(xcurr->val));
+      }
+
+      nm_unregister_value(val);
 
       if (rcurr && rcurr->key - right.offset(rec) >= result.ref_shape(rec)) rcurr = NULL;
       if (lcurr && lcurr->key - left.offset(rec) >= result.ref_shape(rec)) lcurr = NULL;
     }
+    __nm_list_storage_unregister_temp_value_list(temp_vals);
+  }
+
+  if (left.dtype() == nm::RUBYOBJ) {
+    nm_list_storage_unregister_list(l, rec);
+  }
+  if (right.dtype() == nm::RUBYOBJ) {
+    nm_list_storage_unregister_list(r, rec);
+  }
+  if (result.dtype() == nm::RUBYOBJ) {
+    nm_list_storage_unregister_list(x, rec);
   }
 }
 
+
 /*
  * Recursive function, sets multiple values in a matrix from multiple source values. Also handles removal; returns true
  * if the recursion results in an empty list at that level (which signals that the current parent should be removed).
@@ -266,6 +408,12 @@ static bool slice_set(LIST_STORAGE* dest, LIST* l, size_t* coords, size_t* lengt
   using nm::list::insert_after;
   size_t* offsets = dest->offset;
 
+  nm_list_storage_register(dest);
+  if (dest->dtype == nm::RUBYOBJ) {
+    nm_register_values(reinterpret_cast<VALUE*>(v), v_size);
+    nm_list_storage_register_list(l, dest->dim - n - 1);
+  }
+
   // drill down into the structure
   NODE* prev = find_preceding_from_list(l, coords[n] + offsets[n]);
   NODE* node = NULL;
@@ -286,13 +434,16 @@ static bool slice_set(LIST_STORAGE* dest, LIST* l, size_t* coords, size_t* lengt
     }
 
     // At this point, it's guaranteed that there is a list here matching key.
-
+    std::list<LIST*> temp_lists;
     while (node) {
       // Recurse down into the list. If it returns true, it's empty, so we need to delete it.
       bool remove_parent = slice_set(dest, reinterpret_cast<LIST*>(node->val), coords, lengths, n+1, v, v_size, v_offset);
-
+      if (dest->dtype == nm::RUBYOBJ) {
+        temp_lists.push_front(reinterpret_cast<LIST*>(node->val));
+        nm_list_storage_register_list(reinterpret_cast<LIST*>(node->val), dest->dim - n - 2);
+      }
       if (remove_parent) {
-        xfree(remove_by_node(l, prev, node));
+        NM_FREE(remove_by_node(l, prev, node));
         if (prev) node = prev->next ? prev->next : NULL;
         else      node = l->first   ? l->first   : NULL;
       } else {  // move forward
@@ -313,12 +464,13 @@ static bool slice_set(LIST_STORAGE* dest, LIST* l, size_t* coords, size_t* lengt
         }
       }
     }
+    __nm_list_storage_unregister_temp_list_list(temp_lists, dest->dim - n - 2);
 
   } else {
 
     size_t i    = 0;
     size_t key  = i + offsets[n] + coords[n];
-
+    std::list<VALUE*> temp_vals;
     while (i < lengths[n]) {
       // Make sure we have an element to work with
       if (v_offset >= v_size) v_offset %= v_size;
@@ -327,7 +479,7 @@ static bool slice_set(LIST_STORAGE* dest, LIST* l, size_t* coords, size_t* lengt
         if (node->key == key) {
           if (v[v_offset] == *reinterpret_cast<D*>(dest->default_val)) { // remove zero value
 
-            xfree(remove_by_node(l, (prev ? prev : l->first), node));
+            NM_FREE(remove_by_node(l, (prev ? prev : l->first), node));
 
             if (prev) node = prev->next ? prev->next : NULL;
             else      node = l->first   ? l->first   : NULL;
@@ -338,7 +490,12 @@ static bool slice_set(LIST_STORAGE* dest, LIST* l, size_t* coords, size_t* lengt
             node = node->next ? node->next : NULL;
           }
         } else if (node->key > key) {
-          D* nv = ALLOC(D); *nv = v[v_offset];
+          D* nv = NM_ALLOC(D); *nv = v[v_offset++];
+          if (dest->dtype == nm::RUBYOBJ) {
+            nm_register_value(*reinterpret_cast<VALUE*>(nv));
+            temp_vals.push_front(reinterpret_cast<VALUE*>(nv));
+          }
+
           if (prev) node = insert_after(prev, key, nv);
           else      node = insert_first_node(l, key, nv, sizeof(D));
 
@@ -346,7 +503,11 @@ static bool slice_set(LIST_STORAGE* dest, LIST* l, size_t* coords, size_t* lengt
           node = prev->next ? prev->next : NULL;
         }
       } else { // no node -- insert a new one
-        D* nv = ALLOC(D); *nv = v[v_offset];
+        D* nv = NM_ALLOC(D); *nv = v[v_offset++];
+        if (dest->dtype == nm::RUBYOBJ) {
+          nm_register_value(*reinterpret_cast<VALUE*>(nv));
+          temp_vals.push_front(reinterpret_cast<VALUE*>(nv));
+        }
         if (prev) node = insert_after(prev, key, nv);
         else      node = insert_first_node(l, key, nv, sizeof(D));
 
@@ -356,7 +517,14 @@ static bool slice_set(LIST_STORAGE* dest, LIST* l, size_t* coords, size_t* lengt
 
       ++i; ++key;
     }
+    __nm_list_storage_unregister_temp_value_list(temp_vals);
+  }
+
+  if (dest->dtype == nm::RUBYOBJ) {
+    nm_unregister_values(reinterpret_cast<VALUE*>(v), v_size);
+    nm_list_storage_unregister_list(l, dest->dim - n - 1);
   }
+  nm_list_storage_unregister(dest);
 
   return (l->first) ? false : true;
 }
@@ -364,8 +532,10 @@ static bool slice_set(LIST_STORAGE* dest, LIST* l, size_t* coords, size_t* lengt
 
 template <typename D>
 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);
-
+  
   std::pair<NMATRIX*,bool> nm_and_free =
     interpret_arg_as_dense_nmatrix(right, NM_DTYPE(left));
 
@@ -379,17 +549,27 @@ void set(VALUE left, SLICE* slice, VALUE right) {
     v_size           = nm_storage_count_max_elements(t);
 
   } else if (TYPE(right) == T_ARRAY) {
+    nm_register_nmatrix(nm_and_free.first);
     v_size = RARRAY_LEN(right);
-    v      = ALLOC_N(D, v_size);
+    v      = NM_ALLOC_N(D, v_size);
+    if (NM_DTYPE(left) == nm::RUBYOBJ)
+        nm_register_values(reinterpret_cast<VALUE*>(v), v_size);
+
     for (size_t m = 0; m < v_size; ++m) {
       rubyval_to_cval(rb_ary_entry(right, m), s->dtype, &(v[m]));
     }
+    if (NM_DTYPE(left) == nm::RUBYOBJ)
+        nm_unregister_values(reinterpret_cast<VALUE*>(v), v_size);
+
   } else {
+    nm_register_nmatrix(nm_and_free.first);
     v = reinterpret_cast<D*>(rubyobj_to_cval(right, NM_DTYPE(left)));
   }
 
   if (v_size == 1 && *v == *reinterpret_cast<D*>(s->default_val)) {
-    nm::list::remove_recursive(s->rows, slice->coords, s->offset, slice->lengths, 0, s->dim);
+    if (*reinterpret_cast<D*>(nm_list_storage_get(s, slice)) != *reinterpret_cast<D*>(s->default_val)) {
+      nm::list::remove_recursive(s->rows, slice->coords, s->offset, slice->lengths, 0, s->dim);
+    }
   } else if (slice->single) {
     slice_set_single(s, s->rows, reinterpret_cast<void*>(v), slice->coords, slice->lengths, 0);
   } else {
@@ -403,7 +583,12 @@ void set(VALUE left, SLICE* slice, VALUE right) {
     if (nm_and_free.second) {
       nm_delete(nm_and_free.first);
     }
-  } else xfree(v);
+  } else {
+    NM_FREE(v);
+    nm_unregister_nmatrix(nm_and_free.first);
+  }
+  NM_CONSERVATIVE(nm_unregister_value(left));
+  NM_CONSERVATIVE(nm_unregister_value(right));
 }
 
 /*
@@ -411,7 +596,7 @@ void set(VALUE left, SLICE* slice, VALUE right) {
  */
 template <typename D>
 void init_default(LIST_STORAGE* s) {
-  s->default_val = ALLOC(D);
+  s->default_val = NM_ALLOC(D);
   *reinterpret_cast<D*>(s->default_val) = 0;
 }
 
@@ -438,13 +623,13 @@ extern "C" {
  * new storage. You don't need to free them, and you shouldn't re-use them.
  */
 LIST_STORAGE* nm_list_storage_create(nm::dtype_t dtype, size_t* shape, size_t dim, void* init_val) {
-  LIST_STORAGE* s = ALLOC( LIST_STORAGE );
+  LIST_STORAGE* s = NM_ALLOC( LIST_STORAGE );
 
   s->dim   = dim;
   s->shape = shape;
   s->dtype = dtype;
 
-  s->offset = ALLOC_N(size_t, s->dim);
+  s->offset = NM_ALLOC_N(size_t, s->dim);
   memset(s->offset, 0, s->dim * sizeof(size_t));
 
   s->rows  = nm::list::create();
@@ -461,7 +646,7 @@ LIST_STORAGE* nm_list_storage_create(nm::dtype_t dtype, size_t* shape, size_t di
 }
 
 /*
- * Documentation goes here.
+ * Destructor for list storage.
  */
 void nm_list_storage_delete(STORAGE* s) {
   if (s) {
@@ -469,30 +654,30 @@ void nm_list_storage_delete(STORAGE* s) {
     if (storage->count-- == 1) {
       nm::list::del( storage->rows, storage->dim - 1 );
 
-      xfree(storage->shape);
-      xfree(storage->offset);
-      xfree(storage->default_val);
-      xfree(s);
+      NM_FREE(storage->shape);
+      NM_FREE(storage->offset);
+      NM_FREE(storage->default_val);
+      NM_FREE(s);
     }
   }
 }
 
 /*
- * Documentation goes here.
+ * Destructor for a list storage reference slice.
  */
 void nm_list_storage_delete_ref(STORAGE* s) {
   if (s) {
     LIST_STORAGE* storage = (LIST_STORAGE*)s;
 
     nm_list_storage_delete( reinterpret_cast<STORAGE*>(storage->src ) );
-    xfree(storage->shape);
-    xfree(storage->offset);
-    xfree(s);
+    NM_FREE(storage->shape);
+    NM_FREE(storage->offset);
+    NM_FREE(s);
   }
 }
 
 /*
- * Documentation goes here.
+ * GC mark function for list storage.
  */
 void nm_list_storage_mark(STORAGE* storage_base) {
   LIST_STORAGE* storage = (LIST_STORAGE*)storage_base;
@@ -503,6 +688,85 @@ void nm_list_storage_mark(STORAGE* storage_base) {
   }
 }
 
+static void __nm_list_storage_unregister_temp_value_list(std::list<VALUE*>& temp_vals) {
+  for (std::list<VALUE*>::iterator it = temp_vals.begin(); it != temp_vals.end(); ++it) {
+    nm_unregister_value(**it);
+  }
+}
+
+static void __nm_list_storage_unregister_temp_list_list(std::list<LIST*>& temp_vals, size_t recursions) {
+  for (std::list<LIST*>::iterator it = temp_vals.begin(); it != temp_vals.end(); ++it) {
+    nm_list_storage_unregister_list(*it, recursions);
+  }
+}
+
+void nm_list_storage_register_node(const NODE* curr) {
+  nm_register_value(*reinterpret_cast<VALUE*>(curr->val));      
+}
+
+void nm_list_storage_unregister_node(const NODE* curr) {
+  nm_unregister_value(*reinterpret_cast<VALUE*>(curr->val));      
+}
+
+/**
+ * Gets rid of all instances of a given node in the registration list.
+ * Sometimes a node will get deleted and replaced deep in a recursion, but
+ * further up it will still get registered.  This leads to a potential read
+ * after free during the GC marking.  This function completely clears out a
+ * node so that this won't happen.
+ */
+void nm_list_storage_completely_unregister_node(const NODE* curr) {
+  nm_completely_unregister_value(*reinterpret_cast<VALUE*>(curr->val));
+}
+
+void nm_list_storage_register_list(const LIST* list, size_t recursions) {
+  NODE* next;
+  if (!list) return;
+  NODE* curr = list->first;
+
+  while (curr != NULL) {
+    next = curr->next;
+    if (recursions == 0) {
+      nm_list_storage_register_node(curr);
+    } else {
+      nm_list_storage_register_list(reinterpret_cast<LIST*>(curr->val), recursions - 1);
+    }
+    curr = next;
+  }
+}
+
+void nm_list_storage_unregister_list(const LIST* list, size_t recursions) {
+  NODE* next;
+  if (!list) return;
+  NODE* curr = list->first;
+
+  while (curr != NULL) {
+    next = curr->next;
+    if (recursions == 0) {
+      nm_list_storage_unregister_node(curr);
+    } else {
+      nm_list_storage_unregister_list(reinterpret_cast<LIST*>(curr->val), recursions - 1);
+    }
+    curr = next;
+  }
+}
+
+void nm_list_storage_register(const STORAGE* s) {
+  const LIST_STORAGE* storage = reinterpret_cast<const LIST_STORAGE*>(s);
+  if (storage && storage->dtype == nm::RUBYOBJ) {
+    nm_register_value(*reinterpret_cast<VALUE*>(storage->default_val));
+    nm_list_storage_register_list(storage->rows, storage->dim - 1);
+  }
+}
+
+void nm_list_storage_unregister(const STORAGE* s) {
+  const LIST_STORAGE* storage = reinterpret_cast<const LIST_STORAGE*>(s);
+  if (storage && storage->dtype == nm::RUBYOBJ) {
+    nm_unregister_value(*reinterpret_cast<VALUE*>(storage->default_val));
+    nm_list_storage_unregister_list(storage->rows, storage->dim - 1);
+  }
+}
+
 ///////////////
 // Accessors //
 ///////////////
@@ -510,8 +774,7 @@ void nm_list_storage_mark(STORAGE* storage_base) {
 /*
  * Documentation goes here.
  */
-static NODE* list_storage_get_single_node(LIST_STORAGE* s, SLICE* slice)
-{
+static NODE* list_storage_get_single_node(LIST_STORAGE* s, SLICE* slice) {
   size_t r;
   LIST*  l = s->rows;
   NODE*  n;
@@ -532,6 +795,7 @@ static NODE* list_storage_get_single_node(LIST_STORAGE* s, SLICE* slice)
  */
 static void each_empty_with_indices_r(nm::list_storage::RecurseData& s, size_t rec, VALUE& stack) {
   VALUE empty  = s.dtype() == nm::RUBYOBJ ? *reinterpret_cast<VALUE*>(s.init()) : s.init_obj();
+  NM_CONSERVATIVE(nm_register_value(stack));
 
   if (rec) {
     for (long index = 0; index < s.ref_shape(rec); ++index) {
@@ -549,12 +813,16 @@ static void each_empty_with_indices_r(nm::list_storage::RecurseData& s, size_t r
     }
     rb_ary_shift(stack);
   }
+  NM_CONSERVATIVE(nm_unregister_value(stack));
 }
 
 /*
  * Recursive helper function for each_with_indices, based on nm_list_storage_count_elements_r.
  */
 static void each_with_indices_r(nm::list_storage::RecurseData& s, const LIST* l, size_t rec, VALUE& stack) {
+  if (s.dtype() == nm::RUBYOBJ)
+    nm_list_storage_register_list(l, rec);
+  NM_CONSERVATIVE(nm_register_value(stack));
   NODE*  curr  = l->first;
 
   size_t offset = s.offset(rec);
@@ -594,7 +862,9 @@ static void each_with_indices_r(nm::list_storage::RecurseData& s, const LIST* l,
       rb_ary_pop(stack);
     }
   }
-
+  NM_CONSERVATIVE(nm_unregister_value(stack));
+  if (s.dtype() == nm::RUBYOBJ)
+    nm_list_storage_unregister_list(l, rec);
 }
 
 
@@ -602,6 +872,10 @@ static void each_with_indices_r(nm::list_storage::RecurseData& s, const LIST* l,
  * Recursive helper function for each_stored_with_indices, based on nm_list_storage_count_elements_r.
  */
 static void each_stored_with_indices_r(nm::list_storage::RecurseData& s, const LIST* l, size_t rec, VALUE& stack) {
+  if (s.dtype() == nm::RUBYOBJ)
+    nm_list_storage_register_list(l, rec);
+  NM_CONSERVATIVE(nm_register_value(stack));
+  
   NODE* curr = l->first;
 
   size_t offset = s.offset(rec);
@@ -639,6 +913,9 @@ static void each_stored_with_indices_r(nm::list_storage::RecurseData& s, const L
       if (curr && curr->key - offset >= shape) curr = NULL;
     }
   }
+  NM_CONSERVATIVE(nm_unregister_value(stack));
+  if (s.dtype() == nm::RUBYOBJ)
+    nm_list_storage_unregister_list(l, rec);
 }
 
 
@@ -648,7 +925,11 @@ static void each_stored_with_indices_r(nm::list_storage::RecurseData& s, const L
  */
 VALUE nm_list_each_with_indices(VALUE nmatrix, bool stored) {
 
+  NM_CONSERVATIVE(nm_register_value(nmatrix));
+
   // If we don't have a block, return an enumerator.
+  RETURN_SIZED_ENUMERATOR_PRE
+  NM_CONSERVATIVE(nm_unregister_value(nmatrix));
   RETURN_SIZED_ENUMERATOR(nmatrix, 0, 0, 0);
 
   nm::list_storage::RecurseData sdata(NM_STORAGE_LIST(nmatrix));
@@ -658,14 +939,71 @@ VALUE nm_list_each_with_indices(VALUE nmatrix, bool stored) {
   if (stored) each_stored_with_indices_r(sdata, sdata.top_level_list(), sdata.dim() - 1, stack);
   else        each_with_indices_r(sdata, sdata.top_level_list(), sdata.dim() - 1, stack);
 
+  NM_CONSERVATIVE(nm_unregister_value(nmatrix));
   return nmatrix;
 }
 
 
+/*
+ * map merged stored iterator. Always returns a matrix containing RubyObjects which probably needs to be casted.
+ */
+VALUE nm_list_map_stored(VALUE left, VALUE init) {
+  NM_CONSERVATIVE(nm_register_value(left));
+  NM_CONSERVATIVE(nm_register_value(init));
+
+  bool scalar = false;
+
+  LIST_STORAGE *s   = NM_STORAGE_LIST(left);
+
+  // For each matrix, if it's a reference, we want to deal directly with the original (with appropriate offsetting)
+  nm::list_storage::RecurseData sdata(s);
+
+  void* scalar_init = NULL;
+
+  //if (!rb_block_given_p()) {
+  //  rb_raise(rb_eNotImpError, "RETURN_SIZED_ENUMERATOR probably won't work for a map_merged since no merged object is created");
+  //}
+  // If we don't have a block, return an enumerator.
+  RETURN_SIZED_ENUMERATOR_PRE
+  NM_CONSERVATIVE(nm_unregister_value(left));
+  NM_CONSERVATIVE(nm_unregister_value(init));
+  RETURN_SIZED_ENUMERATOR(left, 0, 0, 0); // FIXME: Test this. Probably won't work. Enable above code instead.
+
+  // Figure out default value if none provided by the user
+  if (init == Qnil) {
+    nm_unregister_value(init);
+    init = rb_yield_values(1, sdata.init_obj());
+    nm_register_value(init);
+  }
+	// Allocate a new shape array for the resulting matrix.
+  void* init_val = NM_ALLOC(VALUE);
+  memcpy(init_val, &init, sizeof(VALUE));
+  nm_register_value(*reinterpret_cast<VALUE*>(init_val));
+
+  NMATRIX* result = nm_create(nm::LIST_STORE, nm_list_storage_create(nm::RUBYOBJ, sdata.copy_alloc_shape(), s->dim, init_val));
+  LIST_STORAGE* r = reinterpret_cast<LIST_STORAGE*>(result->storage);
+  nm::list_storage::RecurseData rdata(r, init);
+  nm_register_nmatrix(result);
+  map_stored_r(rdata, sdata, rdata.top_level_list(), sdata.top_level_list(), sdata.dim() - 1);
+
+  VALUE to_return = Data_Wrap_Struct(CLASS_OF(left), nm_mark, nm_delete, result);
+
+  nm_unregister_nmatrix(result);
+  nm_unregister_value(*reinterpret_cast<VALUE*>(init_val));
+  NM_CONSERVATIVE(nm_unregister_value(init));
+  NM_CONSERVATIVE(nm_unregister_value(left));
+
+  return to_return;
+}
+
+
 /*
  * map merged stored iterator. Always returns a matrix containing RubyObjects which probably needs to be casted.
  */
 VALUE nm_list_map_merged_stored(VALUE left, VALUE right, VALUE init) {
+  NM_CONSERVATIVE(nm_register_value(left));
+  NM_CONSERVATIVE(nm_register_value(right));
+  NM_CONSERVATIVE(nm_register_value(init));
 
   bool scalar = false;
 
@@ -679,8 +1017,7 @@ VALUE nm_list_map_merged_stored(VALUE left, VALUE right, VALUE init) {
 
   // right might be a scalar, in which case this is a scalar operation.
   if (TYPE(right) != T_DATA || (RDATA(right)->dfree != (RUBY_DATA_FUNC)nm_delete && RDATA(right)->dfree != (RUBY_DATA_FUNC)nm_delete_ref)) {
-    nm::dtype_t r_dtype = nm_dtype_min(right);
-
+    nm::dtype_t r_dtype = Upcast[NM_DTYPE(left)][nm_dtype_min(right)];
     scalar_init         = rubyobj_to_cval(right, r_dtype); // make a copy of right
 
     t                   = reinterpret_cast<LIST_STORAGE*>(nm_list_storage_create(r_dtype, sdata.copy_alloc_shape(), s->dim, scalar_init));
@@ -693,26 +1030,43 @@ VALUE nm_list_map_merged_stored(VALUE left, VALUE right, VALUE init) {
   //  rb_raise(rb_eNotImpError, "RETURN_SIZED_ENUMERATOR probably won't work for a map_merged since no merged object is created");
   //}
   // If we don't have a block, return an enumerator.
+  RETURN_SIZED_ENUMERATOR_PRE
+  NM_CONSERVATIVE(nm_unregister_value(left));
+  NM_CONSERVATIVE(nm_unregister_value(right));
+  NM_CONSERVATIVE(nm_unregister_value(init));
   RETURN_SIZED_ENUMERATOR(left, 0, 0, 0); // FIXME: Test this. Probably won't work. Enable above code instead.
 
   // Figure out default value if none provided by the user
-  nm::list_storage::RecurseData tdata(t);
-  if (init == Qnil) init = rb_yield_values(2, sdata.init_obj(), tdata.init_obj());
+  nm::list_storage::RecurseData& tdata = *(new nm::list_storage::RecurseData(t)); //FIXME: this is a hack to make sure that we can run the destructor before nm_list_storage_delete(t) below.
+  if (init == Qnil) {
+    nm_unregister_value(init);
+    init = rb_yield_values(2, sdata.init_obj(), tdata.init_obj());
+    nm_register_value(init);
+  }
 
-	// Allocate a new shape array for the resulting matrix.
-  void* init_val = ALLOC(VALUE);
+  // Allocate a new shape array for the resulting matrix.
+  void* init_val = NM_ALLOC(VALUE);
   memcpy(init_val, &init, sizeof(VALUE));
+  nm_register_value(*reinterpret_cast<VALUE*>(init_val));
 
   NMATRIX* result = nm_create(nm::LIST_STORE, nm_list_storage_create(nm::RUBYOBJ, sdata.copy_alloc_shape(), s->dim, init_val));
   LIST_STORAGE* r = reinterpret_cast<LIST_STORAGE*>(result->storage);
   nm::list_storage::RecurseData rdata(r, init);
-
   map_merged_stored_r(rdata, sdata, tdata, rdata.top_level_list(), sdata.top_level_list(), tdata.top_level_list(), sdata.dim() - 1);
 
+  delete &tdata;
   // If we are working with a scalar operation
   if (scalar) nm_list_storage_delete(t);
 
-  return Data_Wrap_Struct(CLASS_OF(left), nm_mark, nm_delete, result);
+  VALUE to_return = Data_Wrap_Struct(CLASS_OF(left), nm_mark, nm_delete, result);
+
+  nm_unregister_value(*reinterpret_cast<VALUE*>(init_val));
+
+  NM_CONSERVATIVE(nm_unregister_value(init));
+  NM_CONSERVATIVE(nm_unregister_value(right));
+  NM_CONSERVATIVE(nm_unregister_value(left));
+
+  return to_return;
 }
 
 
@@ -720,13 +1074,14 @@ VALUE nm_list_map_merged_stored(VALUE left, VALUE right, VALUE init) {
  * Copy a slice of a list matrix into a regular list matrix.
  */
 static LIST* slice_copy(const LIST_STORAGE* src, LIST* src_rows, size_t* coords, size_t* lengths, size_t n) {
-
+  nm_list_storage_register(src);
   void *val = NULL;
   int key;
   
   LIST* dst_rows = nm::list::create();
   NODE* src_node = src_rows->first;
-
+  std::list<VALUE*> temp_vals;
+  std::list<LIST*> temp_lists;
   while (src_node) {
     key = src_node->key - (src->offset[n] + coords[n]);
     
@@ -737,16 +1092,28 @@ static LIST* slice_copy(const LIST_STORAGE* src, LIST* src_rows, size_t* coords,
                           coords,
                           lengths,
                           n + 1    );
-
-        if (val) {  nm::list::insert_copy(dst_rows, false, key, val, sizeof(LIST)); }
+        if (val) {
+          if (src->dtype == nm::RUBYOBJ) {
+            nm_list_storage_register_list(reinterpret_cast<LIST*>(val), src->dim - n - 2);
+            temp_lists.push_front(reinterpret_cast<LIST*>(val));
+          }
+          nm::list::insert_copy(dst_rows, false, key, val, sizeof(LIST));
+        }
+      } else { // matches src->dim - n > 1
+        if (src->dtype == nm::RUBYOBJ) {
+          nm_register_value(*reinterpret_cast<VALUE*>(src_node->val));
+          temp_vals.push_front(reinterpret_cast<VALUE*>(src_node->val));
+        }
+        nm::list::insert_copy(dst_rows, false, key, src_node->val, DTYPE_SIZES[src->dtype]);
       }
-
-      else nm::list::insert_copy(dst_rows, false, key, src_node->val, DTYPE_SIZES[src->dtype]);
     }
-
     src_node = src_node->next;
+ }
+  if (src->dtype == nm::RUBYOBJ) {
+    __nm_list_storage_unregister_temp_list_list(temp_lists, src->dim - n - 2);
+    __nm_list_storage_unregister_temp_value_list(temp_vals);
   }
-
+  nm_list_storage_unregister(src);
   return dst_rows;
 }
 
@@ -756,21 +1123,31 @@ static LIST* slice_copy(const LIST_STORAGE* src, LIST* src_rows, size_t* coords,
 void* nm_list_storage_get(const STORAGE* storage, SLICE* slice) {
   LIST_STORAGE* s = (LIST_STORAGE*)storage;
   LIST_STORAGE* ns = NULL;
-  NODE* n;
+
+  nm_list_storage_register(s);
 
   if (slice->single) {
-    n = list_storage_get_single_node(s, slice);
+    NODE* n = list_storage_get_single_node(s, slice);
+    nm_list_storage_unregister(s);
     return (n ? n->val : s->default_val);
+
   } else {
-    void *init_val = ALLOC_N(char, DTYPE_SIZES[s->dtype]);
+    void *init_val = NM_ALLOC_N(char, DTYPE_SIZES[s->dtype]);
     memcpy(init_val, s->default_val, DTYPE_SIZES[s->dtype]);
+    if (s->dtype == nm::RUBYOBJ)
+      nm_register_value(*reinterpret_cast<VALUE*>(init_val));
 
-    size_t *shape = ALLOC_N(size_t, s->dim);
+    size_t *shape = NM_ALLOC_N(size_t, s->dim);
     memcpy(shape, slice->lengths, sizeof(size_t) * s->dim);
 
     ns = nm_list_storage_create(s->dtype, shape, s->dim, init_val);
-
+  
     ns->rows = slice_copy(s, s->rows, slice->coords, slice->lengths, 0);
+
+    if (s->dtype == nm::RUBYOBJ)
+      nm_unregister_value(*reinterpret_cast<VALUE*>(init_val));
+    nm_list_storage_unregister(s);
+
     return ns;
   }
 }
@@ -782,20 +1159,21 @@ 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;
+  nm_list_storage_register(s);
 
   //TODO: It needs a refactoring.
   if (slice->single) {
-    n = list_storage_get_single_node(s, slice); 
+    NODE* n = list_storage_get_single_node(s, slice);
+    nm_list_storage_unregister(s);
     return (n ? n->val : s->default_val);
   } 
   else {
-    ns              = ALLOC( LIST_STORAGE );
+    ns              = NM_ALLOC( LIST_STORAGE );
     
     ns->dim         = s->dim;
     ns->dtype       = s->dtype;
-    ns->offset      = ALLOC_N(size_t, ns->dim);
-    ns->shape       = ALLOC_N(size_t, ns->dim);
+    ns->offset      = NM_ALLOC_N(size_t, ns->dim);
+    ns->shape       = NM_ALLOC_N(size_t, ns->dim);
 
     for (size_t i = 0; i < ns->dim; ++i) {
       ns->offset[i] = slice->coords[i] + s->offset[i];
@@ -807,7 +1185,7 @@ void* nm_list_storage_ref(const STORAGE* storage, SLICE* slice) {
     
     s->src->count++;
     ns->src         = s->src;
-    
+    nm_list_storage_unregister(s);
     return ns;
   }
 }
@@ -817,10 +1195,16 @@ void* nm_list_storage_ref(const STORAGE* storage, SLICE* slice) {
  * Recursive function, sets multiple values in a matrix from a single source value.
  */
 static void slice_set_single(LIST_STORAGE* dest, LIST* l, void* val, size_t* coords, size_t* lengths, size_t n) {
+  nm_list_storage_register(dest);
+  if (dest->dtype == nm::RUBYOBJ) {
+    nm_register_value(*reinterpret_cast<VALUE*>(val));
+    nm_list_storage_register_list(l, dest->dim - n - 1);
+  }
 
   // drill down into the structure
   NODE* node = NULL;
   if (dest->dim - n > 1) {
+    std::list<LIST*> temp_nodes; 
     for (size_t i = 0; i < lengths[n]; ++i) {
 
       size_t key = i + dest->offset[n] + coords[n];
@@ -833,10 +1217,17 @@ static void slice_set_single(LIST_STORAGE* dest, LIST* l, void* val, size_t* coo
         node = node->next; // correct rank already exists.
       }
 
+      if (dest->dtype == nm::RUBYOBJ) {
+        temp_nodes.push_front(reinterpret_cast<LIST*>(node->val));
+        nm_list_storage_register_list(reinterpret_cast<LIST*>(node->val), dest->dim - n - 2);
+      }
+
       // cast it to a list and recurse
       slice_set_single(dest, reinterpret_cast<LIST*>(node->val), val, coords, lengths, n + 1);
     }
+    __nm_list_storage_unregister_temp_list_list(temp_nodes, dest->dim - n - 2);
   } else {
+    std::list<VALUE*> temp_vals;
     for (size_t i = 0; i < lengths[n]; ++i) {
 
       size_t key = i + dest->offset[n] + coords[n];
@@ -846,7 +1237,18 @@ static void slice_set_single(LIST_STORAGE* dest, LIST* l, void* val, size_t* coo
       } else {
         node = nm::list::replace_insert_after(node, key, val, true, DTYPE_SIZES[dest->dtype]);
       }
+      if (dest->dtype == nm::RUBYOBJ) {
+        temp_vals.push_front(reinterpret_cast<VALUE*>(node->val));
+        nm_register_value(*reinterpret_cast<VALUE*>(node->val));
+      }
     }
+    __nm_list_storage_unregister_temp_value_list(temp_vals);
+  }
+
+  nm_list_storage_unregister(dest);
+  if (dest->dtype == nm::RUBYOBJ) {
+    nm_unregister_value(*reinterpret_cast<VALUE*>(val));
+    nm_list_storage_unregister_list(l, dest->dim - n - 1);
   }
 }
 
@@ -870,6 +1272,9 @@ void nm_list_storage_set(VALUE left, SLICE* slice, VALUE right) {
  */
 NODE* nm_list_storage_insert(STORAGE* storage, SLICE* slice, void* val) {
   LIST_STORAGE* s = (LIST_STORAGE*)storage;
+  nm_list_storage_register(s);
+  if (s->dtype == nm::RUBYOBJ)
+    nm_register_value(*reinterpret_cast<VALUE*>(val));
   // Pretend dims = 2
   // Then coords is going to be size 2
   // So we need to find out if some key already exists
@@ -878,12 +1283,16 @@ NODE* nm_list_storage_insert(STORAGE* storage, SLICE* slice, void* val) {
   LIST*  l = s->rows;
 
   // drill down into the structure
-  for (r = s->dim; r > 1; --r) {
-    n = nm::list::insert(l, false, s->offset[s->dim - r] + slice->coords[s->dim - r], nm::list::create());
+  for (r = 0; r < s->dim -1; ++r) {
+    n = nm::list::insert(l, false, s->offset[r] + slice->coords[s->dim - r], nm::list::create());
     l = reinterpret_cast<LIST*>(n->val);
   }
 
-  return nm::list::insert(l, true, s->offset[s->dim - r] + slice->coords[s->dim - r], val);
+  nm_list_storage_unregister(s);
+  if (s->dtype == nm::RUBYOBJ)
+    nm_unregister_value(*reinterpret_cast<VALUE*>(val));
+
+  return nm::list::insert(l, true, s->offset[r] + slice->coords[r], val);
 }
 
 /*
@@ -937,10 +1346,10 @@ STORAGE* nm_list_storage_matrix_multiply(const STORAGE_PAIR& casted_storage, siz
  * it's a sparse matrix.
  */
 VALUE nm_list_storage_to_hash(const LIST_STORAGE* s, const nm::dtype_t dtype) {
-
+  nm_list_storage_register(s);
   // Get the default value for the list storage.
   VALUE default_value = rubyobj_from_cval(s->default_val, dtype).rval;
-
+  nm_list_storage_unregister(s);
   // Recursively copy each dimension of the matrix into a nested hash.
   return nm_list_copy_to_hash(s->rows, dtype, s->dim - 1, default_value);
 }
@@ -1006,18 +1415,21 @@ size_t nm_list_storage_count_nd_elements(const LIST_STORAGE* s) {
  * List storage copy constructor C access.
  */
 
-LIST_STORAGE* nm_list_storage_copy(const LIST_STORAGE* rhs)
-{
-  size_t *shape = ALLOC_N(size_t, rhs->dim);
+LIST_STORAGE* nm_list_storage_copy(const LIST_STORAGE* rhs) {
+  nm_list_storage_register(rhs);
+  size_t *shape = NM_ALLOC_N(size_t, rhs->dim);
   memcpy(shape, rhs->shape, sizeof(size_t) * rhs->dim);
   
-  void *init_val = ALLOC_N(char, DTYPE_SIZES[rhs->dtype]);
+  void *init_val = NM_ALLOC_N(char, DTYPE_SIZES[rhs->dtype]);
   memcpy(init_val, rhs->default_val, DTYPE_SIZES[rhs->dtype]);
 
   LIST_STORAGE* lhs = nm_list_storage_create(rhs->dtype, shape, rhs->dim, init_val);
-  
+  nm_list_storage_register(lhs);
+
   lhs->rows = slice_copy(rhs, rhs->rows, lhs->offset, lhs->shape, 0);
 
+  nm_list_storage_unregister(rhs);
+  nm_list_storage_unregister(lhs);
   return lhs;
 }
 
@@ -1057,27 +1469,31 @@ namespace list_storage {
  */
 template <typename LDType, typename RDType>
 static LIST_STORAGE* cast_copy(const LIST_STORAGE* rhs, dtype_t new_dtype) {
-
+  nm_list_storage_register(rhs);
   // allocate and copy shape
-  size_t* shape = ALLOC_N(size_t, rhs->dim);
+  size_t* shape = NM_ALLOC_N(size_t, rhs->dim);
   memcpy(shape, rhs->shape, rhs->dim * sizeof(size_t));
 
   // copy default value
-  LDType* default_val = ALLOC_N(LDType, 1);
+  LDType* default_val = NM_ALLOC_N(LDType, 1);
   *default_val = *reinterpret_cast<RDType*>(rhs->default_val);
 
   LIST_STORAGE* lhs = nm_list_storage_create(new_dtype, shape, rhs->dim, default_val);
   //lhs->rows         = nm::list::create();
 
+  nm_list_storage_register(lhs);
   // TODO: Needs optimization. When matrix is reference it is copped twice.
   if (rhs->src == rhs) 
     nm::list::cast_copy_contents<LDType, RDType>(lhs->rows, rhs->rows, rhs->dim - 1);
   else {
     LIST_STORAGE *tmp = nm_list_storage_copy(rhs);
+    nm_list_storage_register(tmp);
     nm::list::cast_copy_contents<LDType, RDType>(lhs->rows, tmp->rows, rhs->dim - 1);
+    nm_list_storage_unregister(tmp);
     nm_list_storage_delete(tmp);
   }
-
+  nm_list_storage_unregister(lhs);
+  nm_list_storage_unregister(rhs);
   return lhs;
 }
 
@@ -1196,13 +1612,16 @@ extern "C" {
     return nm_list_storage_to_hash(NM_STORAGE_LIST(self), NM_DTYPE(self));
   }
 
-    /*
-     * call-seq:
-     *     __list_default_value__ -> ...
-     *
-     * Get the default_value property from a list matrix.
-     */
-    VALUE nm_list_default_value(VALUE self) {
-      return (NM_DTYPE(self) == nm::RUBYOBJ) ? *reinterpret_cast<VALUE*>(NM_DEFAULT_VAL(self)) : rubyobj_from_cval(NM_DEFAULT_VAL(self), NM_DTYPE(self)).rval;
-    }
+  /*
+   * call-seq:
+   *     __list_default_value__ -> ...
+   *
+   * Get the default_value property from a list matrix.
+   */
+  VALUE nm_list_default_value(VALUE self) {
+    NM_CONSERVATIVE(nm_register_value(self));
+    VALUE to_return = (NM_DTYPE(self) == nm::RUBYOBJ) ? *reinterpret_cast<VALUE*>(NM_DEFAULT_VAL(self)) : rubyobj_from_cval(NM_DEFAULT_VAL(self), NM_DTYPE(self)).rval;
+    NM_CONSERVATIVE(nm_unregister_value(self));
+    return to_return;
+  }
 } // end of extern "C" block