vm/data_heap.cpp

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