From ee5fd49b9eb5d35d975b63c59d3f36ec01784629 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bj=C3=B6rn=20Lindqvist?= Date: Wed, 14 Jan 2015 03:11:49 +0000 Subject: [PATCH] VM: simplified fixup_gc_workhorse::fixup_data by mering lots of functions only used once --- vm/code_heap.cpp | 8 ------- vm/code_heap.hpp | 2 -- vm/collector.hpp | 44 ++++++++++++++------------------------ vm/debug.cpp | 2 +- vm/fixup.hpp | 4 ---- vm/free_list_allocator.hpp | 2 +- vm/full_collector.hpp | 4 ++-- vm/tenured_space.hpp | 8 ------- vm/vm.hpp | 5 ----- 9 files changed, 20 insertions(+), 59 deletions(-) diff --git a/vm/code_heap.cpp b/vm/code_heap.cpp index b6b1e4e648..143f700b50 100644 --- a/vm/code_heap.cpp +++ b/vm/code_heap.cpp @@ -39,14 +39,6 @@ bool code_heap::uninitialized_p(code_block* compiled) { return uninitialized_blocks.count(compiled) > 0; } -bool code_heap::marked_p(code_block* compiled) { - return allocator->state.marked_p((cell)compiled); -} - -void code_heap::set_marked_p(code_block* compiled) { - allocator->state.set_marked_p((cell)compiled, compiled->size()); -} - void code_heap::free(code_block* compiled) { FACTOR_ASSERT(!uninitialized_p(compiled)); points_to_nursery.erase(compiled); diff --git a/vm/code_heap.hpp b/vm/code_heap.hpp index 1b9169f69e..4927a8c774 100644 --- a/vm/code_heap.hpp +++ b/vm/code_heap.hpp @@ -37,8 +37,6 @@ struct code_heap { void write_barrier(code_block* compiled); void clear_remembered_set(); bool uninitialized_p(code_block* compiled); - bool marked_p(code_block* compiled); - void set_marked_p(code_block* compiled); void free(code_block* compiled); void flush_icache(); void guard_safepoint(); diff --git a/vm/collector.hpp b/vm/collector.hpp index efab4cfb19..f90dd3279a 100644 --- a/vm/collector.hpp +++ b/vm/collector.hpp @@ -15,18 +15,26 @@ struct gc_workhorse : no_fixup { gc_workhorse(factor_vm* parent, TargetGeneration* target, Policy policy) : parent(parent), target(target), policy(policy), code(parent->code) {} - object* resolve_forwarding(object* untagged) { - parent->check_data_pointer(untagged); + object* fixup_data(object* obj) { + FACTOR_ASSERT((parent->current_gc && + parent->current_gc->op == collect_growing_heap_op) || + parent->data->seg->in_segment_p((cell)obj)); + if (!policy.should_copy_p(obj)) { + policy.visited_object(obj); + return obj; + } + + object* untagged = obj; /* is there another forwarding pointer? */ while (untagged->forwarding_pointer_p()) untagged = untagged->forwarding_pointer(); - /* we've found the destination */ - return untagged; - } + if (!policy.should_copy_p(untagged)) { + policy.visited_object(untagged); + return untagged; + } - object* promote_object(object* untagged) { cell size = untagged->size(); object* newpointer = target->allot(size); if (!newpointer) @@ -40,29 +48,9 @@ struct gc_workhorse : no_fixup { return newpointer; } - object* fixup_data(object* obj) { - parent->check_data_pointer(obj); - - if (!policy.should_copy_p(obj)) { - policy.visited_object(obj); - return obj; - } - - object* forwarding = resolve_forwarding(obj); - - if (forwarding == obj) - return promote_object(obj); - else if (policy.should_copy_p(forwarding)) - return promote_object(forwarding); - else { - policy.visited_object(forwarding); - return forwarding; - } - } - code_block* fixup_code(code_block* compiled) { - if (!code->marked_p(compiled)) { - code->set_marked_p(compiled); + if (!code->allocator->state.marked_p((cell)compiled)) { + code->allocator->state.set_marked_p((cell)compiled, compiled->size()); parent->mark_stack.push_back((cell)compiled + 1); } diff --git a/vm/debug.cpp b/vm/debug.cpp index 7d7312231e..3cba426dae 100644 --- a/vm/debug.cpp +++ b/vm/debug.cpp @@ -368,7 +368,7 @@ struct code_block_printer { reloc_size += parent->object_size(scan->relocation); parameter_size += parent->object_size(scan->parameters); - if (parent->code->marked_p(scan)) + if (parent->code->allocator->state.marked_p((cell)scan)) status = "marked"; else status = "allocated"; diff --git a/vm/fixup.hpp b/vm/fixup.hpp index fef1d6e2dc..f8fba0aaaa 100644 --- a/vm/fixup.hpp +++ b/vm/fixup.hpp @@ -1,9 +1,5 @@ namespace factor { -template struct identity { - T operator()(T t) { return t; } -}; - struct no_fixup { static const bool translated_code_block_map = false; diff --git a/vm/free_list_allocator.hpp b/vm/free_list_allocator.hpp index 57b132b06b..165a65591d 100644 --- a/vm/free_list_allocator.hpp +++ b/vm/free_list_allocator.hpp @@ -59,7 +59,7 @@ template Block* free_list_allocator::next_allocated_block_after(Block* block) { while ((cell)block != this->end && block->free_p()) { free_heap_block* free_block = (free_heap_block*)block; - block = (object*)((cell)free_block + free_block->size()); + block = (Block*)((cell)free_block + free_block->size()); } if ((cell)block == this->end) diff --git a/vm/full_collector.hpp b/vm/full_collector.hpp index 0e063532b4..80dd59a33b 100644 --- a/vm/full_collector.hpp +++ b/vm/full_collector.hpp @@ -12,12 +12,12 @@ struct full_policy { } void promoted_object(object* obj) { - tenured->set_marked_p(obj); + tenured->state.set_marked_p((cell)obj, obj->size()); parent->mark_stack.push_back((cell)obj); } void visited_object(object* obj) { - if (!tenured->marked_p(obj)) + if (!tenured->state.marked_p((cell)obj)) promoted_object(obj); } }; diff --git a/vm/tenured_space.hpp b/vm/tenured_space.hpp index cf501f2e89..33ed45df47 100644 --- a/vm/tenured_space.hpp +++ b/vm/tenured_space.hpp @@ -25,14 +25,6 @@ struct tenured_space : free_list_allocator { return (cell)next_allocated_block_after(next); } - bool marked_p(object* obj) { - return this->state.marked_p((cell)obj); - } - - void set_marked_p(object* obj) { - this->state.set_marked_p((cell)obj, obj->size()); - } - void sweep() { free_list_allocator::sweep(); starts.update_for_sweep(&this->state); diff --git a/vm/vm.hpp b/vm/vm.hpp index 5014aecfc8..4af8511d7d 100644 --- a/vm/vm.hpp +++ b/vm/vm.hpp @@ -382,11 +382,6 @@ struct factor_vm { return (Type*)allot_object(Type::type_number, size); } - inline void check_data_pointer(object* pointer) { - FACTOR_ASSERT((current_gc && current_gc->op == collect_growing_heap_op) || - data->seg->in_segment_p((cell)pointer)); - } - // generic arrays template Array* allot_uninitialized_array(cell capacity); template