vm: make the code nice and pretty

diff --git a/vm/aging_collector.cpp b/vm/aging_collector.cpp
index 74372736492c53dddc6953d447b2175d6e81229c..6e3e61412af7b4271a6807bca44ec4af68ebb0c5 100644 (file)
--- a/vm/aging_collector.cpp
+++ b/vm/aging_collector.cpp
@@ -12,6 +12,8 @@ aging_collector::aging_collector(factor_vm *myvm_) :
 
 void factor_vm::collect_aging()
 {
+       /* Promote objects referenced from tenured space to tenured space, copy
+       everything else to the aging semi-space, and reset the nursery pointer. */
        {
                /* Change the op so that if we fail here, we proceed to a full
                tenured collection. We are collecting to tenured space, and

diff --git a/vm/code_heap.cpp b/vm/code_heap.cpp
index 6eb420cbdeb8ecd52994be3a12f41557eb7c23d6..da4f7995b85e12a827b8e5ba91a66b8251618e8b 100755 (executable)
--- a/vm/code_heap.cpp
+++ b/vm/code_heap.cpp
@@ -11,6 +11,12 @@ void code_heap::write_barrier(code_block *compiled)
        points_to_aging.insert(compiled);
 }
 
+void code_heap::clear_remembered_set()
+{
+       points_to_nursery.clear();
+       points_to_aging.clear();
+}
+
 bool code_heap::needs_fixup_p(code_block *compiled)
 {
        return needs_fixup.count(compiled) > 0;
@@ -224,7 +230,7 @@ void factor_vm::fixup_object_xts()
 
 /* Move all free space to the end of the code heap. This is not very efficient,
 since it makes several passes over the code and data heaps, but we only ever
-do this before saving a deployed image and exiting, so performaance is not
+do this before saving a deployed image and exiting, so performance is not
 critical here */
 void factor_vm::compact_code_heap()
 {

diff --git a/vm/code_heap.hpp b/vm/code_heap.hpp
index f9084d0b43c579458db170687f8220c2a642a994..2f209d3e76058811e3e435a5bef9dc7a207970d3 100755 (executable)
--- a/vm/code_heap.hpp
+++ b/vm/code_heap.hpp
@@ -13,6 +13,7 @@ struct code_heap : heap {
 
        explicit code_heap(bool secure_gc, cell size);
        void write_barrier(code_block *compiled);
+       void clear_remembered_set();
        bool needs_fixup_p(code_block *compiled);
        void code_heap_free(code_block *compiled);
 };

diff --git a/vm/full_collector.cpp b/vm/full_collector.cpp
index 64d83df3f5d81a868e7a9c275759a1b7fb464eb2..8fb4eea406557bf32710d3836cf50f89301d3ef6 100644 (file)
--- a/vm/full_collector.cpp
+++ b/vm/full_collector.cpp
@@ -123,23 +123,6 @@ struct after_full_updater {
        }
 };
 
-void factor_vm::update_code_heap_for_full_gc(bool growing_data_heap)
-{
-       if(growing_data_heap)
-       {
-               after_growing_heap_updater updater(this);
-               code->free_unmarked(updater);
-       }
-       else
-       {
-               after_full_updater updater(this);
-               code->free_unmarked(updater);
-       }
-
-       code->points_to_nursery.clear();
-       code->points_to_aging.clear();
-}
-
 void factor_vm::collect_full_impl(bool trace_contexts_p)
 {
        full_collector collector(this);
@@ -159,19 +142,27 @@ void factor_vm::collect_full_impl(bool trace_contexts_p)
 
 void factor_vm::collect_growing_heap(cell requested_bytes, bool trace_contexts_p)
 {
+       /* Grow the data heap and copy all live objects to the new heap. */
        data_heap *old = data;
        set_data_heap(data->grow(requested_bytes));
        collect_full_impl(trace_contexts_p);
-       update_code_heap_for_full_gc(true);
        delete old;
+
+       after_growing_heap_updater updater(this);
+       code->free_unmarked(updater);
+       code->clear_remembered_set();
 }
 
 void factor_vm::collect_full(bool trace_contexts_p)
 {
+       /* Copy all live objects to the tenured semispace. */
        std::swap(data->tenured,data->tenured_semispace);
        reset_generation(data->tenured);
        collect_full_impl(trace_contexts_p);
-       update_code_heap_for_full_gc(false);
+
+       after_full_updater updater(this);
+       code->free_unmarked(updater);
+       code->clear_remembered_set();
 }
 
 }

diff --git a/vm/nursery_collector.cpp b/vm/nursery_collector.cpp
index 0cb231417ead6c03db05d0cc9a991f871033f2f0..6eb6d840f16a327a0f8546477eed03dcfa9f4f8f 100644 (file)
--- a/vm/nursery_collector.cpp
+++ b/vm/nursery_collector.cpp
@@ -12,6 +12,8 @@ nursery_collector::nursery_collector(factor_vm *myvm_) :
 
 void factor_vm::collect_nursery()
 {
+       /* Copy live objects from the nursery (as determined by the root set and
+       marked cards in aging and tenured) to aging space. */
        nursery_collector collector(this);
 
        collector.trace_roots();

diff --git a/vm/to_tenured_collector.cpp b/vm/to_tenured_collector.cpp
index 68038703c58e762ba5bf8eb67da6e247f8897d05..b5d4793ceb2cf9550aa2477c9c2245ef0cc44c53 100644 (file)
--- a/vm/to_tenured_collector.cpp
+++ b/vm/to_tenured_collector.cpp
@@ -12,6 +12,7 @@ to_tenured_collector::to_tenured_collector(factor_vm *myvm_) :
 
 void factor_vm::collect_to_tenured()
 {
+       /* Copy live objects from aging space to tenured space. */
        to_tenured_collector collector(this);
 
        collector.trace_roots();

diff --git a/vm/to_tenured_collector.hpp b/vm/to_tenured_collector.hpp
index 55561252bcec2f22bc8bb1790be546b584622fff..64bd9aa04d401626acf0099480454513a07a6a24 100644 (file)
--- a/vm/to_tenured_collector.hpp
+++ b/vm/to_tenured_collector.hpp
@@ -15,7 +15,6 @@ struct to_tenured_policy {
 
 struct to_tenured_collector : copying_collector<tenured_space,to_tenured_policy> {
        to_tenured_collector(factor_vm *myvm_);
-       void go();
 };
 
 }

diff --git a/vm/vm.hpp b/vm/vm.hpp
index e2fc589cd27f1eb7b85a09379f2144fa2a752646..3674dd465e7b64141f54133165ad0390fd6c00f5 100755 (executable)
--- a/vm/vm.hpp
+++ b/vm/vm.hpp
@@ -238,7 +238,6 @@ struct factor_vm
        void collect_nursery();
        void collect_aging();
        void collect_to_tenured();
-       void update_code_heap_for_full_gc(bool growing_data_heap);
        void collect_full_impl(bool trace_contexts_p);
        void collect_growing_heap(cell requested_bytes, bool trace_contexts_p);
        void collect_full(bool trace_contexts_p);