5 data_heap::data_heap(bump_allocator* vm_nursery,
10 young_size_ = align(young_size_, deck_size);
11 aging_size_ = align(aging_size_, deck_size);
12 tenured_size_ = align(tenured_size_, deck_size);
14 young_size = young_size_;
15 aging_size = aging_size_;
16 tenured_size = tenured_size_;
18 cell total_size = young_size + 2 * aging_size + tenured_size + deck_size;
19 seg = new segment(total_size, false);
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);
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);
31 start = align(seg->start, deck_size);
33 tenured = new tenured_space(tenured_size, start);
35 aging = new aging_space(aging_size, tenured->end);
36 aging_semispace = new aging_space(aging_size, aging->end);
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;
45 FACTOR_ASSERT(seg->end - nursery->end <= deck_size);
48 data_heap::~data_heap() {
51 delete aging_semispace;
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 = (tenured_size * 2) + requested_bytes;
60 return new data_heap(vm_nursery, young_size, aging_size, new_tenured_size);
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);
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);
75 void data_heap::reset_nursery() {
79 void data_heap::reset_aging() {
83 aging->starts.clear_object_start_offsets();
86 void data_heap::reset_tenured() {
91 bool data_heap::high_fragmentation_p() {
92 return tenured->largest_free_block() <= high_water_mark();
95 bool data_heap::low_memory_p() {
96 return tenured->free_space <= high_water_mark();
99 void data_heap::mark_all_cards() {
100 memset(cards, 0xff, cards_end - cards);
101 memset(decks, 0xff, decks_end - decks);
104 void factor_vm::set_data_heap(data_heap* data_) {
106 cards_offset = (cell)data->cards - addr_to_card(data->start);
107 decks_offset = (cell)data->decks - addr_to_deck(data->start);
110 void factor_vm::init_data_heap(cell young_size, cell aging_size,
112 set_data_heap(new data_heap(&nursery, young_size, aging_size, tenured_size));
115 data_heap_room factor_vm::data_room() {
118 room.nursery_size = data->nursery->size;
119 room.nursery_occupied = data->nursery->occupied_space();
120 room.nursery_free = data->nursery->free_space();
121 room.aging_size = data->aging->size;
122 room.aging_occupied = data->aging->occupied_space();
123 room.aging_free = data->aging->free_space();
124 room.tenured_size = data->tenured->size;
125 room.tenured_occupied = data->tenured->occupied_space();
126 room.tenured_total_free = data->tenured->free_space;
127 room.tenured_contiguous_free = data->tenured->largest_free_block();
128 room.tenured_free_block_count = data->tenured->free_block_count;
129 room.cards = data->cards_end - data->cards;
130 room.decks = data->decks_end - data->decks;
131 room.mark_stack = mark_stack.capacity() * sizeof(cell);
137 void factor_vm::primitive_data_room() {
138 data_heap_room room = data_room();
139 ctx->push(tag<byte_array>(byte_array_from_value(&room)));
143 cell factor_vm::instances(cell type) {
146 std::vector<cell> objects;
147 auto object_accumulator = [&](object* obj) {
148 if (type == TYPE_COUNT || obj->type() == type)
149 objects.push_back(tag_dynamic(obj));
151 each_object(object_accumulator);
152 return std_vector_to_array(objects);
156 void factor_vm::primitive_all_instances() {
157 ctx->push(instances(TYPE_COUNT));