vm/full_collector.cpp

   1 #include "master.hpp"
   2
   3 namespace factor
   4 {
   5
   6 full_collector::full_collector(factor_vm *parent_) :
   7         collector<tenured_space,full_policy>(
   8                 parent_,
   9                 parent_->data->tenured,
  10                 full_policy(parent_)) {}
  11
  12 /* After a sweep, invalidate any code heap roots which are not marked,
  13 so that if a block makes a tail call to a generic word, and the PIC
  14 compiler triggers a GC, and the caller block gets gets GCd as a result,
  15 the PIC code won't try to overwrite the call site */
  16 void factor_vm::update_code_roots_for_sweep()
  17 {
  18         std::vector<code_root *>::const_iterator iter = code_roots.begin();
  19         std::vector<code_root *>::const_iterator end = code_roots.end();
  20
  21         mark_bits<code_block> *state = &code->allocator->state;
  22
  23         for(; iter < end; iter++)
  24         {
  25                 code_root *root = *iter;
  26                 code_block *block = (code_block *)(root->value & -block_granularity);
  27                 if(root->valid && !state->marked_p(block))
  28                         root->valid = false;
  29         }
  30 }
  31
  32 /* After a compaction, invalidate any code heap roots which are not
  33 marked as above, and also slide the valid roots up so that call sites
  34 can be updated correctly. */
  35 void factor_vm::update_code_roots_for_compaction()
  36 {
  37         std::vector<code_root *>::const_iterator iter = code_roots.begin();
  38         std::vector<code_root *>::const_iterator end = code_roots.end();
  39
  40         mark_bits<code_block> *state = &code->allocator->state;
  41
  42         for(; iter < end; iter++)
  43         {
  44                 code_root *root = *iter;
  45                 code_block *block = (code_block *)(root->value & -block_granularity);
  46
  47                 /* Offset of return address within 16-byte allocation line */
  48                 cell offset = root->value - (cell)block;
  49
  50                 if(root->valid && state->marked_p((code_block *)root->value))
  51                 {
  52                         block = state->forward_block(block);
  53                         root->value = (cell)block + offset;
  54                 }
  55                 else
  56                         root->valid = false;
  57         }
  58 }
  59
  60 struct code_block_marker {
  61         code_heap *code;
  62         full_collector *collector;
  63
  64         explicit code_block_marker(code_heap *code_, full_collector *collector_) :
  65                 code(code_), collector(collector_) {}
  66
  67         code_block *operator()(code_block *compiled)
  68         {
  69                 if(!code->marked_p(compiled))
  70                 {
  71                         code->set_marked_p(compiled);
  72                         collector->trace_literal_references(compiled);
  73                 }
  74
  75                 return compiled;
  76         }
  77 };
  78
  79 void factor_vm::collect_mark_impl(bool trace_contexts_p)
  80 {
  81         full_collector collector(this);
  82
  83         code->clear_mark_bits();
  84         data->tenured->clear_mark_bits();
  85         data->tenured->clear_mark_stack();
  86
  87         code_block_visitor<code_block_marker> code_marker(this,code_block_marker(code,&collector));
  88
  89         collector.trace_roots();
  90         if(trace_contexts_p)
  91         {
  92                 collector.trace_contexts();
  93                 code_marker.visit_context_code_blocks();
  94                 code_marker.visit_callback_code_blocks();
  95         }
  96
  97         std::vector<object *> *mark_stack = &data->tenured->mark_stack;
  98
  99         while(!mark_stack->empty())
 100         {
 101                 object *obj = mark_stack->back();
 102                 mark_stack->pop_back();
 103                 collector.trace_object(obj);
 104                 code_marker.visit_object_code_block(obj);
 105         }
 106
 107         data->reset_generation(data->tenured);
 108         data->reset_generation(data->aging);
 109         data->reset_generation(&nursery);
 110         code->clear_remembered_set();
 111 }
 112
 113 void factor_vm::collect_sweep_impl()
 114 {
 115         current_gc->event->started_data_sweep();
 116         data->tenured->sweep();
 117         update_code_roots_for_sweep();
 118         current_gc->event->ended_data_sweep();
 119 }
 120
 121 void factor_vm::collect_full(bool trace_contexts_p)
 122 {
 123         collect_mark_impl(trace_contexts_p);
 124         collect_sweep_impl();
 125         if(data->tenured->largest_free_block() <= data->nursery->size + data->aging->size)
 126                 collect_compact_impl(trace_contexts_p);
 127         else
 128                 update_code_heap_words_and_literals();
 129 }
 130
 131 void factor_vm::collect_compact(bool trace_contexts_p)
 132 {
 133         collect_mark_impl(trace_contexts_p);
 134         collect_compact_impl(trace_contexts_p);
 135 }
 136
 137 void factor_vm::collect_growing_heap(cell requested_bytes, bool trace_contexts_p)
 138 {
 139         /* Grow the data heap and copy all live objects to the new heap. */
 140         data_heap *old = data;
 141         set_data_heap(data->grow(requested_bytes));
 142         collect_mark_impl(trace_contexts_p);
 143         collect_compact_code_impl(trace_contexts_p);
 144         delete old;
 145 }
 146
 147 }