VM: Refactor full_collector to Factor style

diff --git a/vm/full_collector.cpp b/vm/full_collector.cpp
index fad855301ea991f9e59f640d0abdf327ba21bcbf..e705a512766d5905d90e62a144918cf5a66c3f0a 100644 (file)
--- 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<tenured_space,full_policy>(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<tenured_space, full_policy>(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<code_root *>::const_iterator iter = code_roots.begin();
-       std::vector<code_root *>::const_iterator end = code_roots.end();
-
-       mark_bits<code_block> *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<code_root*>::const_iterator iter = code_roots.begin();
+  std::vector<code_root*>::const_iterator end = code_roots.end();
+
+  mark_bits<code_block>* 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 71c4f5334bbe019430cd70c71a7088213109af4d..3ba0719ff46bec192167efbc28854f907536d8ae 100644 (file)
--- 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<tenured_space,full_policy> {
-       code_block_visitor<gc_workhorse<tenured_space,full_policy> > code_visitor;
+struct full_collector : collector<tenured_space, full_policy> {
+  code_block_visitor<gc_workhorse<tenured_space, full_policy> > 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);
 };
 
 }