6 void factor_vm::init_card_decks()
8 cards_offset = (cell)data->cards - addr_to_card(data->start);
9 decks_offset = (cell)data->decks - addr_to_deck(data->start);
12 data_heap::data_heap(cell young_size_,
16 young_size_ = align(young_size_,deck_size);
17 aging_size_ = align(aging_size_,deck_size);
18 tenured_size_ = align(tenured_size_,deck_size);
20 young_size = young_size_;
21 aging_size = aging_size_;
22 tenured_size = tenured_size_;
24 cell total_size = young_size + 2 * aging_size + tenured_size + deck_size;
25 seg = new segment(total_size,false);
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);
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);
37 start = align(seg->start,deck_size);
39 tenured = new tenured_space(tenured_size,start);
41 aging = new aging_space(aging_size,tenured->end);
42 aging_semispace = new aging_space(aging_size,aging->end);
44 nursery = new nursery_space(young_size,aging_semispace->end);
46 assert(seg->end - nursery->end <= deck_size);
49 data_heap::~data_heap()
54 delete aging_semispace;
60 data_heap *data_heap::grow(cell requested_bytes)
62 cell new_tenured_size = (tenured_size * 2) + requested_bytes;
63 return new data_heap(young_size,
68 template<typename Generation> void data_heap::clear_cards(Generation *gen)
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);
75 template<typename Generation> void data_heap::clear_decks(Generation *gen)
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);
82 void data_heap::reset_generation(nursery_space *gen)
84 gen->here = gen->start;
87 void data_heap::reset_generation(aging_space *gen)
89 gen->here = gen->start;
92 gen->starts.clear_object_start_offsets();
95 void data_heap::reset_generation(tenured_space *gen)
101 bool data_heap::low_memory_p()
103 return (tenured->free_space() <= nursery->size + aging->size);
106 void factor_vm::set_data_heap(data_heap *data_)
109 nursery = *data->nursery;
113 void factor_vm::init_data_heap(cell young_size, cell aging_size, cell tenured_size)
115 set_data_heap(new data_heap(young_size,aging_size,tenured_size));
118 /* Size of the object pointed to by a tagged pointer */
119 cell factor_vm::object_size(cell tagged)
121 if(immediate_p(tagged))
124 return untag<object>(tagged)->size();
127 /* Size of the object pointed to by an untagged pointer */
128 cell object::size() const
130 if(free_p()) return ((free_heap_block *)this)->size();
135 return align(array_size((array*)this),data_alignment);
137 return align(array_size((bignum*)this),data_alignment);
138 case BYTE_ARRAY_TYPE:
139 return align(array_size((byte_array*)this),data_alignment);
141 return align(string_size(string_capacity((string*)this)),data_alignment);
144 tuple_layout *layout = (tuple_layout *)UNTAG(((tuple *)this)->layout);
145 return align(tuple_size(layout),data_alignment);
148 return align(sizeof(quotation),data_alignment);
150 return align(sizeof(word),data_alignment);
152 return align(sizeof(boxed_float),data_alignment);
154 return align(sizeof(dll),data_alignment);
156 return align(sizeof(alien),data_alignment);
158 return align(sizeof(wrapper),data_alignment);
160 return align(callstack_size(untag_fixnum(((callstack *)this)->length)),data_alignment);
162 critical_error("Invalid header",(cell)this);
163 return 0; /* can't happen */
167 /* The number of cells from the start of the object which should be scanned by
168 the GC. Some types have a binary payload at the end (string, word, DLL) which
170 cell object::binary_payload_start() const
174 /* these objects do not refer to other objects at all */
176 case BYTE_ARRAY_TYPE:
180 /* these objects have some binary data at the end */
182 return sizeof(word) - sizeof(cell) * 3;
184 return sizeof(cell) * 3;
186 return sizeof(cell) * 2;
188 return sizeof(quotation) - sizeof(cell) * 2;
190 return sizeof(string);
191 /* everything else consists entirely of pointers */
193 return array_size<array>(array_capacity((array*)this));
195 return tuple_size(untag<tuple_layout>(((tuple *)this)->layout));
197 return sizeof(wrapper);
199 critical_error("Invalid header",(cell)this);
200 return 0; /* can't happen */
204 void factor_vm::primitive_size()
206 box_unsigned_cell(object_size(dpop()));
209 data_heap_room factor_vm::data_room()
213 room.nursery_size = nursery.size;
214 room.nursery_occupied = nursery.occupied_space();
215 room.nursery_free = nursery.free_space();
216 room.aging_size = data->aging->size;
217 room.aging_occupied = data->aging->occupied_space();
218 room.aging_free = data->aging->free_space();
219 room.tenured_size = data->tenured->size;
220 room.tenured_occupied = data->tenured->occupied_space();
221 room.tenured_total_free = data->tenured->free_space();
222 room.tenured_contiguous_free = data->tenured->largest_free_block();
223 room.tenured_free_block_count = data->tenured->free_block_count();
224 room.cards = data->cards_end - data->cards;
225 room.decks = data->decks_end - data->decks;
226 room.mark_stack = data->tenured->mark_stack.capacity();
231 void factor_vm::primitive_data_room()
233 data_heap_room room = data_room();
234 dpush(tag<byte_array>(byte_array_from_value(&room)));
237 /* Disables GC and activates next-object ( -- obj ) primitive */
238 void factor_vm::begin_scan()
240 heap_scan_ptr = data->tenured->first_object();
244 void factor_vm::end_scan()
249 void factor_vm::primitive_begin_scan()
254 cell factor_vm::next_object()
257 general_error(ERROR_HEAP_SCAN,false_object,false_object,NULL);
261 cell current = heap_scan_ptr;
262 heap_scan_ptr = data->tenured->next_object_after(heap_scan_ptr);
263 return tag_dynamic((object *)current);
269 /* Push object at heap scan cursor and advance; pushes f when done */
270 void factor_vm::primitive_next_object()
272 dpush(next_object());
276 void factor_vm::primitive_end_scan()
281 struct word_counter {
284 explicit word_counter() : count(0) {}
286 void operator()(cell obj)
288 if(tagged<object>(obj).type_p(WORD_TYPE))
293 struct word_accumulator {
294 growable_array words;
296 explicit word_accumulator(int count,factor_vm *vm) : words(vm,count) {}
298 void operator()(cell obj)
300 if(tagged<object>(obj).type_p(WORD_TYPE))
305 cell factor_vm::find_all_words()
307 word_counter counter;
308 each_object(counter);
309 word_accumulator accum(counter.count,this);
312 return accum.words.elements.value();