6 cell factorvm::init_zone(zone *z, cell size, cell start)
9 z->start = z->here = start;
10 z->end = start + size;
15 void factorvm::init_card_decks()
17 cell start = align(data->seg->start,deck_size);
18 allot_markers_offset = (cell)data->allot_markers - (start >> card_bits);
19 cards_offset = (cell)data->cards - (start >> card_bits);
20 decks_offset = (cell)data->decks - (start >> deck_bits);
23 data_heap *factorvm::alloc_data_heap(cell gens, cell young_size,cell aging_size,cell tenured_size)
25 young_size = align(young_size,deck_size);
26 aging_size = align(aging_size,deck_size);
27 tenured_size = align(tenured_size,deck_size);
29 data_heap *data = (data_heap *)safe_malloc(sizeof(data_heap));
30 data->young_size = young_size;
31 data->aging_size = aging_size;
32 data->tenured_size = tenured_size;
33 data->gen_count = gens;
36 if(data->gen_count == 2)
37 total_size = young_size + 2 * tenured_size;
38 else if(data->gen_count == 3)
39 total_size = young_size + 2 * aging_size + 2 * tenured_size;
42 fatal_error("Invalid number of generations",data->gen_count);
43 return NULL; /* can't happen */
46 total_size += deck_size;
48 data->seg = alloc_segment(total_size);
50 data->generations = (zone *)safe_malloc(sizeof(zone) * data->gen_count);
51 data->semispaces = (zone *)safe_malloc(sizeof(zone) * data->gen_count);
53 cell cards_size = total_size >> card_bits;
54 data->allot_markers = (cell *)safe_malloc(cards_size);
55 data->allot_markers_end = data->allot_markers + cards_size;
57 data->cards = (cell *)safe_malloc(cards_size);
58 data->cards_end = data->cards + cards_size;
60 cell decks_size = total_size >> deck_bits;
61 data->decks = (cell *)safe_malloc(decks_size);
62 data->decks_end = data->decks + decks_size;
64 cell alloter = align(data->seg->start,deck_size);
66 alloter = init_zone(&data->generations[data->tenured()],tenured_size,alloter);
67 alloter = init_zone(&data->semispaces[data->tenured()],tenured_size,alloter);
69 if(data->gen_count == 3)
71 alloter = init_zone(&data->generations[data->aging()],aging_size,alloter);
72 alloter = init_zone(&data->semispaces[data->aging()],aging_size,alloter);
75 if(data->gen_count >= 2)
77 alloter = init_zone(&data->generations[data->nursery()],young_size,alloter);
78 alloter = init_zone(&data->semispaces[data->nursery()],0,alloter);
81 if(data->seg->end - alloter > deck_size)
82 critical_error("Bug in alloc_data_heap",alloter);
88 data_heap *factorvm::grow_data_heap(data_heap *data, cell requested_bytes)
90 cell new_tenured_size = (data->tenured_size * 2) + requested_bytes;
92 return alloc_data_heap(data->gen_count,
99 void factorvm::dealloc_data_heap(data_heap *data)
101 dealloc_segment(data->seg);
102 free(data->generations);
103 free(data->semispaces);
104 free(data->allot_markers);
111 void factorvm::clear_cards(cell from, cell to)
113 /* NOTE: reverse order due to heap layout. */
114 card *first_card = addr_to_card(data->generations[to].start);
115 card *last_card = addr_to_card(data->generations[from].end);
116 memset(first_card,0,last_card - first_card);
120 void factorvm::clear_decks(cell from, cell to)
122 /* NOTE: reverse order due to heap layout. */
123 card_deck *first_deck = addr_to_deck(data->generations[to].start);
124 card_deck *last_deck = addr_to_deck(data->generations[from].end);
125 memset(first_deck,0,last_deck - first_deck);
129 void factorvm::clear_allot_markers(cell from, cell to)
131 /* NOTE: reverse order due to heap layout. */
132 card *first_card = addr_to_allot_marker((object *)data->generations[to].start);
133 card *last_card = addr_to_allot_marker((object *)data->generations[from].end);
134 memset(first_card,invalid_allot_marker,last_card - first_card);
138 void factorvm::reset_generation(cell i)
140 zone *z = (i == data->nursery() ? &nursery : &data->generations[i]);
144 memset((void*)z->start,69,z->size);
148 /* After garbage collection, any generations which are now empty need to have
149 their allocation pointers and cards reset. */
150 void factorvm::reset_generations(cell from, cell to)
153 for(i = from; i <= to; i++)
156 clear_cards(from,to);
157 clear_decks(from,to);
158 clear_allot_markers(from,to);
162 void factorvm::set_data_heap(data_heap *data_)
165 nursery = data->generations[data->nursery()];
167 clear_cards(data->nursery(),data->tenured());
168 clear_decks(data->nursery(),data->tenured());
169 clear_allot_markers(data->nursery(),data->tenured());
173 void factorvm::init_data_heap(cell gens,cell young_size,cell aging_size,cell tenured_size,bool secure_gc_)
175 set_data_heap(alloc_data_heap(gens,young_size,aging_size,tenured_size));
176 secure_gc = secure_gc_;
181 /* Size of the object pointed to by a tagged pointer */
182 cell factorvm::object_size(cell tagged)
184 if(immediate_p(tagged))
187 return untagged_object_size(untag<object>(tagged));
191 /* Size of the object pointed to by an untagged pointer */
192 cell factorvm::untagged_object_size(object *pointer)
194 return align8(unaligned_object_size(pointer));
198 /* Size of the data area of an object pointed to by an untagged pointer */
199 cell factorvm::unaligned_object_size(object *pointer)
201 switch(pointer->h.hi_tag())
204 return array_size((array*)pointer);
206 return array_size((bignum*)pointer);
207 case BYTE_ARRAY_TYPE:
208 return array_size((byte_array*)pointer);
210 return string_size(string_capacity((string*)pointer));
212 return tuple_size(untag<tuple_layout>(((tuple *)pointer)->layout));
214 return sizeof(quotation);
218 return sizeof(boxed_float);
222 return sizeof(alien);
224 return sizeof(wrapper);
226 return callstack_size(untag_fixnum(((callstack *)pointer)->length));
228 critical_error("Invalid header",(cell)pointer);
229 return 0; /* can't happen */
234 inline void factorvm::vmprim_size()
236 box_unsigned_cell(object_size(dpop()));
241 PRIMITIVE_GETVM()->vmprim_size();
244 /* The number of cells from the start of the object which should be scanned by
245 the GC. Some types have a binary payload at the end (string, word, DLL) which
247 cell factorvm::binary_payload_start(object *pointer)
249 switch(pointer->h.hi_tag())
251 /* these objects do not refer to other objects at all */
253 case BYTE_ARRAY_TYPE:
257 /* these objects have some binary data at the end */
259 return sizeof(word) - sizeof(cell) * 3;
261 return sizeof(cell) * 3;
263 return sizeof(cell) * 2;
265 return sizeof(quotation) - sizeof(cell) * 2;
267 return sizeof(string);
268 /* everything else consists entirely of pointers */
270 return array_size<array>(array_capacity((array*)pointer));
272 return tuple_size(untag<tuple_layout>(((tuple *)pointer)->layout));
274 return sizeof(wrapper);
276 critical_error("Invalid header",(cell)pointer);
277 return 0; /* can't happen */
282 /* Push memory usage statistics in data heap */
283 inline void factorvm::vmprim_data_room()
285 dpush(tag_fixnum((data->cards_end - data->cards) >> 10));
286 dpush(tag_fixnum((data->decks_end - data->decks) >> 10));
288 growable_array a(this);
291 for(gen = 0; gen < data->gen_count; gen++)
293 zone *z = (gen == data->nursery() ? &nursery : &data->generations[gen]);
294 a.add(tag_fixnum((z->end - z->here) >> 10));
295 a.add(tag_fixnum((z->size) >> 10));
299 dpush(a.elements.value());
304 PRIMITIVE_GETVM()->vmprim_data_room();
307 /* Disables GC and activates next-object ( -- obj ) primitive */
308 void factorvm::begin_scan()
310 heap_scan_ptr = data->generations[data->tenured()].start;
315 void factorvm::end_scan()
321 inline void factorvm::vmprim_begin_scan()
326 PRIMITIVE(begin_scan)
328 PRIMITIVE_GETVM()->vmprim_begin_scan();
331 cell factorvm::next_object()
334 general_error(ERROR_HEAP_SCAN,F,F,NULL);
336 if(heap_scan_ptr >= data->generations[data->tenured()].here)
339 object *obj = (object *)heap_scan_ptr;
340 heap_scan_ptr += untagged_object_size(obj);
341 return tag_dynamic(obj);
345 /* Push object at heap scan cursor and advance; pushes f when done */
346 inline void factorvm::vmprim_next_object()
348 dpush(next_object());
351 PRIMITIVE(next_object)
353 PRIMITIVE_GETVM()->vmprim_next_object();
357 inline void factorvm::vmprim_end_scan()
364 PRIMITIVE_GETVM()->vmprim_end_scan();
367 template<typename TYPE> void factorvm::each_object(TYPE &functor)
371 while((obj = next_object()) != F)
372 functor(tagged<object>(obj));
380 struct word_counter {
382 word_counter() : count(0) {}
383 void operator()(tagged<object> obj) { if(obj.type_p(WORD_TYPE)) count++; }
386 struct word_accumulator {
387 growable_array words;
388 word_accumulator(int count,factorvm *vm) : words(vm,count) {}
389 void operator()(tagged<object> obj) { if(obj.type_p(WORD_TYPE)) words.add(obj.value()); }
394 cell factorvm::find_all_words()
396 word_counter counter;
397 each_object(counter);
398 word_accumulator accum(counter.count,this);
401 return accum.words.elements.value();