VM: merge of slot_visitor and code_block_visitor

Looks like there is no reason for them to be separate classes and by
merging them you can simplify lots of code.

diff --git a/GNUmakefile b/GNUmakefile
index 4c3b1ccb2e4bb44ba0ba7d33714839149bdb5ec2..760c0d59c9faeae02f6dbc000060b3a71a8823d2 100644 (file)
--- a/GNUmakefile
+++ b/GNUmakefile
@@ -118,7 +118,6 @@ ifdef CONFIG
                vm/nursery_collector.hpp \
                vm/aging_collector.hpp \
                vm/to_tenured_collector.hpp \
-               vm/code_block_visitor.hpp \
                vm/full_collector.hpp \
                vm/arrays.hpp \
                vm/math.hpp \

diff --git a/vm/code_block_visitor.hpp b/vm/code_block_visitor.hpp
deleted file mode 100644 (file)
index 8cd7dab..0000000
--- a/vm/code_block_visitor.hpp
+++ /dev/null
@@ -1,122 +0,0 @@
-namespace factor {
-
-/* Code block visitors iterate over sets of code blocks, applying a functor to
-each one. The functor returns a new code_block pointer, which may or may not
-equal the old one. This is stored back to the original location.
-
-This is used by GC's sweep and compact phases, and the implementation of the
-modify-code-heap primitive.
-
-Iteration is driven by visit_*() methods. Some of them define GC roots:
-- visit_context_code_blocks()
-- visit_callback_code_blocks() */
-
-template <typename Fixup> struct code_block_visitor {
-  factor_vm* parent;
-  Fixup fixup;
-
-  code_block_visitor(factor_vm* parent, Fixup fixup)
-      : parent(parent), fixup(fixup) {}
-
-  code_block* visit_code_block(code_block* compiled);
-  void visit_object_code_block(object* obj);
-  void visit_embedded_code_pointers(code_block* compiled);
-  void visit_context_code_blocks();
-  void visit_uninitialized_code_blocks();
-};
-
-template <typename Fixup>
-code_block* code_block_visitor<Fixup>::visit_code_block(code_block* compiled) {
-  return fixup.fixup_code(compiled);
-}
-
-template <typename Fixup> struct call_frame_code_block_visitor {
-  factor_vm* parent;
-  Fixup fixup;
-
-  call_frame_code_block_visitor(factor_vm* parent, Fixup fixup)
-      : parent(parent), fixup(fixup) {}
-
-  void operator()(cell frame_top, cell size, code_block* owner, cell addr) {
-    code_block* compiled =
-        Fixup::translated_code_block_map ? owner : fixup.fixup_code(owner);
-    cell fixed_addr = compiled->address_for_offset(owner->offset(addr));
-
-    *(cell*)frame_top = fixed_addr;
-  }
-};
-
-template <typename Fixup>
-void code_block_visitor<Fixup>::visit_object_code_block(object* obj) {
-  switch (obj->type()) {
-    case WORD_TYPE: {
-      word* w = (word*)obj;
-      if (w->entry_point)
-        w->entry_point = visit_code_block(w->code())->entry_point();
-      break;
-    }
-    case QUOTATION_TYPE: {
-      quotation* q = (quotation*)obj;
-      if (q->entry_point)
-        q->entry_point = visit_code_block(q->code())->entry_point();
-      break;
-    }
-    case CALLSTACK_TYPE: {
-      callstack* stack = (callstack*)obj;
-      call_frame_code_block_visitor<Fixup> call_frame_visitor(parent, fixup);
-      parent->iterate_callstack_object(stack, call_frame_visitor, fixup);
-      break;
-    }
-  }
-}
-
-template <typename Fixup> struct embedded_code_pointers_visitor {
-  Fixup fixup;
-
-  explicit embedded_code_pointers_visitor(Fixup fixup) : fixup(fixup) {}
-
-  void operator()(instruction_operand op) {
-    relocation_type type = op.rel_type();
-    if (type == RT_ENTRY_POINT || type == RT_ENTRY_POINT_PIC ||
-        type == RT_ENTRY_POINT_PIC_TAIL)
-      op.store_code_block(fixup.fixup_code(op.load_code_block()));
-  }
-};
-
-template <typename Fixup>
-void code_block_visitor<Fixup>::visit_embedded_code_pointers(
-    code_block* compiled) {
-  if (!parent->code->uninitialized_p(compiled)) {
-    embedded_code_pointers_visitor<Fixup> operand_visitor(fixup);
-    compiled->each_instruction_operand(operand_visitor);
-  }
-}
-
-template <typename Fixup>
-void code_block_visitor<Fixup>::visit_context_code_blocks() {
-  call_frame_code_block_visitor<Fixup> call_frame_visitor(parent, fixup);
-  std::set<context*>::const_iterator begin = parent->active_contexts.begin();
-  std::set<context*>::const_iterator end = parent->active_contexts.end();
-  while (begin != end) {
-    parent->iterate_callstack(*begin++, call_frame_visitor, fixup);
-  }
-}
-
-template <typename Fixup>
-void code_block_visitor<Fixup>::visit_uninitialized_code_blocks() {
-  std::map<code_block*, cell>* uninitialized_blocks =
-      &parent->code->uninitialized_blocks;
-  std::map<code_block*, cell>::const_iterator iter =
-      uninitialized_blocks->begin();
-  std::map<code_block*, cell>::const_iterator end = uninitialized_blocks->end();
-
-  std::map<code_block*, cell> new_uninitialized_blocks;
-  for (; iter != end; iter++) {
-    new_uninitialized_blocks.insert(
-        std::make_pair(fixup.fixup_code(iter->first), iter->second));
-  }
-
-  parent->code->uninitialized_blocks = new_uninitialized_blocks;
-}
-
-}

