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