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 void factor_vm::set_data_heap(data_heap *data_)
 102 {
 103         data = data_;
 104         nursery = *data->nursery;
 105         init_card_decks();
 106 }
 107
 108 void factor_vm::init_data_heap(cell young_size, cell aging_size, cell tenured_size)
 109 {
 110         set_data_heap(new data_heap(young_size,aging_size,tenured_size));
 111 }
 112
 113 /* Size of the object pointed to by a tagged pointer */
 114 cell factor_vm::object_size(cell tagged)
 115 {
 116         if(immediate_p(tagged))
 117                 return 0;
 118         else
 119                 return untag<object>(tagged)->size();
 120 }
 121
 122 /* Size of the object pointed to by an untagged pointer */
 123 cell object::size() const
 124 {
 125         if(free_p()) return ((free_heap_block *)this)->size();
 126
 127         switch(h.hi_tag())
 128         {
 129         case ARRAY_TYPE:
 130                 return align(array_size((array*)this),data_alignment);
 131         case BIGNUM_TYPE:
 132                 return align(array_size((bignum*)this),data_alignment);
 133         case BYTE_ARRAY_TYPE:
 134                 return align(array_size((byte_array*)this),data_alignment);
 135         case STRING_TYPE:
 136                 return align(string_size(string_capacity((string*)this)),data_alignment);
 137         case TUPLE_TYPE:
 138                 {
 139                         tuple_layout *layout = (tuple_layout *)UNTAG(((tuple *)this)->layout);
 140                         return align(tuple_size(layout),data_alignment);
 141                 }
 142         case QUOTATION_TYPE:
 143                 return align(sizeof(quotation),data_alignment);
 144         case WORD_TYPE:
 145                 return align(sizeof(word),data_alignment);
 146         case FLOAT_TYPE:
 147                 return align(sizeof(boxed_float),data_alignment);
 148         case DLL_TYPE:
 149                 return align(sizeof(dll),data_alignment);
 150         case ALIEN_TYPE:
 151                 return align(sizeof(alien),data_alignment);
 152         case WRAPPER_TYPE:
 153                 return align(sizeof(wrapper),data_alignment);
 154         case CALLSTACK_TYPE:
 155                 return align(callstack_size(untag_fixnum(((callstack *)this)->length)),data_alignment);
 156         default:
 157                 critical_error("Invalid header",(cell)this);
 158                 return 0; /* can't happen */
 159         }
 160 }
 161
 162 /* The number of cells from the start of the object which should be scanned by
 163 the GC. Some types have a binary payload at the end (string, word, DLL) which
 164 we ignore. */
 165 cell object::binary_payload_start() const
 166 {
 167         switch(h.hi_tag())
 168         {
 169         /* these objects do not refer to other objects at all */
 170         case FLOAT_TYPE:
 171         case BYTE_ARRAY_TYPE:
 172         case BIGNUM_TYPE:
 173         case CALLSTACK_TYPE:
 174                 return 0;
 175         /* these objects have some binary data at the end */
 176         case WORD_TYPE:
 177                 return sizeof(word) - sizeof(cell) * 3;
 178         case ALIEN_TYPE:
 179                 return sizeof(cell) * 3;
 180         case DLL_TYPE:
 181                 return sizeof(cell) * 2;
 182         case QUOTATION_TYPE:
 183                 return sizeof(quotation) - sizeof(cell) * 2;
 184         case STRING_TYPE:
 185                 return sizeof(string);
 186         /* everything else consists entirely of pointers */
 187         case ARRAY_TYPE:
 188                 return array_size<array>(array_capacity((array*)this));
 189         case TUPLE_TYPE:
 190                 return tuple_size(untag<tuple_layout>(((tuple *)this)->layout));
 191         case WRAPPER_TYPE:
 192                 return sizeof(wrapper);
 193         default:
 194                 critical_error("Invalid header",(cell)this);
 195                 return 0; /* can't happen */
 196         }
 197 }
 198
 199 void factor_vm::primitive_size()
 200 {
 201         box_unsigned_cell(object_size(dpop()));
 202 }
 203
 204 data_heap_room factor_vm::data_room()
 205 {
 206         data_heap_room room;
 207
 208         room.nursery_size             = nursery.size;
 209         room.nursery_occupied         = nursery.occupied_space();
 210         room.nursery_free             = nursery.free_space();
 211         room.aging_size               = data->aging->size;
 212         room.aging_occupied           = data->aging->occupied_space();
 213         room.aging_free               = data->aging->free_space();
 214         room.tenured_size             = data->tenured->size;
 215         room.tenured_occupied         = data->tenured->occupied_space();
 216         room.tenured_total_free       = data->tenured->free_space();
 217         room.tenured_contiguous_free  = data->tenured->largest_free_block();
 218         room.tenured_free_block_count = data->tenured->free_block_count();
 219         room.cards                    = data->cards_end - data->cards;
 220         room.decks                    = data->decks_end - data->decks;
 221         room.mark_stack               = data->tenured->mark_stack.capacity();
 222
 223         return room;
 224 }
 225
 226 void factor_vm::primitive_data_room()
 227 {
 228         data_heap_room room = data_room();
 229         dpush(tag<byte_array>(byte_array_from_value(&room)));
 230 }
 231
 232 /* Disables GC and activates next-object ( -- obj ) primitive */
 233 void factor_vm::begin_scan()
 234 {
 235         heap_scan_ptr = data->tenured->first_object();
 236         gc_off = true;
 237 }
 238
 239 void factor_vm::end_scan()
 240 {
 241         gc_off = false;
 242 }
 243
 244 void factor_vm::primitive_begin_scan()
 245 {
 246         begin_scan();
 247 }
 248
 249 cell factor_vm::next_object()
 250 {
 251         if(!gc_off)
 252                 general_error(ERROR_HEAP_SCAN,false_object,false_object,NULL);
 253
 254         if(heap_scan_ptr)
 255         {
 256                 cell current = heap_scan_ptr;
 257                 heap_scan_ptr = data->tenured->next_object_after(heap_scan_ptr);
 258                 return tag_dynamic((object *)current);
 259         }
 260         else
 261                 return false_object;
 262 }
 263
 264 /* Push object at heap scan cursor and advance; pushes f when done */
 265 void factor_vm::primitive_next_object()
 266 {
 267         dpush(next_object());
 268 }
 269
 270 /* Re-enables GC */
 271 void factor_vm::primitive_end_scan()
 272 {
 273         gc_off = false;
 274 }
 275
 276 struct word_counter {
 277         cell count;
 278
 279         explicit word_counter() : count(0) {}
 280
 281         void operator()(cell obj)
 282         {
 283                 if(tagged<object>(obj).type_p(WORD_TYPE))
 284                         count++;
 285         }
 286 };
 287
 288 struct word_accumulator {
 289         growable_array words;
 290
 291         explicit word_accumulator(int count,factor_vm *vm) : words(vm,count) {}
 292
 293         void operator()(cell obj)
 294         {
 295                 if(tagged<object>(obj).type_p(WORD_TYPE))
 296                         words.add(obj);
 297         }
 298 };
 299
 300 cell factor_vm::find_all_words()
 301 {
 302         word_counter counter;
 303         each_object(counter);
 304         word_accumulator accum(counter.count,this);
 305         each_object(accum);
 306         accum.words.trim();
 307         return accum.words.elements.value();
 308 }
 309
 310 }