vm/full_collector.cpp

   1 #include "master.hpp"
   2
   3 namespace factor {
   4
   5 /* After a sweep, invalidate any code heap roots which are not marked,
   6    so that if a block makes a tail call to a generic word, and the PIC
   7    compiler triggers a GC, and the caller block gets GCd as a result,
   8    the PIC code won't try to overwrite the call site */
   9 void factor_vm::update_code_roots_for_sweep() {
  10   std::vector<code_root*>::const_iterator iter = code_roots.begin();
  11   std::vector<code_root*>::const_iterator end = code_roots.end();
  12
  13   mark_bits* state = &code->allocator->state;
  14
  15   for (; iter < end; iter++) {
  16     code_root* root = *iter;
  17     cell block = root->value & (~data_alignment - 1);
  18     if (root->valid && !state->marked_p(block))
  19       root->valid = false;
  20   }
  21 }
  22
  23 void factor_vm::collect_mark_impl() {
  24   gc_workhorse<tenured_space, full_policy>
  25       workhorse(this, this->data->tenured, full_policy(this));
  26
  27   slot_visitor<gc_workhorse<tenured_space, full_policy> >
  28                 visitor(this, workhorse);
  29
  30   mark_stack.clear();
  31
  32   code->allocator->state.clear_mark_bits();
  33   data->tenured->state.clear_mark_bits();
  34
  35   visitor.visit_all_roots();
  36   visitor.visit_context_code_blocks();
  37   visitor.visit_uninitialized_code_blocks();
  38
  39   while (!mark_stack.empty()) {
  40     cell ptr = mark_stack.back();
  41     mark_stack.pop_back();
  42
  43     if (ptr & 1) {
  44       code_block* compiled = (code_block*)(ptr - 1);
  45       visitor.visit_code_block_objects(compiled);
  46       visitor.visit_embedded_literals(compiled);
  47       visitor.visit_embedded_code_pointers(compiled);
  48     } else {
  49       object* obj = (object*)ptr;
  50       visitor.visit_slots(obj);
  51       if (obj->type() == ALIEN_TYPE)
  52         ((alien*)obj)->update_address();
  53       visitor.visit_object_code_block(obj);
  54     }
  55   }
  56   data->reset_tenured();
  57   data->reset_aging();
  58   data->reset_nursery();
  59   code->clear_remembered_set();
  60 }
  61
  62 void factor_vm::collect_sweep_impl() {
  63   gc_event* event = current_gc->event;
  64
  65   if (event)
  66     event->started_data_sweep();
  67   data->tenured->sweep();
  68   if (event)
  69     event->ended_data_sweep();
  70
  71   update_code_roots_for_sweep();
  72
  73   if (event)
  74     event->started_code_sweep();
  75   code->sweep();
  76   if (event)
  77     event->ended_code_sweep();
  78 }
  79
  80 void factor_vm::collect_full() {
  81   collect_mark_impl();
  82   collect_sweep_impl();
  83
  84   if (data->low_memory_p()) {
  85     /* Full GC did not free up enough memory. Grow the heap. */
  86     set_current_gc_op(collect_growing_heap_op);
  87     collect_growing_heap(0);
  88   } else if (data->high_fragmentation_p()) {
  89     /* Enough free memory, but it is not contiguous. Perform a
  90        compaction. */
  91     set_current_gc_op(collect_compact_op);
  92     collect_compact_impl();
  93   }
  94
  95   code->flush_icache();
  96 }
  97
  98 }