8 /* Set by the -securegc command line argument */
11 /* new objects are allocated here */
12 VM_C_API zone nursery;
14 /* GC is off during heap walking */
19 cell init_zone(zone *z, cell size, cell start)
22 z->start = z->here = start;
23 z->end = start + size;
27 void init_card_decks()
29 cell start = align(data->seg->start,deck_size);
30 allot_markers_offset = (cell)data->allot_markers - (start >> card_bits);
31 cards_offset = (cell)data->cards - (start >> card_bits);
32 decks_offset = (cell)data->decks - (start >> deck_bits);
35 data_heap *alloc_data_heap(cell gens,
40 young_size = align(young_size,deck_size);
41 aging_size = align(aging_size,deck_size);
42 tenured_size = align(tenured_size,deck_size);
44 data_heap *data = (data_heap *)safe_malloc(sizeof(data_heap));
45 data->young_size = young_size;
46 data->aging_size = aging_size;
47 data->tenured_size = tenured_size;
48 data->gen_count = gens;
51 if(data->gen_count == 2)
52 total_size = young_size + 2 * tenured_size;
53 else if(data->gen_count == 3)
54 total_size = young_size + 2 * aging_size + 2 * tenured_size;
57 fatal_error("Invalid number of generations",data->gen_count);
58 return NULL; /* can't happen */
61 total_size += deck_size;
63 data->seg = alloc_segment(total_size);
65 data->generations = (zone *)safe_malloc(sizeof(zone) * data->gen_count);
66 data->semispaces = (zone *)safe_malloc(sizeof(zone) * data->gen_count);
68 cell cards_size = total_size >> card_bits;
69 data->allot_markers = (cell *)safe_malloc(cards_size);
70 data->allot_markers_end = data->allot_markers + cards_size;
72 data->cards = (cell *)safe_malloc(cards_size);
73 data->cards_end = data->cards + cards_size;
75 cell decks_size = total_size >> deck_bits;
76 data->decks = (cell *)safe_malloc(decks_size);
77 data->decks_end = data->decks + decks_size;
79 cell alloter = align(data->seg->start,deck_size);
81 alloter = init_zone(&data->generations[data->tenured()],tenured_size,alloter);
82 alloter = init_zone(&data->semispaces[data->tenured()],tenured_size,alloter);
84 if(data->gen_count == 3)
86 alloter = init_zone(&data->generations[data->aging()],aging_size,alloter);
87 alloter = init_zone(&data->semispaces[data->aging()],aging_size,alloter);
90 if(data->gen_count >= 2)
92 alloter = init_zone(&data->generations[data->nursery()],young_size,alloter);
93 alloter = init_zone(&data->semispaces[data->nursery()],0,alloter);
96 if(data->seg->end - alloter > deck_size)
97 critical_error("Bug in alloc_data_heap",alloter);
102 data_heap *grow_data_heap(data_heap *data, cell requested_bytes)
104 cell new_tenured_size = (data->tenured_size * 2) + requested_bytes;
106 return alloc_data_heap(data->gen_count,
112 void dealloc_data_heap(data_heap *data)
114 dealloc_segment(data->seg);
115 free(data->generations);
116 free(data->semispaces);
117 free(data->allot_markers);
123 void clear_cards(cell from, cell to)
125 /* NOTE: reverse order due to heap layout. */
126 card *first_card = addr_to_card(data->generations[to].start);
127 card *last_card = addr_to_card(data->generations[from].end);
128 memset(first_card,0,last_card - first_card);
131 void clear_decks(cell from, cell to)
133 /* NOTE: reverse order due to heap layout. */
134 card_deck *first_deck = addr_to_deck(data->generations[to].start);
135 card_deck *last_deck = addr_to_deck(data->generations[from].end);
136 memset(first_deck,0,last_deck - first_deck);
139 void clear_allot_markers(cell from, cell to)
141 /* NOTE: reverse order due to heap layout. */
142 card *first_card = addr_to_allot_marker((object *)data->generations[to].start);
143 card *last_card = addr_to_allot_marker((object *)data->generations[from].end);
144 memset(first_card,invalid_allot_marker,last_card - first_card);
147 void reset_generation(cell i)
149 zone *z = (i == data->nursery() ? &nursery : &data->generations[i]);
153 memset((void*)z->start,69,z->size);
156 /* After garbage collection, any generations which are now empty need to have
157 their allocation pointers and cards reset. */
158 void reset_generations(cell from, cell to)
161 for(i = from; i <= to; i++)
164 clear_cards(from,to);
165 clear_decks(from,to);
166 clear_allot_markers(from,to);
169 void set_data_heap(data_heap *data_)
172 nursery = data->generations[data->nursery()];
174 clear_cards(data->nursery(),data->tenured());
175 clear_decks(data->nursery(),data->tenured());
176 clear_allot_markers(data->nursery(),data->tenured());
179 void init_data_heap(cell gens,
185 set_data_heap(alloc_data_heap(gens,young_size,aging_size,tenured_size));
187 gc_locals_region = alloc_segment(getpagesize());
188 gc_locals = gc_locals_region->start - sizeof(cell);
190 gc_bignums_region = alloc_segment(getpagesize());
191 gc_bignums = gc_bignums_region->start - sizeof(cell);
193 secure_gc = secure_gc_;
198 /* Size of the object pointed to by a tagged pointer */
199 cell object_size(cell tagged)
201 if(immediate_p(tagged))
204 return untagged_object_size(untag<object>(tagged));
207 /* Size of the object pointed to by an untagged pointer */
208 cell untagged_object_size(object *pointer)
210 return align8(unaligned_object_size(pointer));
213 /* Size of the data area of an object pointed to by an untagged pointer */
214 cell unaligned_object_size(object *pointer)
216 switch(pointer->h.hi_tag())
219 return array_size((array*)pointer);
221 return array_size((bignum*)pointer);
222 case BYTE_ARRAY_TYPE:
223 return array_size((byte_array*)pointer);
225 return string_size(string_capacity((string*)pointer));
227 return tuple_size(untag<tuple_layout>(((tuple *)pointer)->layout));
229 return sizeof(quotation);
233 return sizeof(boxed_float);
237 return sizeof(alien);
239 return sizeof(wrapper);
241 return callstack_size(untag_fixnum(((callstack *)pointer)->length));
243 critical_error("Invalid header",(cell)pointer);
244 return 0; /* can't happen */
250 box_unsigned_cell(object_size(dpop()));
253 /* The number of cells from the start of the object which should be scanned by
254 the GC. Some types have a binary payload at the end (string, word, DLL) which
256 cell binary_payload_start(object *pointer)
258 switch(pointer->h.hi_tag())
260 /* these objects do not refer to other objects at all */
262 case BYTE_ARRAY_TYPE:
266 /* these objects have some binary data at the end */
268 return sizeof(word) - sizeof(cell) * 3;
270 return sizeof(cell) * 3;
272 return sizeof(cell) * 2;
274 return sizeof(quotation) - sizeof(cell) * 2;
276 return sizeof(string);
277 /* everything else consists entirely of pointers */
279 return array_size<array>(array_capacity((array*)pointer));
281 return tuple_size(untag<tuple_layout>(((tuple *)pointer)->layout));
283 return sizeof(wrapper);
285 critical_error("Invalid header",(cell)pointer);
286 return 0; /* can't happen */
290 /* Push memory usage statistics in data heap */
293 dpush(tag_fixnum((data->cards_end - data->cards) >> 10));
294 dpush(tag_fixnum((data->decks_end - data->decks) >> 10));
299 for(gen = 0; gen < data->gen_count; gen++)
301 zone *z = (gen == data->nursery() ? &nursery : &data->generations[gen]);
302 a.add(tag_fixnum((z->end - z->here) >> 10));
303 a.add(tag_fixnum((z->size) >> 10));
307 dpush(a.elements.value());
310 /* A heap walk allows useful things to be done, like finding all
311 references to an object for debugging purposes. */
314 /* Disables GC and activates next-object ( -- obj ) primitive */
317 heap_scan_ptr = data->generations[data->tenured()].start;
326 PRIMITIVE(begin_scan)
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);
344 /* Push object at heap scan cursor and advance; pushes f when done */
345 PRIMITIVE(next_object)
347 dpush(next_object());
356 template<typename T> void each_object(T &functor)
360 while((obj = next_object()) != F)
361 functor(tagged<object>(obj));
368 struct word_counter {
370 word_counter() : count(0) {}
371 void operator()(tagged<object> obj) { if(obj.type_p(WORD_TYPE)) count++; }
374 struct word_accumulator {
375 growable_array words;
376 word_accumulator(int count) : words(count) {}
377 void operator()(tagged<object> obj) { if(obj.type_p(WORD_TYPE)) words.add(obj.value()); }
382 cell find_all_words()
384 word_counter counter;
385 each_object(counter);
386 word_accumulator accum(counter.count);
389 return accum.words.elements.value();