From 0a3d08bc524b3d94d089afc21b0f7f926a9a873a Mon Sep 17 00:00:00 2001 From: Slava Pestov Date: Fri, 16 Oct 2009 02:55:02 -0500 Subject: [PATCH] vm: make the code nice and pretty --- vm/aging_collector.cpp | 2 ++ vm/code_heap.cpp | 8 +++++++- vm/code_heap.hpp | 1 + vm/full_collector.cpp | 29 ++++++++++------------------- vm/nursery_collector.cpp | 2 ++ vm/to_tenured_collector.cpp | 1 + vm/to_tenured_collector.hpp | 1 - vm/vm.hpp | 1 - 8 files changed, 23 insertions(+), 22 deletions(-) diff --git a/vm/aging_collector.cpp b/vm/aging_collector.cpp index 7437273649..6e3e61412a 100644 --- 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 6eb420cbde..da4f7995b8 100755 --- 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 f9084d0b43..2f209d3e76 100755 --- 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 64d83df3f5..8fb4eea406 100644 --- 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 0cb231417e..6eb6d840f1 100644 --- 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 68038703c5..b5d4793ceb 100644 --- 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 55561252bc..64bd9aa04d 100644 --- 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 { to_tenured_collector(factor_vm *myvm_); - void go(); }; } diff --git a/vm/vm.hpp b/vm/vm.hpp index e2fc589cd2..3674dd465e 100755 --- 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);