vm: faster data_root and <array> primitive

diff --git a/vm/arrays.cpp b/vm/arrays.cpp
index 3060ac70a348004f22af63c596514068db6fe707..3945670e7dc7456fd241c85f52fb57b2c43f4736 100644 (file)
--- a/vm/arrays.cpp
+++ b/vm/arrays.cpp
@@ -7,9 +7,9 @@ namespace factor
 array *factor_vm::allot_array(cell capacity, cell fill_)
 {
        data_root<object> fill(fill_,this);
-       data_root<array> new_array(allot_uninitialized_array<array>(capacity),this);
+       array *new_array = allot_uninitialized_array<array>(capacity);
        memset_cell(new_array->data(),fill.value(),capacity * sizeof(cell));
-       return new_array.untagged();
+       return new_array;
 }
 
 /* push a new array on the stack */

diff --git a/vm/data_heap.cpp b/vm/data_heap.cpp
index a080417db0be2412c0cbe89804fcaaed2e1cbd21..c62b433af07ca61a8ad8819f9bcf809efe57404c 100755 (executable)
--- a/vm/data_heap.cpp
+++ b/vm/data_heap.cpp
@@ -245,13 +245,11 @@ cell factor_vm::instances(cell type)
        each_object(accum);
        cell object_count = accum.objects.size();
 
-       data_roots.push_back((cell)&accum.objects[0]);
-       data_roots.push_back(object_count);
+       data_roots.push_back(data_root_range(&accum.objects[0],object_count));
 
        array *objects = allot_array(object_count,false_object);
        memcpy(objects->data(),&accum.objects[0],object_count * sizeof(cell));
 
-       data_roots.pop_back();
        data_roots.pop_back();
 
        return tag<array>(objects);

diff --git a/vm/data_roots.hpp b/vm/data_roots.hpp
index 1b3eb888ef004a5d9f56c49cf341bb4905a60c6a..8e366a7cfd7c514af73718feb9d2fa57a9ec10bd 100644 (file)
--- a/vm/data_roots.hpp
+++ b/vm/data_roots.hpp
@@ -7,8 +7,7 @@ struct data_root : public tagged<Type> {
 
        void push()
        {
-               parent->data_roots.push_back((cell)this);
-               parent->data_roots.push_back(1);
+               parent->data_roots.push_back(data_root_range(&this->value_,1));
        }
 
        explicit data_root(cell value_, factor_vm *parent_)
@@ -28,13 +27,6 @@ struct data_root : public tagged<Type> {
 
        ~data_root()
        {
-#ifdef FACTOR_DEBUG
-               assert(parent->data_roots.back() == 1);
-#endif
-               parent->data_roots.pop_back();
-#ifdef FACTOR_DEBUG
-               assert(parent->data_roots.back() == (cell)this);
-#endif
                parent->data_roots.pop_back();
        }
 };

diff --git a/vm/gc.cpp b/vm/gc.cpp
index 98266ecc913fd77adbba6e5b2f4efc7e8e753961..79fba81d19861a6dfcc55ced66a422753ea91973 100755 (executable)
--- a/vm/gc.cpp
+++ b/vm/gc.cpp
@@ -218,18 +218,14 @@ void factor_vm::primitive_compact_gc()
                true /* trace contexts? */);
 }
 
-void factor_vm::inline_gc(cell data_roots_base, cell data_roots_size)
+void factor_vm::inline_gc(cell *data_roots_base, cell data_roots_size)
 {
-       data_roots.push_back(data_roots_base);
-       data_roots.push_back(data_roots_size);
-
+       data_roots.push_back(data_root_range(data_roots_base,data_roots_size));
        primitive_minor_gc();
-
-       data_roots.pop_back();
        data_roots.pop_back();
 }
 
-VM_C_API void inline_gc(cell data_roots_base, cell data_roots_size, factor_vm *parent)
+VM_C_API void inline_gc(cell *data_roots_base, cell data_roots_size, factor_vm *parent)
 {
        parent->inline_gc(data_roots_base,data_roots_size);
 }

diff --git a/vm/gc.hpp b/vm/gc.hpp
index 83e5da8aa1b016bf594622f521b7870a879f6c39..a9250eddb20e17f3123d5a96fb5779fa1e099078 100755 (executable)
--- a/vm/gc.hpp
+++ b/vm/gc.hpp
@@ -53,6 +53,6 @@ struct gc_state {
        void start_again(gc_op op_, factor_vm *parent);
 };
 
-VM_C_API void inline_gc(cell data_roots_base, cell data_roots_size, factor_vm *parent);
+VM_C_API void inline_gc(cell *data_roots_base, cell data_roots_size, factor_vm *parent);
 
 }

diff --git a/vm/layouts.hpp b/vm/layouts.hpp
index 5f3f3e93100bdbe9ad0c301cec4d35dcd1b9b299..5eea72a002c836dcc43f712bd7fa7cbc2a9c0168 100644 (file)
--- a/vm/layouts.hpp
+++ b/vm/layouts.hpp
@@ -373,4 +373,12 @@ struct tuple : public object {
        cell *data() const { return (cell *)(this + 1); }
 };
 
+struct data_root_range {
+       cell *start;
+       cell len;
+
+       explicit data_root_range(cell *start_, cell len_) :
+               start(start_), len(len_) {}
+};
+
 }

diff --git a/vm/slot_visitor.hpp b/vm/slot_visitor.hpp
index eb24179336df2f990bb06d889901d8c29431915b..af920fc6e2401b7bc4d4fb1b6de92f360fa6befc 100644 (file)
--- a/vm/slot_visitor.hpp
+++ b/vm/slot_visitor.hpp
@@ -43,15 +43,14 @@ template<typename Visitor> struct slot_visitor {
 
        void visit_data_roots()
        {
-               std::vector<cell>::const_iterator iter = parent->data_roots.begin();
-               std::vector<cell>::const_iterator end = parent->data_roots.end();
+               std::vector<data_root_range>::const_iterator iter = parent->data_roots.begin();
+               std::vector<data_root_range>::const_iterator end = parent->data_roots.end();
 
-               while(iter < end)
+               for(; iter < end; iter++)
                {
-                       cell start = *iter++;
-                       cell len = *iter++;
-                       for(cell index = 0; index < len; index++)
-                               visit_handle((cell *)start + index);
+                       data_root_range r = *iter;
+                       for(cell index = 0; index < r.len; index++)
+                               visit_handle(r.start + index);
                }
        }
 

diff --git a/vm/vm.hpp b/vm/vm.hpp
index cb0d0968a0799ef5fcb7906f2520092f22d56ff5..05f15af560d8031e4761727c3df698a260273531 100755 (executable)
--- a/vm/vm.hpp
+++ b/vm/vm.hpp
@@ -62,7 +62,7 @@ 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<cell> data_roots;
+       std::vector<data_root_range> data_roots;
        std::vector<cell> bignum_roots;
        std::vector<code_root *> code_roots;
 
@@ -281,7 +281,7 @@ struct factor_vm
        void primitive_minor_gc();
        void primitive_full_gc();
        void primitive_compact_gc();
-       void inline_gc(cell data_roots_base, cell data_roots_size);
+       void inline_gc(cell *data_roots_base, cell data_roots_size);
        void primitive_enable_gc_events();
        void primitive_disable_gc_events();
        object *allot_object(header header, cell size);