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