vm/data_heap.cpp

   1 #include "master.hpp"
   2
   3 namespace factor {
   4
   5 void factor_vm::init_card_decks() {
   6   cards_offset = (cell)data->cards - addr_to_card(data->start);
   7   decks_offset = (cell)data->decks - addr_to_deck(data->start);
   8 }
   9
  10 data_heap::data_heap(bump_allocator* vm_nursery,
  11                      cell young_size_,
  12                      cell aging_size_,
  13                      cell tenured_size_) {
  14
  15   young_size_ = align(young_size_, deck_size);
  16   aging_size_ = align(aging_size_, deck_size);
  17   tenured_size_ = align(tenured_size_, deck_size);
  18
  19   young_size = young_size_;
  20   aging_size = aging_size_;
  21   tenured_size = tenured_size_;
  22
  23   cell total_size = young_size + 2 * aging_size + tenured_size + deck_size;
  24   seg = new segment(total_size, false);
  25
  26   cell cards_size = total_size / card_size;
  27   cards = new card[cards_size];
  28   cards_end = cards + cards_size;
  29   memset(cards, 0, cards_size);
  30
  31   cell decks_size = total_size / deck_size;
  32   decks = new card_deck[decks_size];
  33   decks_end = decks + decks_size;
  34   memset(decks, 0, decks_size);
  35
  36   start = align(seg->start, deck_size);
  37
  38   tenured = new tenured_space(tenured_size, start);
  39
  40   aging = new aging_space(aging_size, tenured->end);
  41   aging_semispace = new aging_space(aging_size, aging->end);
  42
  43   // Initialize vm nursery
  44   vm_nursery->here = aging_semispace->end;
  45   vm_nursery->start = aging_semispace->end;
  46   vm_nursery->end = vm_nursery->start + young_size;
  47   vm_nursery->size = young_size;
  48   nursery = vm_nursery;
  49
  50   FACTOR_ASSERT(seg->end - nursery->end <= deck_size);
  51 }
  52
  53 data_heap::~data_heap() {
  54   delete seg;
  55   delete aging;
  56   delete aging_semispace;
  57   delete tenured;
  58   delete[] cards;
  59   delete[] decks;
  60 }
  61
  62 data_heap* data_heap::grow(bump_allocator* vm_nursery, cell requested_bytes) {
  63   FACTOR_ASSERT(vm_nursery->occupied_space() == 0);
  64   cell new_tenured_size = (tenured_size * 2) + requested_bytes;
  65   return new data_heap(vm_nursery, young_size, aging_size, new_tenured_size);
  66 }
  67
  68 template <typename Generation> void data_heap::clear_cards(Generation* gen) {
  69   cell first_card = addr_to_card(gen->start - start);
  70   cell last_card = addr_to_card(gen->end - start);
  71   memset(&cards[first_card], 0, last_card - first_card);
  72 }
  73
  74 template <typename Generation> void data_heap::clear_decks(Generation* gen) {
  75   cell first_deck = addr_to_deck(gen->start - start);
  76   cell last_deck = addr_to_deck(gen->end - start);
  77   memset(&decks[first_deck], 0, last_deck - first_deck);
  78 }
  79
  80 void data_heap::reset_nursery() {
  81   nursery->flush();
  82 }
  83
  84 void data_heap::reset_aging() {
  85   aging->flush();
  86   clear_cards(aging);
  87   clear_decks(aging);
  88   aging->starts.clear_object_start_offsets();
  89 }
  90
  91 void data_heap::reset_tenured() {
  92   clear_cards(tenured);
  93   clear_decks(tenured);
  94 }
  95
  96 bool data_heap::high_fragmentation_p() {
  97   return tenured->largest_free_block() <= high_water_mark();
  98 }
  99
 100 bool data_heap::low_memory_p() {
 101   return tenured->free_space() <= high_water_mark();
 102 }
 103
 104 void data_heap::mark_all_cards() {
 105   memset(cards, 0xff, cards_end - cards);
 106   memset(decks, 0xff, decks_end - decks);
 107 }
 108
 109 void factor_vm::set_data_heap(data_heap* data_) {
 110   data = data_;
 111   init_card_decks();
 112 }
 113
 114 void factor_vm::init_data_heap(cell young_size, cell aging_size,
 115                                cell tenured_size) {
 116   set_data_heap(new data_heap(&nursery, young_size, aging_size, tenured_size));
 117 }
 118
 119 data_heap_room factor_vm::data_room() {
 120   data_heap_room room;
 121
 122   room.nursery_size = data->nursery->size;
 123   room.nursery_occupied = data->nursery->occupied_space();
 124   room.nursery_free = data->nursery->free_space();
 125   room.aging_size = data->aging->size;
 126   room.aging_occupied = data->aging->occupied_space();
 127   room.aging_free = data->aging->free_space();
 128   room.tenured_size = data->tenured->size;
 129   room.tenured_occupied = data->tenured->occupied_space();
 130   room.tenured_total_free = data->tenured->free_space();
 131   room.tenured_contiguous_free = data->tenured->largest_free_block();
 132   room.tenured_free_block_count = data->tenured->free_block_count();
 133   room.cards = data->cards_end - data->cards;
 134   room.decks = data->decks_end - data->decks;
 135   room.mark_stack = mark_stack.capacity() * sizeof(cell);
 136
 137   return room;
 138 }
 139
 140 /* Allocates memory */
 141 void factor_vm::primitive_data_room() {
 142   data_heap_room room = data_room();
 143   ctx->push(tag<byte_array>(byte_array_from_value(&room)));
 144 }
 145
 146 struct object_accumulator {
 147   cell type;
 148   std::vector<cell> objects;
 149
 150   explicit object_accumulator(cell type) : type(type) {}
 151
 152   void operator()(object* obj) {
 153     if (type == TYPE_COUNT || obj->type() == type)
 154       objects.push_back(tag_dynamic(obj));
 155   }
 156 };
 157
 158 /* Allocates memory */
 159 cell factor_vm::instances(cell type) {
 160   primitive_full_gc();
 161   object_accumulator accum(type);
 162   each_object(accum);
 163   return std_vector_to_array(accum.objects);
 164 }
 165
 166 /* Allocates memory */
 167 void factor_vm::primitive_all_instances() {
 168   ctx->push(instances(TYPE_COUNT));
 169 }
 170
 171 }