vm: restructure data_roots so that its a sequence of handle/len pairs rather than...

diff --git a/vm/data_heap.cpp b/vm/data_heap.cpp
index 9791c33892431d3a0039627c3f86d22344168c6d..e13d0dbae1a013ee37be0e41a23189fc63b582e7 100755 (executable)
--- a/vm/data_heap.cpp
+++ b/vm/data_heap.cpp
@@ -245,10 +245,14 @@ cell factor_vm::instances(cell type)
        each_object(accum);
        cell object_count = accum.objects.size();
 
-       gc_off = true;
+       data_roots.push_back(accum.objects[0]);
+       data_roots.push_back(object_count);
+
        array *objects = allot_array(object_count,false_object);
        memcpy(objects->data(),&accum.objects[0],object_count * sizeof(cell));
-       gc_off = false;
+
+       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 52654c49f0274dc14cbf717aeb07fa315a2f40de..1b3eb888ef004a5d9f56c49cf341bb4905a60c6a 100644 (file)
--- a/vm/data_roots.hpp
+++ b/vm/data_roots.hpp
@@ -8,6 +8,7 @@ struct data_root : public tagged<Type> {
        void push()
        {
                parent->data_roots.push_back((cell)this);
+               parent->data_roots.push_back(1);
        }
 
        explicit data_root(cell value_, factor_vm *parent_)
@@ -27,6 +28,10 @@ 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

diff --git a/vm/gc.cpp b/vm/gc.cpp
index 79f04db802c3078bfff5f7b6e27c065b1bb82b7d..98266ecc913fd77adbba6e5b2f4efc7e8e753961 100755 (executable)
--- a/vm/gc.cpp
+++ b/vm/gc.cpp
@@ -218,18 +218,18 @@ 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)
 {
-       for(cell i = 0; i < data_roots_size; i++)
-               data_roots.push_back((cell)&data_roots_base[i]);
+       data_roots.push_back(data_roots_base);
+       data_roots.push_back(data_roots_size);
 
        primitive_minor_gc();
 
-       for(cell i = 0; i < data_roots_size; i++)
-               data_roots.pop_back();
+       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 a9250eddb20e17f3123d5a96fb5779fa1e099078..83e5da8aa1b016bf594622f521b7870a879f6c39 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/slot_visitor.hpp b/vm/slot_visitor.hpp
index e777347622b3ccc9970d6e73f2f15dbe087a6145..c0263ebf114b8a9474c895a33a2bc23944dd790c 100644 (file)
--- a/vm/slot_visitor.hpp
+++ b/vm/slot_visitor.hpp
@@ -8,15 +8,18 @@ template<typename Visitor> struct slot_visitor {
        explicit slot_visitor<Visitor>(factor_vm *parent_, Visitor visitor_) :
                parent(parent_), visitor(visitor_) {}
 
-       void visit_handle(cell *handle)
+       cell visit_pointer(cell pointer)
        {
-               cell pointer = *handle;
-
-               if(immediate_p(pointer)) return;
-
                object *untagged = untag<object>(pointer);
                untagged = visitor(untagged);
-               *handle = RETAG(untagged,TAG(pointer));
+               return RETAG(untagged,TAG(pointer));
+       }
+
+       void visit_handle(cell *handle)
+       {
+               cell pointer = *handle;
+               if(!immediate_p(pointer))
+                       *handle = visit_pointer(pointer);
        }
 
        void visit_slots(object *ptr, cell payload_start)
@@ -47,8 +50,13 @@ template<typename Visitor> struct slot_visitor {
                std::vector<cell>::const_iterator iter = parent->data_roots.begin();
                std::vector<cell>::const_iterator end = parent->data_roots.end();
 
-               for(; iter < end; iter++)
-                       visit_handle((cell *)(*iter));
+               while(iter < end)
+               {
+                       cell start = *iter++;
+                       cell len = *iter++;
+                       for(cell index = 0; index < len; index++)
+                               visit_handle((cell *)start + index);
+               }
        }
 
        void visit_bignum_roots()

diff --git a/vm/vm.hpp b/vm/vm.hpp
index b89dda4085b05559c6052f54e6913fe1a99645a7..cb0d0968a0799ef5fcb7906f2520092f22d56ff5 100755 (executable)
--- a/vm/vm.hpp
+++ b/vm/vm.hpp
@@ -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);