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