VM: refactoring that removes data_root_ranges

instead of storing data_root_ranges in data_roots, you can just store
cell pointers directly. the advantage with doing it that way is that
registration and traversal code becomes simpler (and slightly faster).

diff --git a/vm/arrays.cpp b/vm/arrays.cpp
index 9e97221d81ee3da95c4e8bddbc5284b8a9af39da..2c0808b6a314b43f7f4a3c2fdd741a9ee5ab591c 100644 (file)
--- a/vm/arrays.cpp
+++ b/vm/arrays.cpp
@@ -42,14 +42,18 @@ void factor_vm::primitive_resize_array() {
 
 /* Allocates memory */
 cell factor_vm::std_vector_to_array(std::vector<cell>& elements) {
+
   cell element_count = elements.size();
-  data_roots.push_back(data_root_range(&elements[0], element_count));
+  cell orig_size = data_roots.size();
+  data_roots.reserve(orig_size + element_count);
+
+  for (cell n = 0; n < element_count; n++) {
+    data_roots.push_back(&elements[n]);
+  }
 
   tagged<array> objects(allot_uninitialized_array<array>(element_count));
   memcpy(objects->data(), &elements[0], element_count * sizeof(cell));
-
-  data_roots.pop_back();
-
+  data_roots.resize(orig_size);
   return objects.value();
 }
 

diff --git a/vm/data_roots.hpp b/vm/data_roots.hpp
index 0d6d745c59bf2d1262400453734e994d4c212a25..628733291a2d763e4a1ee9ca0002a29faaccc3f4 100644 (file)
--- a/vm/data_roots.hpp
+++ b/vm/data_roots.hpp
@@ -4,7 +4,7 @@ template <typename Type> struct data_root : public tagged<Type> {
   factor_vm* parent;
 
   void push() {
-    parent->data_roots.push_back(data_root_range(&this->value_, 1));
+    parent->data_roots.push_back(&this->value_);
   }
 
   data_root(cell value, factor_vm* parent)

diff --git a/vm/layouts.hpp b/vm/layouts.hpp
index 95d75c026e779dc6c7dc3947bf4babaa54b3a6aa..701b100163c123410a864aa3e1a625371d22e5a5 100644 (file)
--- a/vm/layouts.hpp
+++ b/vm/layouts.hpp
@@ -323,12 +323,4 @@ struct tuple : public object {
   cell* data() const { return (cell*)(this + 1); }
 };
 
-struct data_root_range {
-  cell* start;
-  cell len;
-
-  data_root_range(cell* start, cell len)
-      : start(start), len(len) {}
-};
-
 }

diff --git a/vm/slot_visitor.hpp b/vm/slot_visitor.hpp
index 7ac2c0c17378c0f2204c254a7ce4e603ae8c33b2..094a178a189e9667a8a8b228572d48fbd975b75d 100644 (file)
--- a/vm/slot_visitor.hpp
+++ b/vm/slot_visitor.hpp
@@ -175,12 +175,14 @@ void slot_visitor<Fixup>::visit_stack_elements(segment* region, cell* top) {
 }
 
 template <typename Fixup> void slot_visitor<Fixup>::visit_data_roots() {
-  std::vector<data_root_range>::const_iterator iter =
+  std::vector<cell*>::const_iterator iter =
       parent->data_roots.begin();
-  std::vector<data_root_range>::const_iterator end = parent->data_roots.end();
+  std::vector<cell*>::const_iterator end =
+      parent->data_roots.end();
 
-  for (; iter < end; iter++)
-    visit_object_array(iter->start, iter->start + iter->len);
+  for (; iter < end; iter++) {
+    visit_handle(*iter);
+  }
 }
 
 template <typename Fixup> void slot_visitor<Fixup>::visit_bignum_roots() {

diff --git a/vm/vm.hpp b/vm/vm.hpp
index 49499b5cbefae86c5077da37a9643903525c0d5d..6bf51c40e919336bc79125872f8d25bb7c7ff9a2 100644 (file)
--- a/vm/vm.hpp
+++ b/vm/vm.hpp
@@ -112,7 +112,8 @@ struct factor_vm {
      allocates memory, it must wrap any references to the data and code
      heaps with data_root and code_root smart pointers, which register
      themselves here. See data_roots.hpp and code_roots.hpp */
-  std::vector<data_root_range> data_roots;
+
+  std::vector<cell*> data_roots;
   std::vector<cell> bignum_roots;
   std::vector<code_root*> code_roots;