From: Erik Charlebois Date: Sun, 12 May 2013 02:02:39 +0000 (-0400) Subject: VM: Refactor full_collector to Factor style X-Git-Tag: 0.97~1291 X-Git-Url: https://gitweb.factorcode.org/gitweb.cgi?p=factor.git;a=commitdiff_plain;h=9e2d775095876462040f47c0cf30a7153ae12408 VM: Refactor full_collector to Factor style --- diff --git a/vm/full_collector.cpp b/vm/full_collector.cpp index fad855301e..e705a51276 100644 --- a/vm/full_collector.cpp +++ b/vm/full_collector.cpp @@ -1,130 +1,115 @@ #include "master.hpp" -namespace factor -{ - -full_collector::full_collector(factor_vm *parent_) : - collector(parent_,parent_->data->tenured,full_policy(parent_)), - code_visitor(parent,workhorse) {} - -void full_collector::trace_code_block(code_block *compiled) -{ - data_visitor.visit_code_block_objects(compiled); - data_visitor.visit_embedded_literals(compiled); - code_visitor.visit_embedded_code_pointers(compiled); -} +namespace factor { + +full_collector::full_collector(factor_vm* parent_) + : collector(parent_, parent_->data->tenured, + full_policy(parent_)), + code_visitor(parent, workhorse) {} -void full_collector::trace_context_code_blocks() -{ - code_visitor.visit_context_code_blocks(); +void full_collector::trace_code_block(code_block* compiled) { + data_visitor.visit_code_block_objects(compiled); + data_visitor.visit_embedded_literals(compiled); + code_visitor.visit_embedded_code_pointers(compiled); } -void full_collector::trace_code_roots() -{ - code_visitor.visit_code_roots(); +void full_collector::trace_context_code_blocks() { + code_visitor.visit_context_code_blocks(); } -void full_collector::trace_object_code_block(object *obj) -{ - code_visitor.visit_object_code_block(obj); +void full_collector::trace_code_roots() { code_visitor.visit_code_roots(); } + +void full_collector::trace_object_code_block(object* obj) { + code_visitor.visit_object_code_block(obj); } /* After a sweep, invalidate any code heap roots which are not marked, -so that if a block makes a tail call to a generic word, and the PIC -compiler triggers a GC, and the caller block gets gets GCd as a result, -the PIC code won't try to overwrite the call site */ -void factor_vm::update_code_roots_for_sweep() -{ - std::vector::const_iterator iter = code_roots.begin(); - std::vector::const_iterator end = code_roots.end(); - - mark_bits *state = &code->allocator->state; - - for(; iter < end; iter++) - { - code_root *root = *iter; - code_block *block = (code_block *)(root->value & (~data_alignment - 1)); - if(root->valid && !state->marked_p(block)) - root->valid = false; - } + so that if a block makes a tail call to a generic word, and the PIC + compiler triggers a GC, and the caller block gets gets GCd as a result, + the PIC code won't try to overwrite the call site */ +void factor_vm::update_code_roots_for_sweep() { + std::vector::const_iterator iter = code_roots.begin(); + std::vector::const_iterator end = code_roots.end(); + + mark_bits* state = &code->allocator->state; + + for (; iter < end; iter++) { + code_root* root = *iter; + code_block* block = (code_block*)(root->value & (~data_alignment - 1)); + if (root->valid && !state->marked_p(block)) + root->valid = false; + } } -void factor_vm::collect_mark_impl(bool trace_contexts_p) -{ - full_collector collector(this); - - mark_stack.clear(); - - code->clear_mark_bits(); - data->tenured->clear_mark_bits(); - - collector.trace_roots(); - if(trace_contexts_p) - { - collector.trace_contexts(); - collector.trace_context_code_blocks(); - collector.trace_code_roots(); - } - - while(!mark_stack.empty()) - { - cell ptr = mark_stack.back(); - mark_stack.pop_back(); - - if(ptr & 1) - { - code_block *compiled = (code_block *)(ptr - 1); - collector.trace_code_block(compiled); - } - else - { - object *obj = (object *)ptr; - collector.trace_object(obj); - collector.trace_object_code_block(obj); - } - } - - data->reset_generation(data->tenured); - data->reset_generation(data->aging); - data->reset_generation(&nursery); - code->clear_remembered_set(); +void factor_vm::collect_mark_impl(bool trace_contexts_p) { + full_collector collector(this); + + mark_stack.clear(); + + code->clear_mark_bits(); + data->tenured->clear_mark_bits(); + + collector.trace_roots(); + if (trace_contexts_p) { + collector.trace_contexts(); + collector.trace_context_code_blocks(); + collector.trace_code_roots(); + } + + while (!mark_stack.empty()) { + cell ptr = mark_stack.back(); + mark_stack.pop_back(); + + if (ptr & 1) { + code_block* compiled = (code_block*)(ptr - 1); + collector.trace_code_block(compiled); + } else { + object* obj = (object*)ptr; + collector.trace_object(obj); + collector.trace_object_code_block(obj); + } + } + + data->reset_generation(data->tenured); + data->reset_generation(data->aging); + data->reset_generation(&nursery); + code->clear_remembered_set(); } -void factor_vm::collect_sweep_impl() -{ - gc_event *event = current_gc->event; +void factor_vm::collect_sweep_impl() { + gc_event* event = current_gc->event; - if(event) event->started_data_sweep(); - data->tenured->sweep(); - if(event) event->ended_data_sweep(); + if (event) + event->started_data_sweep(); + data->tenured->sweep(); + if (event) + event->ended_data_sweep(); - update_code_roots_for_sweep(); + update_code_roots_for_sweep(); - if(event) event->started_code_sweep(); - code->sweep(); - if(event) event->ended_code_sweep(); + if (event) + event->started_code_sweep(); + code->sweep(); + if (event) + event->ended_code_sweep(); } -void factor_vm::collect_full(bool trace_contexts_p) -{ - collect_mark_impl(trace_contexts_p); - collect_sweep_impl(); - - if(data->low_memory_p()) - { - /* Full GC did not free up enough memory. Grow the heap. */ - set_current_gc_op(collect_growing_heap_op); - collect_growing_heap(0,trace_contexts_p); - } - else if(data->high_fragmentation_p()) - { - /* Enough free memory, but it is not contiguous. Perform a - compaction. */ - set_current_gc_op(collect_compact_op); - collect_compact_impl(trace_contexts_p); - } - - code->flush_icache(); +void factor_vm::collect_full(bool trace_contexts_p) { + collect_mark_impl(trace_contexts_p); + collect_sweep_impl(); + + if (data->low_memory_p()) { + /* Full GC did not free up enough memory. Grow the heap. */ + set_current_gc_op(collect_growing_heap_op); + collect_growing_heap(0, trace_contexts_p); + } else if (data->high_fragmentation_p()) { + /* Enough free memory, but it is not contiguous. Perform a + compaction. */ + set_current_gc_op(collect_compact_op); + collect_compact_impl(trace_contexts_p); + } + + code->flush_icache(); } } diff --git a/vm/full_collector.hpp b/vm/full_collector.hpp index 71c4f5334b..3ba0719ff4 100644 --- a/vm/full_collector.hpp +++ b/vm/full_collector.hpp @@ -1,38 +1,35 @@ -namespace factor -{ +namespace factor { struct full_policy { - factor_vm *parent; - tenured_space *tenured; - - explicit full_policy(factor_vm *parent_) : parent(parent_), tenured(parent->data->tenured) {} - - bool should_copy_p(object *untagged) - { - return !tenured->contains_p(untagged); - } - - void promoted_object(object *obj) - { - tenured->set_marked_p(obj); - parent->mark_stack.push_back((cell)obj); - } - - void visited_object(object *obj) - { - if(!tenured->marked_p(obj)) - promoted_object(obj); - } + factor_vm* parent; + tenured_space* tenured; + + explicit full_policy(factor_vm* parent_) + : parent(parent_), tenured(parent->data->tenured) {} + + bool should_copy_p(object* untagged) { + return !tenured->contains_p(untagged); + } + + void promoted_object(object* obj) { + tenured->set_marked_p(obj); + parent->mark_stack.push_back((cell) obj); + } + + void visited_object(object* obj) { + if (!tenured->marked_p(obj)) + promoted_object(obj); + } }; -struct full_collector : collector { - code_block_visitor > code_visitor; +struct full_collector : collector { + code_block_visitor > code_visitor; - explicit full_collector(factor_vm *parent_); - void trace_code_block(code_block *compiled); - void trace_context_code_blocks(); - void trace_code_roots(); - void trace_object_code_block(object *obj); + explicit full_collector(factor_vm* parent_); + void trace_code_block(code_block* compiled); + void trace_context_code_blocks(); + void trace_code_roots(); + void trace_object_code_block(object* obj); }; }