diff --git a/vm/compaction.cpp b/vm/compaction.cpp
index b5104c5eb19d5bcc469d328ff0332092b665165a..ce5e707f6a58ac69aeb632da38f979503c9aa695 100644 (file)
--- a/vm/compaction.cpp
+++ b/vm/compaction.cpp
@@ -67,12 +67,9 @@ struct object_compaction_updater {
         starts(&parent->data->tenured->starts) {}
 
   void operator()(object* old_address, object* new_address, cell size) {
-    slot_visitor<compaction_fixup> slot_forwarder(parent, fixup);
-    slot_forwarder.visit_slots(new_address);
-
-    code_block_visitor<compaction_fixup> code_forwarder(parent, fixup);
-    code_forwarder.visit_object_code_block(new_address);
-
+    slot_visitor<compaction_fixup> forwarder(parent, fixup);
+    forwarder.visit_slots(new_address);
+    forwarder.visit_object_code_block(new_address);
     starts->record_object_start_offset(new_address);
   }
 };
@@ -125,19 +122,16 @@ template <typename Fixup> struct code_block_compaction_relocation_visitor {
 template <typename Fixup> struct code_block_compaction_updater {
   factor_vm* parent;
   Fixup fixup;
-  slot_visitor<Fixup> data_forwarder;
-  code_block_visitor<Fixup> code_forwarder;
+  slot_visitor<Fixup> forwarder;
 
   code_block_compaction_updater(
-      factor_vm* parent, Fixup fixup, slot_visitor<Fixup> data_forwarder,
-      code_block_visitor<Fixup> code_forwarder)
+      factor_vm* parent, Fixup fixup, slot_visitor<Fixup> forwarder)
       : parent(parent),
         fixup(fixup),
-        data_forwarder(data_forwarder),
-        code_forwarder(code_forwarder) {}
+        forwarder(forwarder) { }
 
   void operator()(code_block* old_address, code_block* new_address, cell size) {
-    data_forwarder.visit_code_block_objects(new_address);
+    forwarder.visit_code_block_objects(new_address);
 
     code_block_compaction_relocation_visitor<Fixup> visitor(parent, old_address,
                                                             fixup);
@@ -195,10 +189,9 @@ void factor_vm::collect_compact_impl(bool trace_contexts_p) {
     compaction_fixup fixup(data_forwarding_map, code_forwarding_map, &data_finger,
                            &code_finger);
 
-    slot_visitor<compaction_fixup> data_forwarder(this, fixup);
-    code_block_visitor<compaction_fixup> code_forwarder(this, fixup);
+    slot_visitor<compaction_fixup> forwarder(this, fixup);
 
-    code_forwarder.visit_uninitialized_code_blocks();
+    forwarder.visit_uninitialized_code_blocks();
 
     /* Object start offsets get recomputed by the object_compaction_updater */
     data->tenured->starts.clear_object_start_offsets();
@@ -214,14 +207,14 @@ void factor_vm::collect_compact_impl(bool trace_contexts_p) {
        pointers inside code blocks. */
     {
       code_block_compaction_updater<compaction_fixup> code_block_updater(
-          this, fixup, data_forwarder, code_forwarder);
+          this, fixup, forwarder);
       code->allocator->compact(code_block_updater, fixup, &code_finger);
     }
 
-    data_forwarder.visit_roots();
+    forwarder.visit_roots();
     if (trace_contexts_p) {
-      data_forwarder.visit_contexts();
-      code_forwarder.visit_context_code_blocks();
+      forwarder.visit_contexts();
+      forwarder.visit_context_code_blocks();
     }
   }
 
@@ -270,13 +263,13 @@ struct code_compaction_fixup {
 };
 
 struct object_grow_heap_updater {
-  code_block_visitor<code_compaction_fixup> code_forwarder;
+  slot_visitor<code_compaction_fixup> forwarder;
 
   explicit object_grow_heap_updater(
-      code_block_visitor<code_compaction_fixup> code_forwarder)
-      : code_forwarder(code_forwarder) {}
+      slot_visitor<code_compaction_fixup> forwarder)
+      : forwarder(forwarder) {}
 
-  void operator()(object* obj) { code_forwarder.visit_object_code_block(obj); }
+  void operator()(object* obj) { forwarder.visit_object_code_block(obj); }
 };
 
 /* Compact just the code heap, after growing the data heap */
@@ -288,22 +281,21 @@ void factor_vm::collect_compact_code_impl(bool trace_contexts_p) {
   const code_block* code_finger = (code_block*)code->allocator->start;
 
   code_compaction_fixup fixup(code_forwarding_map, &code_finger);
-  slot_visitor<code_compaction_fixup> data_forwarder(this, fixup);
-  code_block_visitor<code_compaction_fixup> code_forwarder(this, fixup);
+  slot_visitor<code_compaction_fixup> forwarder(this, fixup);
 
-  code_forwarder.visit_uninitialized_code_blocks();
+  forwarder.visit_uninitialized_code_blocks();
 
   if (trace_contexts_p)
-    code_forwarder.visit_context_code_blocks();
+    forwarder.visit_context_code_blocks();
 
   /* Update code heap references in data heap */
-  object_grow_heap_updater object_updater(code_forwarder);
+  object_grow_heap_updater object_updater(forwarder);
   each_object(object_updater);
 
   /* Slide everything in the code heap up, and update code heap
        pointers inside code blocks. */
   code_block_compaction_updater<code_compaction_fixup> code_block_updater(
-      this, fixup, data_forwarder, code_forwarder);
+      this, fixup, forwarder);
   code->allocator->compact(code_block_updater, fixup, &code_finger);
 
   update_code_roots_for_compaction();

diff --git a/vm/full_collector.cpp b/vm/full_collector.cpp
index 736974b67e31d672c48b748a9bd5a81acf29a035..22ee3577bcce0483a1db8a60e28aadcb13cfd0ea 100644 (file)
--- a/vm/full_collector.cpp
+++ b/vm/full_collector.cpp
@@ -25,21 +25,18 @@ void factor_vm::collect_mark_impl(bool trace_contexts_p) {
       workhorse(this, this->data->tenured, full_policy(this));
 
   slot_visitor<gc_workhorse<tenured_space, full_policy> >
-                data_visitor(this, workhorse);
-
-  code_block_visitor<gc_workhorse<tenured_space, full_policy> >
-                code_visitor(this, workhorse);
+                visitor(this, workhorse);
 
   mark_stack.clear();
 
   code->allocator->state.clear_mark_bits();
   data->tenured->state.clear_mark_bits();
 
-  data_visitor.visit_roots();
+  visitor.visit_roots();
   if (trace_contexts_p) {
-    data_visitor.visit_contexts();
-    code_visitor.visit_context_code_blocks();
-    code_visitor.visit_uninitialized_code_blocks();
+    visitor.visit_contexts();
+    visitor.visit_context_code_blocks();
+    visitor.visit_uninitialized_code_blocks();
   }
 
   while (!mark_stack.empty()) {
@@ -48,15 +45,15 @@ void factor_vm::collect_mark_impl(bool trace_contexts_p) {
 
     if (ptr & 1) {
       code_block* compiled = (code_block*)(ptr - 1);
-      data_visitor.visit_code_block_objects(compiled);
-      data_visitor.visit_embedded_literals(compiled);
-      code_visitor.visit_embedded_code_pointers(compiled);
+      visitor.visit_code_block_objects(compiled);
+      visitor.visit_embedded_literals(compiled);
+      visitor.visit_embedded_code_pointers(compiled);
     } else {
       object* obj = (object*)ptr;
-      data_visitor.visit_slots(obj);
+      visitor.visit_slots(obj);
       if (obj->type() == ALIEN_TYPE)
         ((alien*)obj)->update_address();
-      code_visitor.visit_object_code_block(obj);
+      visitor.visit_object_code_block(obj);
     }
   }
   data->reset_tenured();

diff --git a/vm/image.cpp b/vm/image.cpp
index bd76915c6ff6cd188270abec510b8f065b0d5e60..87b82e14e915d3ad6aae2cc4b82e36393c40fc0b 100644 (file)
--- a/vm/image.cpp
+++ b/vm/image.cpp
@@ -80,19 +80,17 @@ struct startup_fixup {
 struct start_object_updater {
   factor_vm* parent;
   startup_fixup fixup;
-  slot_visitor<startup_fixup> data_visitor;
-  code_block_visitor<startup_fixup> code_visitor;
+  slot_visitor<startup_fixup> visitor;
 
   start_object_updater(factor_vm* parent, startup_fixup fixup)
       : parent(parent),
         fixup(fixup),
-        data_visitor(slot_visitor<startup_fixup>(parent, fixup)),
-        code_visitor(code_block_visitor<startup_fixup>(parent, fixup)) {}
+        visitor(slot_visitor<startup_fixup>(parent, fixup)) { }
 
   void operator()(object* obj, cell size) {
     parent->data->tenured->starts.record_object_start_offset(obj);
 
-    data_visitor.visit_slots(obj);
+    visitor.visit_slots(obj);
 
     switch (obj->type()) {
       case ALIEN_TYPE: {
@@ -110,7 +108,7 @@ struct start_object_updater {
         break;
       }
       default: {
-        code_visitor.visit_object_code_block(obj);
+        visitor.visit_object_code_block(obj);
         break;
       }
     }

diff --git a/vm/master.hpp b/vm/master.hpp
index 01c7e7aa0d23822f0ebded399a695a76d08333c9..21bf6c0d5ed7ddcd747a85ebbbb4ff70b193ed9f 100644 (file)
--- a/vm/master.hpp
+++ b/vm/master.hpp
@@ -137,7 +137,6 @@ namespace factor { struct factor_vm; }
 #include "nursery_collector.hpp"
 #include "aging_collector.hpp"
 #include "to_tenured_collector.hpp"
-#include "code_block_visitor.hpp"
 #include "full_collector.hpp"
 #include "arrays.hpp"
 #include "math.hpp"

diff --git a/vm/slot_visitor.hpp b/vm/slot_visitor.hpp
index dd618fbb567e21c9689940ed2418721ecbac880c..a980666f9e72dd6cc66a4cd33a148a3efc095772 100644 (file)
--- a/vm/slot_visitor.hpp
+++ b/vm/slot_visitor.hpp
@@ -103,7 +103,18 @@ of the become primitive.
 
 Iteration is driven by visit_*() methods. Some of them define GC roots:
 - visit_roots()
-- visit_contexts() */
+- visit_contexts()
+
+Code block visitors iterate over sets of code blocks, applying a functor to
+each one. The functor returns a new code_block pointer, which may or may not
+equal the old one. This is stored back to the original location.
+
+This is used by GC's sweep and compact phases, and the implementation of the
+modify-code-heap primitive.
+
+Iteration is driven by visit_*() methods. Some of them define GC roots:
+- visit_context_code_blocks()
+- visit_callback_code_blocks() */
 
 template <typename Fixup> struct slot_visitor {
   factor_vm* parent;
@@ -130,6 +141,10 @@ template <typename Fixup> struct slot_visitor {
   void visit_embedded_literals(code_block* compiled);
   void visit_sample_callstacks();
   void visit_sample_threads();
+  void visit_object_code_block(object* obj);
+  void visit_context_code_blocks();
+  void visit_uninitialized_code_blocks();
+  void visit_embedded_code_pointers(code_block* compiled);
 };
 
 template <typename Fixup>
@@ -431,4 +446,92 @@ void slot_visitor<Fixup>::visit_embedded_literals(code_block* compiled) {
   }
 }
 
+template <typename Fixup> struct call_frame_code_block_visitor {
+  factor_vm* parent;
+  Fixup fixup;
+
+  call_frame_code_block_visitor(factor_vm* parent, Fixup fixup)
+      : parent(parent), fixup(fixup) {}
+
+  void operator()(cell frame_top, cell size, code_block* owner, cell addr) {
+    code_block* compiled =
+        Fixup::translated_code_block_map ? owner : fixup.fixup_code(owner);
+    cell fixed_addr = compiled->address_for_offset(owner->offset(addr));
+
+    *(cell*)frame_top = fixed_addr;
+  }
+};
+
+template <typename Fixup>
+void slot_visitor<Fixup>::visit_object_code_block(object* obj) {
+  switch (obj->type()) {
+    case WORD_TYPE: {
+      word* w = (word*)obj;
+      if (w->entry_point)
+        w->entry_point = fixup.fixup_code(w->code())->entry_point();
+      break;
+    }
+    case QUOTATION_TYPE: {
+      quotation* q = (quotation*)obj;
+      if (q->entry_point)
+        q->entry_point = fixup.fixup_code(q->code())->entry_point();
+      break;
+    }
+    case CALLSTACK_TYPE: {
+      callstack* stack = (callstack*)obj;
+      call_frame_code_block_visitor<Fixup> call_frame_visitor(parent, fixup);
+      parent->iterate_callstack_object(stack, call_frame_visitor, fixup);
+      break;
+    }
+  }
+}
+
+template <typename Fixup>
+void slot_visitor<Fixup>::visit_context_code_blocks() {
+  call_frame_code_block_visitor<Fixup> call_frame_visitor(parent, fixup);
+  std::set<context*>::const_iterator begin = parent->active_contexts.begin();
+  std::set<context*>::const_iterator end = parent->active_contexts.end();
+  while (begin != end) {
+    parent->iterate_callstack(*begin++, call_frame_visitor, fixup);
+  }
+}
+
+template <typename Fixup>
+void slot_visitor<Fixup>::visit_uninitialized_code_blocks() {
+  std::map<code_block*, cell>* uninitialized_blocks =
+      &parent->code->uninitialized_blocks;
+  std::map<code_block*, cell>::const_iterator iter =
+      uninitialized_blocks->begin();
+  std::map<code_block*, cell>::const_iterator end = uninitialized_blocks->end();
+
+  std::map<code_block*, cell> new_uninitialized_blocks;
+  for (; iter != end; iter++) {
+    new_uninitialized_blocks.insert(
+        std::make_pair(fixup.fixup_code(iter->first), iter->second));
+  }
+
+  parent->code->uninitialized_blocks = new_uninitialized_blocks;
+}
+
+template <typename Fixup> struct embedded_code_pointers_visitor {
+  Fixup fixup;
+
+  explicit embedded_code_pointers_visitor(Fixup fixup) : fixup(fixup) {}
+
+  void operator()(instruction_operand op) {
+    relocation_type type = op.rel_type();
+    if (type == RT_ENTRY_POINT || type == RT_ENTRY_POINT_PIC ||
+        type == RT_ENTRY_POINT_PIC_TAIL)
+      op.store_code_block(fixup.fixup_code(op.load_code_block()));
+  }
+};
+
+template <typename Fixup>
+void slot_visitor<Fixup>::visit_embedded_code_pointers(code_block* compiled) {
+  if (!parent->code->uninitialized_p(compiled)) {
+    embedded_code_pointers_visitor<Fixup> operand_visitor(fixup);
+    compiled->each_instruction_operand(operand_visitor);
+  }
+}
+
 }