vm/data_heap.cpp

   1 #include "master.hpp"
   2
   3 namespace factor
   4 {
   5
   6 void factor_vm::init_card_decks()
   7 {
   8         cards_offset = (cell)data->cards - addr_to_card(data->start);
   9         decks_offset = (cell)data->decks - addr_to_deck(data->start);
  10 }
  11
  12 data_heap::data_heap(cell young_size_, cell aging_size_, cell tenured_size_)
  13 {
  14         young_size_ = align(young_size_,deck_size);
  15         aging_size_ = align(aging_size_,deck_size);
  16         tenured_size_ = align(tenured_size_,deck_size);
  17
  18         young_size = young_size_;
  19         aging_size = aging_size_;
  20         tenured_size = tenured_size_;
  21
  22         cell total_size = young_size + 2 * aging_size + 2 * tenured_size;
  23
  24         total_size += deck_size;
  25
  26         seg = new segment(total_size,false);
  27
  28         cell cards_size = addr_to_card(total_size);
  29
  30         cards = new card[cards_size];
  31         cards_end = cards + cards_size;
  32
  33         cell decks_size = addr_to_deck(total_size);
  34         decks = new card_deck[decks_size];
  35         decks_end = decks + decks_size;
  36
  37         start = align(seg->start,deck_size);
  38
  39         tenured = new tenured_space(tenured_size,start);
  40         tenured_semispace = new tenured_space(tenured_size,tenured->end);
  41
  42         aging = new aging_space(aging_size,tenured_semispace->end);
  43         aging_semispace = new aging_space(aging_size,aging->end);
  44
  45         nursery = new zone(young_size,aging_semispace->end);
  46
  47         assert(seg->end - nursery->end <= deck_size);
  48 }
  49
  50 data_heap::~data_heap()
  51 {
  52         delete seg;
  53         delete nursery;
  54         delete aging;
  55         delete aging_semispace;
  56         delete tenured;
  57         delete tenured_semispace;
  58         delete[] cards;
  59         delete[] decks;
  60 }
  61
  62 data_heap *data_heap::grow(cell requested_bytes)
  63 {
  64         cell new_tenured_size = (tenured_size * 2) + requested_bytes;
  65         return new data_heap(young_size,aging_size,new_tenured_size);
  66 }
  67
  68 void factor_vm::clear_cards(old_space *gen)
  69 {
  70         cell first_card = addr_to_card(gen->start - data->start);
  71         cell last_card = addr_to_card(gen->end - data->start);
  72         memset(&data->cards[first_card],0,last_card - first_card);
  73 }
  74
  75 void factor_vm::clear_decks(old_space *gen)
  76 {
  77         cell first_deck = addr_to_deck(gen->start - data->start);
  78         cell last_deck = addr_to_deck(gen->end - data->start);
  79         memset(&data->decks[first_deck],0,last_deck - first_deck);
  80 }
  81
  82 /* After garbage collection, any generations which are now empty need to have
  83 their allocation pointers and cards reset. */
  84 void factor_vm::reset_generation(old_space *gen)
  85 {
  86         gen->here = gen->start;
  87         if(secure_gc) memset((void*)gen->start,69,gen->size);
  88
  89         clear_cards(gen);
  90         clear_decks(gen);
  91         gen->clear_object_start_offsets();
  92 }
  93
  94 void factor_vm::set_data_heap(data_heap *data_)
  95 {
  96         data = data_;
  97         nursery = *data->nursery;
  98         nursery.here = nursery.start;
  99         init_card_decks();
 100         reset_generation(data->aging);
 101         reset_generation(data->tenured);
 102 }
 103
 104 void factor_vm::init_data_heap(cell young_size, cell aging_size, cell tenured_size, bool secure_gc_)
 105 {
 106         set_data_heap(new data_heap(young_size,aging_size,tenured_size));
 107         secure_gc = secure_gc_;
 108 }
 109
 110 /* Size of the object pointed to by a tagged pointer */
 111 cell factor_vm::object_size(cell tagged)
 112 {
 113         if(immediate_p(tagged))
 114                 return 0;
 115         else
 116                 return untagged_object_size(untag<object>(tagged));
 117 }
 118
 119 /* Size of the object pointed to by an untagged pointer */
 120 cell factor_vm::untagged_object_size(object *pointer)
 121 {
 122         return align8(unaligned_object_size(pointer));
 123 }
 124
 125 /* Size of the data area of an object pointed to by an untagged pointer */
 126 cell factor_vm::unaligned_object_size(object *pointer)
 127 {
 128         switch(pointer->h.hi_tag())
 129         {
 130         case ARRAY_TYPE:
 131                 return array_size((array*)pointer);
 132         case BIGNUM_TYPE:
 133                 return array_size((bignum*)pointer);
 134         case BYTE_ARRAY_TYPE:
 135                 return array_size((byte_array*)pointer);
 136         case STRING_TYPE:
 137                 return string_size(string_capacity((string*)pointer));
 138         case TUPLE_TYPE:
 139                 return tuple_size(untag<tuple_layout>(((tuple *)pointer)->layout));
 140         case QUOTATION_TYPE:
 141                 return sizeof(quotation);
 142         case WORD_TYPE:
 143                 return sizeof(word);
 144         case FLOAT_TYPE:
 145                 return sizeof(boxed_float);
 146         case DLL_TYPE:
 147                 return sizeof(dll);
 148         case ALIEN_TYPE:
 149                 return sizeof(alien);
 150         case WRAPPER_TYPE:
 151                 return sizeof(wrapper);
 152         case CALLSTACK_TYPE:
 153                 return callstack_size(untag_fixnum(((callstack *)pointer)->length));
 154         default:
 155                 critical_error("Invalid header",(cell)pointer);
 156                 return 0; /* can't happen */
 157         }
 158 }
 159
 160 void factor_vm::primitive_size()
 161 {
 162         box_unsigned_cell(object_size(dpop()));
 163 }
 164
 165 /* The number of cells from the start of the object which should be scanned by
 166 the GC. Some types have a binary payload at the end (string, word, DLL) which
 167 we ignore. */
 168 cell factor_vm::binary_payload_start(object *pointer)
 169 {
 170         switch(pointer->h.hi_tag())
 171         {
 172         /* these objects do not refer to other objects at all */
 173         case FLOAT_TYPE:
 174         case BYTE_ARRAY_TYPE:
 175         case BIGNUM_TYPE:
 176         case CALLSTACK_TYPE:
 177                 return 0;
 178         /* these objects have some binary data at the end */
 179         case WORD_TYPE:
 180                 return sizeof(word) - sizeof(cell) * 3;
 181         case ALIEN_TYPE:
 182                 return sizeof(cell) * 3;
 183         case DLL_TYPE:
 184                 return sizeof(cell) * 2;
 185         case QUOTATION_TYPE:
 186                 return sizeof(quotation) - sizeof(cell) * 2;
 187         case STRING_TYPE:
 188                 return sizeof(string);
 189         /* everything else consists entirely of pointers */
 190         case ARRAY_TYPE:
 191                 return array_size<array>(array_capacity((array*)pointer));
 192         case TUPLE_TYPE:
 193                 return tuple_size(untag<tuple_layout>(((tuple *)pointer)->layout));
 194         case WRAPPER_TYPE:
 195                 return sizeof(wrapper);
 196         default:
 197                 critical_error("Invalid header",(cell)pointer);
 198                 return 0; /* can't happen */
 199         }
 200 }
 201
 202 /* Push memory usage statistics in data heap */
 203 void factor_vm::primitive_data_room()
 204 {
 205         dpush(tag_fixnum((data->cards_end - data->cards) >> 10));
 206         dpush(tag_fixnum((data->decks_end - data->decks) >> 10));
 207
 208         growable_array a(this);
 209
 210         a.add(tag_fixnum((nursery.end - nursery.here) >> 10));
 211         a.add(tag_fixnum((nursery.size) >> 10));
 212
 213         a.add(tag_fixnum((data->aging->end - data->aging->here) >> 10));
 214         a.add(tag_fixnum((data->aging->size) >> 10));
 215
 216         a.add(tag_fixnum((data->tenured->end - data->tenured->here) >> 10));
 217         a.add(tag_fixnum((data->tenured->size) >> 10));
 218
 219         a.trim();
 220         dpush(a.elements.value());
 221 }
 222
 223 /* Disables GC and activates next-object ( -- obj ) primitive */
 224 void factor_vm::begin_scan()
 225 {
 226         heap_scan_ptr = data->tenured->start;
 227         gc_off = true;
 228 }
 229
 230 void factor_vm::end_scan()
 231 {
 232         gc_off = false;
 233 }
 234
 235 void factor_vm::primitive_begin_scan()
 236 {
 237         begin_scan();
 238 }
 239
 240 cell factor_vm::next_object()
 241 {
 242         if(!gc_off)
 243                 general_error(ERROR_HEAP_SCAN,F,F,NULL);
 244
 245         if(heap_scan_ptr >= data->tenured->here)
 246                 return F;
 247
 248         object *obj = (object *)heap_scan_ptr;
 249         heap_scan_ptr += untagged_object_size(obj);
 250         return tag_dynamic(obj);
 251 }
 252
 253 /* Push object at heap scan cursor and advance; pushes f when done */
 254 void factor_vm::primitive_next_object()
 255 {
 256         dpush(next_object());
 257 }
 258
 259 /* Re-enables GC */
 260 void factor_vm::primitive_end_scan()
 261 {
 262         gc_off = false;
 263 }
 264
 265 template<typename Iterator> void factor_vm::each_object(Iterator &iterator)
 266 {
 267         begin_scan();
 268         cell obj;
 269         while((obj = next_object()) != F)
 270                 iterator(tagged<object>(obj));
 271         end_scan();
 272 }
 273
 274 struct word_counter {
 275         cell count;
 276         explicit word_counter() : count(0) {}
 277         void operator()(tagged<object> obj) { if(obj.type_p(WORD_TYPE)) count++; }
 278 };
 279
 280 struct word_accumulator {
 281         growable_array words;
 282         explicit word_accumulator(int count,factor_vm *vm) : words(vm,count) {}
 283         void operator()(tagged<object> obj) { if(obj.type_p(WORD_TYPE)) words.add(obj.value()); }
 284 };
 285
 286 cell factor_vm::find_all_words()
 287 {
 288         word_counter counter;
 289         each_object(counter);
 290         word_accumulator accum(counter.count,this);
 291         each_object(accum);
 292         accum.words.trim();
 293         return accum.words.elements.value();
 294 }
 295
 296 }