vm: minor GC traces embedded pointers

diff --git a/vm/aging_collector.cpp b/vm/aging_collector.cpp
index 3572677aa6d54dc801c3647a43f3c8b62ce703ba..1695846ee7c086bc9c9292c7479e38a7252b8d06 100644 (file)
--- a/vm/aging_collector.cpp
+++ b/vm/aging_collector.cpp
@@ -33,10 +33,6 @@ void factor_vm::collect_aging()
                current_gc->event->ended_code_scan(collector.code_blocks_scanned);
 
                collector.tenure_reachable_objects();
-
-               current_gc->event->started_code_sweep();
-               update_code_heap_for_minor_gc(&code->points_to_aging);
-               current_gc->event->ended_code_sweep();
        }
        {
                /* If collection fails here, do a to_tenured collection. */

diff --git a/vm/code_blocks.cpp b/vm/code_blocks.cpp
index d33d468d20f461f5c89cc4fd29f3149e19170029..a7df30d4bfc32f484bc8ad2fa39fc7cd7ef9ef97 100755 (executable)
--- a/vm/code_blocks.cpp
+++ b/vm/code_blocks.cpp
@@ -151,51 +151,6 @@ cell factor_vm::compute_relocation(relocation_entry rel, cell index, code_block
 #undef ARG
 }
 
-template<typename Iterator> void factor_vm::iterate_relocations(code_block *compiled, Iterator &iter)
-{
-       if(to_boolean(compiled->relocation))
-       {
-               byte_array *relocation = untag<byte_array>(compiled->relocation);
-
-               cell index = 0;
-               cell length = array_capacity(relocation) / sizeof(relocation_entry);
-
-               for(cell i = 0; i < length; i++)
-               {
-                       relocation_entry rel = relocation->data<relocation_entry>()[i];
-                       iter(rel,index,compiled);
-                       index += rel.number_of_parameters();
-               }
-       }
-}
-
-struct literal_references_updater {
-       factor_vm *parent;
-
-       explicit literal_references_updater(factor_vm *parent_) : parent(parent_) {}
-
-       void operator()(relocation_entry rel, cell index, code_block *compiled)
-       {
-               if(rel.rel_type() == RT_IMMEDIATE)
-               {
-                       embedded_pointer ptr(rel.rel_class(),rel.rel_offset() + (cell)(compiled + 1));
-                       array *literals = untag<array>(compiled->literals);
-                       ptr.store_address(array_nth(literals,index));
-               }
-       }
-};
-
-/* Update pointers to literals from compiled code. */
-void factor_vm::update_literal_references(code_block *compiled)
-{
-       if(!code->needs_fixup_p(compiled))
-       {
-               literal_references_updater updater(this);
-               iterate_relocations(compiled,updater);
-               flush_icache_for(compiled);
-       }
-}
-
 /* Compute an address to store at a relocation */
 void factor_vm::relocate_code_block_step(relocation_entry rel, cell index, code_block *compiled)
 {

diff --git a/vm/full_collector.cpp b/vm/full_collector.cpp
index 188ab55efc067547cb5068d43ff323b792f478af..e6f155e58a020568dba952170cd177c5cdff5ca2 100644 (file)
--- a/vm/full_collector.cpp
+++ b/vm/full_collector.cpp
@@ -114,9 +114,10 @@ void factor_vm::collect_sweep_impl()
 {
        current_gc->event->started_data_sweep();
        data->tenured->sweep();
-       update_code_roots_for_sweep();
        current_gc->event->ended_data_sweep();
 
+       update_code_roots_for_sweep();
+
        current_gc->event->started_code_sweep();
        code->allocator->sweep();
        current_gc->event->ended_code_sweep();

diff --git a/vm/gc.cpp b/vm/gc.cpp
index ff458e95dce7254365fce26fced193e740f10c47..f90ad58f231408427908524b5885413c37aee21d 100755 (executable)
--- a/vm/gc.cpp
+++ b/vm/gc.cpp
@@ -126,15 +126,6 @@ void factor_vm::start_gc_again()
        current_gc->event = new gc_event(current_gc->op,this);
 }
 
-void factor_vm::update_code_heap_for_minor_gc(std::set<code_block *> *remembered_set)
-{
-       /* The youngest generation that any code block can now reference */
-       std::set<code_block *>::const_iterator iter = remembered_set->begin();
-       std::set<code_block *>::const_iterator end = remembered_set->end();
-
-       for(; iter != end; iter++) update_literal_references(*iter);
-}
-
 void factor_vm::gc(gc_op op, cell requested_bytes, bool trace_contexts_p)
 {
        assert(!gc_off);

diff --git a/vm/master.hpp b/vm/master.hpp
index cfb71a47157e5390d3b1637c1c95a87a236992cc..ba782c3bd78953e7930d3c4fa57cb3c103a5ae5a 100755 (executable)
--- a/vm/master.hpp
+++ b/vm/master.hpp
@@ -79,6 +79,7 @@ namespace factor
 #include "tagged.hpp"
 #include "data_roots.hpp"
 #include "code_roots.hpp"
+#include "generic_arrays.hpp"
 #include "slot_visitor.hpp"
 #include "collector.hpp"
 #include "copying_collector.hpp"
@@ -89,7 +90,6 @@ namespace factor
 #include "compaction.hpp"
 #include "full_collector.hpp"
 #include "callstack.hpp"
-#include "generic_arrays.hpp"
 #include "arrays.hpp"
 #include "math.hpp"
 #include "booleans.hpp"

diff --git a/vm/nursery_collector.cpp b/vm/nursery_collector.cpp
index 5eb77fd763009d396a9490cdf63632bd44410c72..062aa6aed33294b8f4b0bf092eefaabfc848a52b 100644 (file)
--- a/vm/nursery_collector.cpp
+++ b/vm/nursery_collector.cpp
@@ -36,10 +36,6 @@ void factor_vm::collect_nursery()
 
        collector.cheneys_algorithm();
 
-       current_gc->event->started_code_sweep();
-       update_code_heap_for_minor_gc(&code->points_to_nursery);
-       current_gc->event->ended_code_sweep();
-
        data->reset_generation(&nursery);
        code->points_to_nursery.clear();
 }

diff --git a/vm/slot_visitor.hpp b/vm/slot_visitor.hpp
index 908e0f3152ff77f6351876f6b361dd87e1bef006..aa2751d690b3975ae7d73245c6683f04b949d2df 100644 (file)
--- a/vm/slot_visitor.hpp
+++ b/vm/slot_visitor.hpp
@@ -8,106 +8,150 @@ template<typename Visitor> struct slot_visitor {
        explicit slot_visitor<Visitor>(factor_vm *parent_, Visitor visitor_) :
                parent(parent_), visitor(visitor_) {}
 
-       cell visit_pointer(cell pointer)
-       {
-               if(immediate_p(pointer)) return pointer;
+       cell visit_pointer(cell pointer);
+       void visit_handle(cell *handle);
+       void visit_slots(object *ptr, cell payload_start);
+       void visit_slots(object *ptr);
+       void visit_stack_elements(segment *region, cell *top);
+       void visit_data_roots();
+       void visit_bignum_roots();
+       void visit_roots();
+       void visit_contexts();
+       void visit_literal_references(code_block *compiled);
+};
 
-               object *untagged = untag<object>(pointer);
-               untagged = visitor(untagged);
-               return RETAG(untagged,TAG(pointer));
-       }
+template<typename Visitor>
+cell slot_visitor<Visitor>::visit_pointer(cell pointer)
+{
+       if(immediate_p(pointer)) return pointer;
 
-       void visit_handle(cell *handle)
-       {
-               *handle = visit_pointer(*handle);
-       }
+       object *untagged = untag<object>(pointer);
+       untagged = visitor(untagged);
+       return RETAG(untagged,TAG(pointer));
+}
 
-       void visit_slots(object *ptr, cell payload_start)
-       {
-               cell *slot = (cell *)ptr;
-               cell *end = (cell *)((cell)ptr + payload_start);
+template<typename Visitor>
+void slot_visitor<Visitor>::visit_handle(cell *handle)
+{
+       *handle = visit_pointer(*handle);
+}
 
-               if(slot != end)
-               {
-                       slot++;
-                       for(; slot < end; slot++) visit_handle(slot);
-               }
-       }
+template<typename Visitor>
+void slot_visitor<Visitor>::visit_slots(object *ptr, cell payload_start)
+{
+       cell *slot = (cell *)ptr;
+       cell *end = (cell *)((cell)ptr + payload_start);
 
-       void visit_slots(object *ptr)
+       if(slot != end)
        {
-               visit_slots(ptr,ptr->binary_payload_start());
+               slot++;
+               for(; slot < end; slot++) visit_handle(slot);
        }
+}
 
-       void visit_stack_elements(segment *region, cell *top)
+template<typename Visitor>
+void slot_visitor<Visitor>::visit_slots(object *ptr)
+{
+       visit_slots(ptr,ptr->binary_payload_start());
+}
+
+template<typename Visitor>
+void slot_visitor<Visitor>::visit_stack_elements(segment *region, cell *top)
+{
+       for(cell *ptr = (cell *)region->start; ptr <= top; ptr++)
+               visit_handle(ptr);
+}
+
+template<typename Visitor>
+void slot_visitor<Visitor>::visit_data_roots()
+{
+       std::vector<data_root_range>::const_iterator iter = parent->data_roots.begin();
+       std::vector<data_root_range>::const_iterator end = parent->data_roots.end();
+
+       for(; iter < end; iter++)
        {
-               for(cell *ptr = (cell *)region->start; ptr <= top; ptr++)
-                       visit_handle(ptr);
+               data_root_range r = *iter;
+               for(cell index = 0; index < r.len; index++)
+                       visit_handle(r.start + index);
        }
+}
+
+template<typename Visitor>
+void slot_visitor<Visitor>::visit_bignum_roots()
+{
+       std::vector<cell>::const_iterator iter = parent->bignum_roots.begin();
+       std::vector<cell>::const_iterator end = parent->bignum_roots.end();
 
-       void visit_data_roots()
+       for(; iter < end; iter++)
        {
-               std::vector<data_root_range>::const_iterator iter = parent->data_roots.begin();
-               std::vector<data_root_range>::const_iterator end = parent->data_roots.end();
+               cell *handle = (cell *)(*iter);
 
-               for(; iter < end; iter++)
-               {
-                       data_root_range r = *iter;
-                       for(cell index = 0; index < r.len; index++)
-                               visit_handle(r.start + index);
-               }
+               if(*handle)
+                       *handle = (cell)visitor(*(object **)handle);
        }
+}
 
-       void visit_bignum_roots()
-       {
-               std::vector<cell>::const_iterator iter = parent->bignum_roots.begin();
-               std::vector<cell>::const_iterator end = parent->bignum_roots.end();
+template<typename Visitor>
+void slot_visitor<Visitor>::visit_roots()
+{
+       visit_handle(&parent->true_object);
+       visit_handle(&parent->bignum_zero);
+       visit_handle(&parent->bignum_pos_one);
+       visit_handle(&parent->bignum_neg_one);
 
-               for(; iter < end; iter++)
-               {
-                       cell *handle = (cell *)(*iter);
+       visit_data_roots();
+       visit_bignum_roots();
 
-                       if(*handle)
-                               *handle = (cell)visitor(*(object **)handle);
-               }
-       }
+       for(cell i = 0; i < special_object_count; i++)
+               visit_handle(&parent->special_objects[i]);
+}
+
+template<typename Visitor>
+void slot_visitor<Visitor>::visit_contexts()
+{
+       context *ctx = parent->ctx;
 
-       void visit_roots()
+       while(ctx)
        {
-               visit_handle(&parent->true_object);
-               visit_handle(&parent->bignum_zero);
-               visit_handle(&parent->bignum_pos_one);
-               visit_handle(&parent->bignum_neg_one);
+               visit_stack_elements(ctx->datastack_region,(cell *)ctx->datastack);
+               visit_stack_elements(ctx->retainstack_region,(cell *)ctx->retainstack);
 
-               visit_data_roots();
-               visit_bignum_roots();
+               visit_handle(&ctx->catchstack_save);
+               visit_handle(&ctx->current_callback_save);
 
-               for(cell i = 0; i < special_object_count; i++)
-                       visit_handle(&parent->special_objects[i]);
+               ctx = ctx->next;
        }
+}
 
-       void visit_contexts()
-       {
-               context *ctx = parent->ctx;
-
-               while(ctx)
-               {
-                       visit_stack_elements(ctx->datastack_region,(cell *)ctx->datastack);
-                       visit_stack_elements(ctx->retainstack_region,(cell *)ctx->retainstack);
-
-                       visit_handle(&ctx->catchstack_save);
-                       visit_handle(&ctx->current_callback_save);
+template<typename Visitor>
+struct literal_references_visitor {
+       factor_vm *parent;
+       slot_visitor<Visitor> *visitor;
 
-                       ctx = ctx->next;
-               }
-       }
+       explicit literal_references_visitor(factor_vm *parent_, slot_visitor<Visitor> *visitor_)
+               : parent(parent_), visitor(visitor_) {}
 
-       void visit_literal_references(code_block *compiled)
+       void operator()(relocation_entry rel, cell index, code_block *compiled)
        {
-               visit_handle(&compiled->owner);
-               visit_handle(&compiled->literals);
-               visit_handle(&compiled->relocation);
+               if(rel.rel_type() == RT_IMMEDIATE)
+               {
+                       embedded_pointer ptr(rel.rel_class(),rel.rel_offset() + (cell)(compiled + 1));
+                       cell literal = ptr.load_address();
+                       literal = visitor->visit_pointer(literal);
+                       ptr.store_address(literal);
+               }
        }
 };
 
+template<typename Visitor>
+void slot_visitor<Visitor>::visit_literal_references(code_block *compiled)
+{
+       visit_handle(&compiled->owner);
+       visit_handle(&compiled->literals);
+       visit_handle(&compiled->relocation);
+
+       literal_references_visitor<Visitor> visitor(parent,this);
+       parent->iterate_relocations(compiled,visitor);
+}
+
 }

diff --git a/vm/to_tenured_collector.cpp b/vm/to_tenured_collector.cpp
index 0cee7482058a9f3493dae9a37f647a260d9069f9..b2fe3461b9ffdd02be319a9223d69c7f8b28d1ea 100644 (file)
--- a/vm/to_tenured_collector.cpp
+++ b/vm/to_tenured_collector.cpp
@@ -42,10 +42,6 @@ void factor_vm::collect_to_tenured()
 
        collector.tenure_reachable_objects();
 
-       current_gc->event->started_code_sweep();
-       update_code_heap_for_minor_gc(&code->points_to_aging);
-       current_gc->event->ended_code_sweep();
-
        data->reset_generation(&nursery);
        data->reset_generation(data->aging);
        code->clear_remembered_set();

diff --git a/vm/vm.hpp b/vm/vm.hpp
index 67997e859021b1686232aa0b984a46f1d0e00f3b..5548f7190581cfc32740110ada713e2b8b0d8b7d 100755 (executable)
--- a/vm/vm.hpp
+++ b/vm/vm.hpp
@@ -504,8 +504,25 @@ struct factor_vm
        void undefined_symbol();
        void *get_rel_symbol(array *literals, cell index);
        cell compute_relocation(relocation_entry rel, cell index, code_block *compiled);
-       template<typename Iterator> void iterate_relocations(code_block *compiled, Iterator &iter);
-       void update_literal_references(code_block *compiled);
+
+       template<typename Iterator> void iterate_relocations(code_block *compiled, Iterator &iter)
+       {
+               if(to_boolean(compiled->relocation))
+               {
+                       byte_array *relocation = (byte_array *)UNTAG(compiled->relocation);
+
+                       cell index = 0;
+                       cell length = (relocation->capacity >> TAG_BITS) / sizeof(relocation_entry);
+
+                       for(cell i = 0; i < length; i++)
+                       {
+                               relocation_entry rel = relocation->data<relocation_entry>()[i];
+                               iter(rel,index,compiled);
+                               index += rel.number_of_parameters();
+                       }
+               }
+       }
+
        void relocate_code_block_step(relocation_entry rel, cell index, code_block *compiled);
        void update_word_references(code_block *compiled);
        void update_code_block_words_and_literals(code_block *compiled);