VM: removes the collector class

The cheneys_algorithm() method can be moved to slot_visitor (because it
kind of visists objects), and then there is no need for the collector
class.

diff --git a/vm/aging_collector.cpp b/vm/aging_collector.cpp
index a7511466bd38cada9d18413c5fe030c3ab74dc5c..77b4a1645ce5d2348ce741a4f1c3588034111c6b 100644 (file)
--- a/vm/aging_collector.cpp
+++ b/vm/aging_collector.cpp
@@ -26,26 +26,26 @@ void factor_vm::collect_aging() {
        raised. */
     current_gc->op = collect_to_tenured_op;
 
-    collector<tenured_space, to_tenured_policy> collector(this,
-                                                          data->tenured,
-                                                          to_tenured_policy(this));
+    gc_workhorse<tenured_space, to_tenured_policy>
+        workhorse(this, data->tenured, to_tenured_policy(this));
+    slot_visitor<gc_workhorse<tenured_space, to_tenured_policy>>
+        visitor(this, workhorse);
+
     gc_event* event = current_gc->event;
 
     if (event)
       event->reset_timer();
-    collector.visitor.visit_cards(data->tenured, card_points_to_aging, 0xff);
-    if (event) {
-      event->ended_card_scan(collector.visitor.cards_scanned,
-                             collector.visitor.decks_scanned);
-    }
+    visitor.visit_cards(data->tenured, card_points_to_aging, 0xff);
+    if (event)
+      event->ended_card_scan(visitor.cards_scanned, visitor.decks_scanned);
 
     if (event)
       event->reset_timer();
-    collector.visitor.visit_code_heap_roots(&code->points_to_aging);
+    visitor.visit_code_heap_roots(&code->points_to_aging);
     if (event)
       event->ended_code_scan(code->points_to_aging.size());
 
-    collector.visitor.visit_mark_stack(&mark_stack);
+    visitor.visit_mark_stack(&mark_stack);
   }
   {
     /* If collection fails here, do a to_tenured collection. */
@@ -54,12 +54,15 @@ void factor_vm::collect_aging() {
     std::swap(data->aging, data->aging_semispace);
     data->reset_aging();
 
-    collector<aging_space, aging_policy> collector(this,
-                                                   data->aging,
-                                                   aging_policy(this));
+    aging_space *target = data->aging;
+    gc_workhorse<aging_space, aging_policy>
+        workhorse(this, target, aging_policy(this));
+    slot_visitor<gc_workhorse<aging_space, aging_policy>>
+        visitor(this, workhorse);
+    cell scan = target->start + target->occupied_space();
 
-    collector.visitor.visit_all_roots();
-    collector.cheneys_algorithm();
+    visitor.visit_all_roots();
+    visitor.cheneys_algorithm(target, scan);
 
     data->reset_nursery();
     code->clear_remembered_set();

diff --git a/vm/collector.hpp b/vm/collector.hpp
index 32719b5f2c751e7f310205417786ca02d92e93fc..f15479219d158c60a02a1d73367d5e91be8e0ea1 100644 (file)
--- a/vm/collector.hpp
+++ b/vm/collector.hpp
@@ -59,25 +59,4 @@ struct gc_workhorse : no_fixup {
   }
 };
 
-template <typename TargetGeneration, typename Policy> struct collector {
-  data_heap* data;
-  TargetGeneration* target;
-  slot_visitor<gc_workhorse<TargetGeneration, Policy> > visitor;
-  cell scan;
-
-  collector(factor_vm* parent, TargetGeneration* target, Policy policy)
-      : data(parent->data),
-        target(target),
-        visitor(parent, gc_workhorse<TargetGeneration, Policy>(parent, target, policy)) {
-    scan = target->start + target->occupied_space();
-  }
-
-  void cheneys_algorithm() {
-    while (scan && scan < this->target->here) {
-      this->visitor.visit_object((object*)scan);
-      scan = this->target->next_object_after(scan);
-    }
-  }
-};
-
 }

