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::high_fragmentation_p()
 102 {
 103         return (tenured->largest_free_block() <= nursery->size + aging->size);
 104 }
 105
 106 bool data_heap::low_memory_p()
 107 {
 108         return (tenured->free_space() <= nursery->size + aging->size);
 109 }
 110
 111 void data_heap::mark_all_cards()
 112 {
 113         memset(cards,-1,cards_end - cards);
 114         memset(decks,-1,decks_end - decks);
 115 }
 116
 117 void factor_vm::set_data_heap(data_heap *data_)
 118 {
 119         data = data_;
 120         nursery = *data->nursery;
 121         init_card_decks();
 122 }
 123
 124 void factor_vm::init_data_heap(cell young_size, cell aging_size, cell tenured_size)
 125 {
 126         set_data_heap(new data_heap(young_size,aging_size,tenured_size));
 127 }
 128
 129 data_heap_room factor_vm::data_room()
 130 {
 131         data_heap_room room;
 132
 133         room.nursery_size             = nursery.size;
 134         room.nursery_occupied         = nursery.occupied_space();
 135         room.nursery_free             = nursery.free_space();
 136         room.aging_size               = data->aging->size;
 137         room.aging_occupied           = data->aging->occupied_space();
 138         room.aging_free               = data->aging->free_space();
 139         room.tenured_size             = data->tenured->size;
 140         room.tenured_occupied         = data->tenured->occupied_space();
 141         room.tenured_total_free       = data->tenured->free_space();
 142         room.tenured_contiguous_free  = data->tenured->largest_free_block();
 143         room.tenured_free_block_count = data->tenured->free_block_count();
 144         room.cards                    = data->cards_end - data->cards;
 145         room.decks                    = data->decks_end - data->decks;
 146         room.mark_stack               = mark_stack.capacity() * sizeof(cell);
 147
 148         return room;
 149 }
 150
 151 void factor_vm::primitive_data_room()
 152 {
 153         data_heap_room room = data_room();
 154         ctx->push(tag<byte_array>(byte_array_from_value(&room)));
 155 }
 156
 157 struct object_accumulator {
 158         cell type;
 159         std::vector<cell> objects;
 160
 161         explicit object_accumulator(cell type_) : type(type_) {}
 162
 163         void operator()(object *obj)
 164         {
 165                 if(type == TYPE_COUNT || obj->type() == type)
 166                         objects.push_back(tag_dynamic(obj));
 167         }
 168 };
 169
 170 cell factor_vm::instances(cell type)
 171 {
 172         object_accumulator accum(type);
 173         each_object(accum);
 174         return std_vector_to_array(accum.objects);
 175 }
 176
 177 void factor_vm::primitive_all_instances()
 178 {
 179         primitive_full_gc();
 180         ctx->push(instances(TYPE_COUNT));
 181 }
 182
 183 }