vm/gc.cpp

   1 #include "master.hpp"
   2
   3 namespace factor
   4 {
   5
   6 gc_state::gc_state(gc_op op_) : op(op_), start_time(current_micros()) {}
   7
   8 gc_state::~gc_state() {}
   9
  10 void factor_vm::update_code_heap_for_minor_gc(std::set<code_block *> *remembered_set)
  11 {
  12         /* The youngest generation that any code block can now reference */
  13         std::set<code_block *>::const_iterator iter = remembered_set->begin();
  14         std::set<code_block *>::const_iterator end = remembered_set->end();
  15
  16         for(; iter != end; iter++) update_literal_references(*iter);
  17 }
  18
  19 void factor_vm::record_gc_stats(generation_statistics *stats)
  20 {
  21         cell gc_elapsed = (current_micros() - current_gc->start_time);
  22         stats->collections++;
  23         stats->gc_time += gc_elapsed;
  24         if(stats->max_gc_time < gc_elapsed)
  25                 stats->max_gc_time = gc_elapsed;
  26 }
  27
  28 void factor_vm::gc(gc_op op,
  29         cell requested_bytes,
  30         bool trace_contexts_p,
  31         bool compact_code_heap_p)
  32 {
  33         assert(!gc_off);
  34         assert(!current_gc);
  35
  36         save_stacks();
  37
  38         current_gc = new gc_state(op);
  39
  40         /* Keep trying to GC higher and higher generations until we don't run out
  41         of space */
  42         if(setjmp(current_gc->gc_unwind))
  43         {
  44                 /* We come back here if a generation is full */
  45                 switch(current_gc->op)
  46                 {
  47                 case collect_nursery_op:
  48                         current_gc->op = collect_aging_op;
  49                         break;
  50                 case collect_aging_op:
  51                         current_gc->op = collect_to_tenured_op;
  52                         break;
  53                 case collect_to_tenured_op:
  54                         current_gc->op = collect_full_op;
  55                         break;
  56                 case collect_full_op:
  57                         current_gc->op = collect_growing_heap_op;
  58                         break;
  59                 default:
  60                         critical_error("Bad GC op\n",op);
  61                         break;
  62                 }
  63         }
  64
  65         switch(current_gc->op)
  66         {
  67         case collect_nursery_op:
  68                 collect_nursery();
  69                 record_gc_stats(&gc_stats.nursery_stats);
  70                 break;
  71         case collect_aging_op:
  72                 collect_aging();
  73                 record_gc_stats(&gc_stats.aging_stats);
  74                 break;
  75         case collect_to_tenured_op:
  76                 collect_to_tenured();
  77                 record_gc_stats(&gc_stats.aging_stats);
  78                 break;
  79         case collect_full_op:
  80                 collect_full(trace_contexts_p,compact_code_heap_p);
  81                 record_gc_stats(&gc_stats.full_stats);
  82                 break;
  83         case collect_growing_heap_op:
  84                 collect_growing_heap(requested_bytes,trace_contexts_p,compact_code_heap_p);
  85                 record_gc_stats(&gc_stats.full_stats);
  86                 break;
  87         default:
  88                 critical_error("Bad GC op\n",op);
  89                 break;
  90         }
  91
  92         delete current_gc;
  93         current_gc = NULL;
  94 }
  95
  96 void factor_vm::primitive_minor_gc()
  97 {
  98         gc(collect_nursery_op,
  99                 0, /* requested size */
 100                 true, /* trace contexts? */
 101                 false /* compact code heap? */);
 102 }
 103
 104 void factor_vm::primitive_full_gc()
 105 {
 106         gc(collect_full_op,
 107                 0, /* requested size */
 108                 true, /* trace contexts? */
 109                 false /* compact code heap? */);
 110 }
 111
 112 void factor_vm::primitive_compact_gc()
 113 {
 114         gc(collect_full_op,
 115                 0, /* requested size */
 116                 true, /* trace contexts? */
 117                 true /* compact code heap? */);
 118 }
 119
 120 void factor_vm::add_gc_stats(generation_statistics *stats, growable_array *result)
 121 {
 122         result->add(allot_cell(stats->collections));
 123         result->add(tag<bignum>(long_long_to_bignum(stats->gc_time)));
 124         result->add(tag<bignum>(long_long_to_bignum(stats->max_gc_time)));
 125         result->add(allot_cell(stats->collections == 0 ? 0 : stats->gc_time / stats->collections));
 126         result->add(allot_cell(stats->object_count));
 127         result->add(tag<bignum>(long_long_to_bignum(stats->bytes_copied)));
 128 }
 129
 130 void factor_vm::primitive_gc_stats()
 131 {
 132         growable_array result(this);
 133
 134         add_gc_stats(&gc_stats.nursery_stats,&result);
 135         add_gc_stats(&gc_stats.aging_stats,&result);
 136         add_gc_stats(&gc_stats.full_stats,&result);
 137
 138         u64 total_gc_time =
 139                 gc_stats.nursery_stats.gc_time +
 140                 gc_stats.aging_stats.gc_time +
 141                 gc_stats.full_stats.gc_time;
 142
 143         result.add(tag<bignum>(ulong_long_to_bignum(total_gc_time)));
 144         result.add(tag<bignum>(ulong_long_to_bignum(gc_stats.cards_scanned)));
 145         result.add(tag<bignum>(ulong_long_to_bignum(gc_stats.decks_scanned)));
 146         result.add(tag<bignum>(ulong_long_to_bignum(gc_stats.card_scan_time)));
 147         result.add(allot_cell(gc_stats.code_blocks_scanned));
 148
 149         result.trim();
 150         dpush(result.elements.value());
 151 }
 152
 153 void factor_vm::clear_gc_stats()
 154 {
 155         memset(&gc_stats,0,sizeof(gc_statistics));
 156 }
 157
 158 void factor_vm::primitive_clear_gc_stats()
 159 {
 160         clear_gc_stats();
 161 }
 162
 163 /* classes.tuple uses this to reshape tuples; tools.deploy.shaker uses this
 164    to coalesce equal but distinct quotations and wrappers. */
 165 void factor_vm::primitive_become()
 166 {
 167         array *new_objects = untag_check<array>(dpop());
 168         array *old_objects = untag_check<array>(dpop());
 169
 170         cell capacity = array_capacity(new_objects);
 171         if(capacity != array_capacity(old_objects))
 172                 critical_error("bad parameters to become",0);
 173
 174         cell i;
 175
 176         for(i = 0; i < capacity; i++)
 177         {
 178                 tagged<object> old_obj(array_nth(old_objects,i));
 179                 tagged<object> new_obj(array_nth(new_objects,i));
 180
 181                 if(old_obj != new_obj)
 182                         old_obj->h.forward_to(new_obj.untagged());
 183         }
 184
 185         primitive_full_gc();
 186
 187         /* If a word's definition quotation was in old_objects and the
 188            quotation in new_objects is not compiled, we might leak memory
 189            by referencing the old quotation unless we recompile all
 190            unoptimized words. */
 191         compile_all_words();
 192 }
 193
 194 void factor_vm::inline_gc(cell *gc_roots_base, cell gc_roots_size)
 195 {
 196         for(cell i = 0; i < gc_roots_size; i++)
 197                 gc_locals.push_back((cell)&gc_roots_base[i]);
 198
 199         primitive_minor_gc();
 200
 201         for(cell i = 0; i < gc_roots_size; i++)
 202                 gc_locals.pop_back();
 203 }
 204
 205 VM_C_API void inline_gc(cell *gc_roots_base, cell gc_roots_size, factor_vm *parent)
 206 {
 207         parent->inline_gc(gc_roots_base,gc_roots_size);
 208 }
 209
 210 /*
 211  * It is up to the caller to fill in the object's fields in a meaningful
 212  * fashion!
 213  */
 214 object *factor_vm::allot_object(header header, cell size)
 215 {
 216 #ifdef GC_DEBUG
 217         if(!gc_off)
 218                 primitive_full_gc();
 219 #endif
 220
 221         object *obj;
 222
 223         /* If the object is smaller than the nursery, allocate it in the nursery,
 224         after a GC if needed */
 225         if(nursery.size > size)
 226         {
 227                 /* If there is insufficient room, collect the nursery */
 228                 if(nursery.here + size > nursery.end)
 229                         primitive_minor_gc();
 230
 231                 obj = nursery.allot(size);
 232         }
 233         /* If the object is bigger than the nursery, allocate it in
 234         tenured space */
 235         else
 236         {
 237                 /* If tenured space does not have enough room, collect */
 238                 if(data->tenured->here + size > data->tenured->end)
 239                         primitive_full_gc();
 240
 241                 /* If it still won't fit, grow the heap */
 242                 if(data->tenured->here + size > data->tenured->end)
 243                 {
 244                         gc(collect_growing_heap_op,
 245                                 size, /* requested size */
 246                                 true, /* trace contexts? */
 247                                 false /* compact code heap? */);
 248                 }
 249
 250                 obj = data->tenured->allot(size);
 251
 252                 /* Allows initialization code to store old->new pointers
 253                 without hitting the write barrier in the common case of
 254                 a nursery allocation */
 255                 char *start = (char *)obj;
 256                 for(cell offset = 0; offset < size; offset += card_size)
 257                         write_barrier((cell *)(start + offset));
 258         }
 259
 260         obj->h = header;
 261         return obj;
 262 }
 263
 264 }