diff --git a/vm/full_collector.cpp b/vm/full_collector.cpp
index c815990b7c5953502f43567d7658dfecf7cef3fd..788f15c6ff439547c30e898bbf0f463e864e3370 100644 (file)
--- a/vm/full_collector.cpp
+++ b/vm/full_collector.cpp
@@ -42,9 +42,8 @@ void factor_vm::update_code_roots_for_sweep() {
 void factor_vm::collect_mark_impl() {
   gc_workhorse<tenured_space, full_policy>
       workhorse(this, this->data->tenured, full_policy(this));
-
-  slot_visitor<gc_workhorse<tenured_space, full_policy> >
-                visitor(this, workhorse);
+  slot_visitor<gc_workhorse<tenured_space, full_policy>>
+      visitor(this, workhorse);
 
   mark_stack.clear();
 

diff --git a/vm/nursery_collector.cpp b/vm/nursery_collector.cpp
index 2bd5515fbefe1ed684ac60e2a865244c619f0096..f86f6768bff6347b5b251e9fb5f9b4140a09cd47 100644 (file)
--- a/vm/nursery_collector.cpp
+++ b/vm/nursery_collector.cpp
@@ -20,31 +20,31 @@ 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_policy policy(this->data->nursery);
-  collector<aging_space, nursery_policy>
-      collector(this, this->data->aging, policy);
+  gc_workhorse<aging_space, nursery_policy>
+      workhorse(this, data->aging, nursery_policy(data->nursery));
+  slot_visitor<gc_workhorse<aging_space, nursery_policy>>
+      visitor(this, workhorse);
 
-  collector.visitor.visit_all_roots();
+  cell scan = data->aging->start + data->aging->occupied_space();
+
+  visitor.visit_all_roots();
   gc_event* event = current_gc->event;
 
   if (event)
     event->reset_timer();
-  collector.visitor.visit_cards(data->tenured, card_points_to_nursery,
-                                card_points_to_nursery);
-  collector.visitor.visit_cards(data->aging, card_points_to_nursery, 0xff);
-
-  if (event) {
-    event->ended_card_scan(collector.visitor.cards_scanned,
-                           collector.visitor.decks_scanned);
-  }
+  visitor.visit_cards(data->tenured, card_points_to_nursery,
+                      card_points_to_nursery);
+  visitor.visit_cards(data->aging, card_points_to_nursery, 0xff);
+  if (event)
+    event->ended_card_scan(visitor.cards_scanned, visitor.decks_scanned);
 
   if (event)
     event->reset_timer();
-  collector.visitor.visit_code_heap_roots(&code->points_to_nursery);
+  visitor.visit_code_heap_roots(&code->points_to_nursery);
   if (event)
     event->ended_code_scan(code->points_to_nursery.size());
 
-  collector.cheneys_algorithm();
+  visitor.cheneys_algorithm(data->aging, scan);
 
   data->reset_nursery();
   code->points_to_nursery.clear();

diff --git a/vm/slot_visitor.hpp b/vm/slot_visitor.hpp
index 2eb3aad98ca3df3a6bfdf1460538c1ca837ba867..96bc49dfdd9e0ab9b98ea491121c958ebea62f49 100644 (file)
--- a/vm/slot_visitor.hpp
+++ b/vm/slot_visitor.hpp
@@ -152,11 +152,12 @@ template <typename Fixup> struct slot_visitor {
 
   template <typename SourceGeneration>
   cell visit_card(SourceGeneration* gen, cell index, cell start);
-
   template <typename SourceGeneration>
   void visit_cards(SourceGeneration* gen, card mask, card unmask);
-
   void visit_code_heap_roots(std::set<code_block*>* remembered_set);
+
+  template <typename TargetGeneration>
+  void cheneys_algorithm(TargetGeneration* gen, cell scan);
 };
 
 template <typename Fixup>
@@ -599,12 +600,21 @@ void slot_visitor<Fixup>::visit_cards(SourceGeneration* gen,
 
 template <typename Fixup>
 void slot_visitor<Fixup>::visit_code_heap_roots(std::set<code_block*>* remembered_set) {
-    FACTOR_FOR_EACH(*remembered_set) {
-      code_block* compiled = *iter;
-      visit_code_block_objects(compiled);
-      visit_embedded_literals(compiled);
-      compiled->flush_icache();
-    }
+  FACTOR_FOR_EACH(*remembered_set) {
+    code_block* compiled = *iter;
+    visit_code_block_objects(compiled);
+    visit_embedded_literals(compiled);
+    compiled->flush_icache();
   }
+}
+
+template <typename Fixup>
+template <typename TargetGeneration>
+void slot_visitor<Fixup>::cheneys_algorithm(TargetGeneration* gen, cell scan) {
+  while (scan && scan < gen->here) {
+    visit_object((object*)scan);
+    scan = gen->next_object_after(scan);
+  }
+}
 
 }

diff --git a/vm/to_tenured_collector.cpp b/vm/to_tenured_collector.cpp
index d4b2b51d655b234936b93e47224b4eb4df5e6aad..6490984c6e43a2c978b5a984fa03c1a8dd2297d3 100644 (file)
--- a/vm/to_tenured_collector.cpp
+++ b/vm/to_tenured_collector.cpp
@@ -4,30 +4,29 @@ namespace factor {
 
 void factor_vm::collect_to_tenured() {
   /* Copy live objects from aging space to tenured space. */
-  collector<tenured_space, to_tenured_policy> collector(this,
-                                                        data->tenured,
-                                                        to_tenured_policy(this));
+  gc_workhorse<tenured_space, to_tenured_policy>
+      workhorse(this, data->tenured, to_tenured_policy(this));
+  slot_visitor<gc_workhorse<tenured_space, to_tenured_policy>>
+      visitor(this, workhorse);
 
   mark_stack.clear();
 
-  collector.visitor.visit_all_roots();
+  visitor.visit_all_roots();
   gc_event* event = current_gc->event;
 
   if (event)
     event->reset_timer();
-  collector.visitor.visit_cards(data->tenured, card_points_to_aging, 0xff);
-  if (event) {
-    event->ended_card_scan(collector.visitor.cards_scanned,
-                           collector.visitor.decks_scanned);
-  }
+  visitor.visit_cards(data->tenured, card_points_to_aging, 0xff);
+  if (event)
+    event->ended_card_scan(visitor.cards_scanned, visitor.decks_scanned);
 
   if (event)
     event->reset_timer();
-  collector.visitor.visit_code_heap_roots(&code->points_to_aging);
+  visitor.visit_code_heap_roots(&code->points_to_aging);
   if (event)
     event->ended_code_scan(code->points_to_aging.size());
 
-  collector.visitor.visit_mark_stack(&mark_stack);
+  visitor.visit_mark_stack(&mark_stack);
 
   data->reset_nursery();
   data->reset_aging();