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.

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,
+    gc_workhorse<tenured_space, to_tenured_policy>
-                                                          data->tenured,
+        workhorse(this, data->tenured, to_tenured_policy(this));
-                                                          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);
+    visitor.visit_cards(data->tenured, card_points_to_aging, 0xff);
-    if (event) {
+    if (event)
-      event->ended_card_scan(collector.visitor.cards_scanned,
+      event->ended_card_scan(visitor.cards_scanned, visitor.decks_scanned);
-                             collector.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,
+    aging_space *target = data->aging;
-                                                   data->aging,
+    gc_workhorse<aging_space, aging_policy>
-                                                   aging_policy(this));
+        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();
+    visitor.visit_all_roots();
-    collector.cheneys_algorithm();
+    visitor.cheneys_algorithm(target, scan);
 
     data->reset_nursery();
     code->clear_remembered_set();

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);
-    }
-  }
-};
-
 }

vm/full_collector.cpp

@@ -42,8 +42,7 @@ 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>>
-  slot_visitor<gc_workhorse<tenured_space, full_policy> >
       visitor(this, workhorse);
 
   mark_stack.clear();

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);
+  gc_workhorse<aging_space, nursery_policy>
-  collector<aging_space, nursery_policy>
+      workhorse(this, data->aging, nursery_policy(data->nursery));
-      collector(this, this->data->aging, policy);
+  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,
+  visitor.visit_cards(data->tenured, card_points_to_nursery,
                       card_points_to_nursery);
-  collector.visitor.visit_cards(data->aging, card_points_to_nursery, 0xff);
+  visitor.visit_cards(data->aging, card_points_to_nursery, 0xff);
-
+  if (event)
-  if (event) {
+    event->ended_card_scan(visitor.cards_scanned, visitor.decks_scanned);
-    event->ended_card_scan(collector.visitor.cards_scanned,
-                           collector.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();

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>
@@ -605,6 +606,15 @@ void slot_visitor<Fixup>::visit_code_heap_roots(std::set<code_block*>* remembere
     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);
   }
+}
 
 }

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,
+  gc_workhorse<tenured_space, to_tenured_policy>
-                                                        data->tenured,
+      workhorse(this, data->tenured, to_tenured_policy(this));
-                                                        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);
+  visitor.visit_cards(data->tenured, card_points_to_aging, 0xff);
-  if (event) {
+  if (event)
-    event->ended_card_scan(collector.visitor.cards_scanned,
+    event->ended_card_scan(visitor.cards_scanned, visitor.decks_scanned);
-                           collector.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();