steve
/
factor
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

vm: split off parts of data_gc into sub-files and clean up logic

db4
Slava Pestov 2009-10-08 02:10:28 -05:00
parent db29d60e8e
commit dbf0dd4a2d
10 changed files with 112 additions and 608 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
vm/aging_collector.cpp
View File

@ -7,13 +7,21 @@ aging_collector::aging_collector(factor_vm *myvm_) :
copying_collector<aging_space,aging_policy> copying_collector<aging_space,aging_policy>
(myvm_,myvm_->data->aging,aging_policy(myvm_)) {} (myvm_,myvm_->data->aging,aging_policy(myvm_)) {}
void aging_collector::go() void factor_vm::collect_aging()
{ {
trace_roots(); std::swap(data->aging,data->aging_semispace);
trace_contexts(); reset_generation(data->aging);
trace_cards(data->tenured);
trace_code_heap_roots(); aging_collector collector(this);
cheneys_algorithm();
collector.trace_roots();
collector.trace_contexts();
collector.trace_cards(data->tenured);
collector.trace_code_heap_roots();
collector.cheneys_algorithm();
update_dirty_code_blocks();
nursery.here = nursery.start;
} }
} }

1
vm/aging_collector.hpp
View File

@ -18,7 +18,6 @@ struct aging_policy {
struct aging_collector : copying_collector<aging_space,aging_policy> { struct aging_collector : copying_collector<aging_space,aging_policy> {
aging_collector(factor_vm *myvm_); aging_collector(factor_vm *myvm_);
void go();
}; };
} }

534
vm/data_gc.cpp
View File

@ -12,345 +12,6 @@ gc_state::gc_state(data_heap *data_, bool growing_data_heap_, cell collecting_ge
gc_state::~gc_state() { } gc_state::~gc_state() { }
template<typename Strategy> object *factor_vm::resolve_forwarding(object *untagged, Strategy &strategy)
{
check_data_pointer(untagged);
/* is there another forwarding pointer? */
while(untagged->h.forwarding_pointer_p())
untagged = untagged->h.forwarding_pointer();
/* we've found the destination */
untagged->h.check_header();
return untagged;
}
template<typename Strategy> void factor_vm::trace_handle(cell *handle, Strategy &strategy)
{
cell pointer = *handle;
if(!immediate_p(pointer))
{
object *untagged = untag<object>(pointer);
if(strategy.should_copy_p(untagged))
{
object *forwarding = resolve_forwarding(untagged,strategy);
if(forwarding == untagged)
untagged = strategy.copy_object(untagged);
else if(strategy.should_copy_p(forwarding))
untagged = strategy.copy_object(forwarding);
else
untagged = forwarding;
*handle = RETAG(untagged,TAG(pointer));
}
}
}
template<typename Strategy> void factor_vm::trace_slots(object *ptr, Strategy &strategy)
{
cell *slot = (cell *)ptr;
cell *end = (cell *)((cell)ptr + binary_payload_start(ptr));
if(slot != end)
{
slot++;
for(; slot < end; slot++) trace_handle(slot,strategy);
}
}
template<typename Strategy> object *factor_vm::promote_object(object *untagged, Strategy &strategy)
{
cell size = untagged_object_size(untagged);
object *newpointer = strategy.allot(size);
if(!newpointer) longjmp(current_gc->gc_unwind,1);
generation_statistics *s = &gc_stats.generations[current_gc->collecting_gen];
s->object_count++;
s->bytes_copied += size;
memcpy(newpointer,untagged,size);
untagged->h.forward_to(newpointer);
return newpointer;
}
template<typename Strategy> void factor_vm::trace_card(card *ptr, old_space *gen, Strategy &strategy)
{
cell card_start = card_to_addr(ptr);
cell card_scan = card_start + gen->card_offset(card_start);
cell card_end = card_to_addr(ptr + 1);
if(gen->here < card_end) card_end = gen->here;
strategy.copy_reachable_objects(card_scan,&card_end);
gc_stats.cards_scanned++;
}
template<typename Strategy> void factor_vm::trace_card_deck(card_deck *deck, old_space *gen, card mask, card unmask, Strategy &strategy)
{
card *first_card = deck_to_card(deck);
card *last_card = deck_to_card(deck + 1);
u32 *quad_ptr;
u32 quad_mask = mask | (mask << 8) | (mask << 16) | (mask << 24);
for(quad_ptr = (u32 *)first_card; quad_ptr < (u32 *)last_card; quad_ptr++)
{
if(*quad_ptr & quad_mask)
{
card *ptr = (card *)quad_ptr;
int card;
for(card = 0; card < 4; card++)
{
if(ptr[card] & mask)
{
trace_card(&ptr[card],gen,strategy);
ptr[card] &= ~unmask;
}
}
}
}
gc_stats.decks_scanned++;
}
/* Trace all objects referenced from marked cards */
template<typename Strategy> void factor_vm::trace_cards(cell gen, old_space *z, Strategy &strategy)
{
u64 start_time = current_micros();
card_deck *first_deck = addr_to_deck(z->start);
card_deck *last_deck = addr_to_deck(z->end);
card mask, unmask;
/* if we are collecting the nursery, we care about old->nursery pointers
but not old->aging pointers */
if(current_gc->collecting_nursery_p())
{
mask = card_points_to_nursery;
/* after the collection, no old->nursery pointers remain
anywhere, but old->aging pointers might remain in tenured
space */
if(gen == tenured_gen)
unmask = card_points_to_nursery;
/* after the collection, all cards in aging space can be
cleared */
else if(gen == aging_gen)
unmask = card_mark_mask;
else
{
critical_error("bug in trace_generation_cards",gen);
return;
}
}
/* if we are collecting aging space into tenured space, we care about
all old->nursery and old->aging pointers. no old->aging pointers can
remain */
else if(current_gc->collecting_aging_p())
{
if(current_gc->collecting_aging_again)
{
mask = card_points_to_aging;
unmask = card_mark_mask;
}
/* after we collect aging space into the aging semispace, no
old->nursery pointers remain but tenured space might still have
pointers to aging space. */
else
{
mask = card_points_to_aging;
unmask = card_points_to_nursery;
}
}
else
{
critical_error("bug in trace_generation_cards",gen);
return;
}
card_deck *ptr;
for(ptr = first_deck; ptr < last_deck; ptr++)
{
if(*ptr & mask)
{
trace_card_deck(ptr,z,mask,unmask,strategy);
*ptr &= ~unmask;
}
}
gc_stats.card_scan_time += (current_micros() - start_time);
}
/* Copy all tagged pointers in a range of memory */
template<typename Strategy> void factor_vm::trace_stack_elements(segment *region, cell top, Strategy &strategy)
{
cell ptr = region->start;
for(; ptr <= top; ptr += sizeof(cell))
trace_handle((cell*)ptr,strategy);
}
template<typename Strategy> void factor_vm::trace_registered_locals(Strategy &strategy)
{
std::vector<cell>::const_iterator iter = gc_locals.begin();
std::vector<cell>::const_iterator end = gc_locals.end();
for(; iter < end; iter++)
trace_handle((cell *)(*iter),strategy);
}
template<typename Strategy> void factor_vm::trace_registered_bignums(Strategy &strategy)
{
std::vector<cell>::const_iterator iter = gc_bignums.begin();
std::vector<cell>::const_iterator end = gc_bignums.end();
for(; iter < end; iter++)
{
cell *handle = (cell *)(*iter);
if(*handle)
{
*handle |= BIGNUM_TYPE;
trace_handle(handle,strategy);
*handle &= ~BIGNUM_TYPE;
}
}
}
/* Copy roots over at the start of GC, namely various constants, stacks,
the user environment and extra roots registered by local_roots.hpp */
template<typename Strategy> void factor_vm::trace_roots(Strategy &strategy)
{
trace_handle(&T,strategy);
trace_handle(&bignum_zero,strategy);
trace_handle(&bignum_pos_one,strategy);
trace_handle(&bignum_neg_one,strategy);
trace_registered_locals(strategy);
trace_registered_bignums(strategy);
int i;
for(i = 0; i < USER_ENV; i++)
trace_handle(&userenv[i],strategy);
}
template<typename Strategy> struct stack_frame_marker {
factor_vm *myvm;
Strategy &strategy;
explicit stack_frame_marker(factor_vm *myvm_, Strategy &strategy_) :
myvm(myvm_), strategy(strategy_) {}
void operator()(stack_frame *frame)
{
myvm->mark_code_block(myvm->frame_code(frame),strategy);
}
};
/* Mark code blocks executing in currently active stack frames. */
template<typename Strategy> void factor_vm::mark_active_blocks(context *stacks, Strategy &strategy)
{
if(current_gc->collecting_tenured_p())
{
cell top = (cell)stacks->callstack_top;
cell bottom = (cell)stacks->callstack_bottom;
stack_frame_marker<Strategy> marker(this,strategy);
iterate_callstack(top,bottom,marker);
}
}
template<typename Strategy> void factor_vm::mark_object_code_block(object *object, Strategy &strategy)
{
switch(object->h.hi_tag())
{
case WORD_TYPE:
{
word *w = (word *)object;
if(w->code)
mark_code_block(w->code,strategy);
if(w->profiling)
mark_code_block(w->profiling,strategy);
break;
}
case QUOTATION_TYPE:
{
quotation *q = (quotation *)object;
if(q->code)
mark_code_block(q->code,strategy);
break;
}
case CALLSTACK_TYPE:
{
callstack *stack = (callstack *)object;
stack_frame_marker<Strategy> marker(this,strategy);
iterate_callstack_object(stack,marker);
break;
}
}
}
template<typename Strategy> void factor_vm::trace_contexts(Strategy &strategy)
{
save_stacks();
context *stacks = stack_chain;
while(stacks)
{
trace_stack_elements(stacks->datastack_region,stacks->datastack,strategy);
trace_stack_elements(stacks->retainstack_region,stacks->retainstack,strategy);
trace_handle(&stacks->catchstack_save,strategy);
trace_handle(&stacks->current_callback_save,strategy);
mark_active_blocks(stacks,strategy);
stacks = stacks->next;
}
}
/* Trace all literals referenced from a code block. Only for aging and nursery collections */
template<typename Strategy> void factor_vm::trace_literal_references(code_block *compiled, Strategy &strategy)
{
trace_handle(&compiled->owner,strategy);
trace_handle(&compiled->literals,strategy);
trace_handle(&compiled->relocation,strategy);
}
/* Trace literals referenced from all code blocks. Only for aging and nursery collections */
template<typename Strategy> void factor_vm::trace_code_heap_roots(Strategy &strategy)
{
if(current_gc->collecting_gen >= code->youngest_referenced_generation)
{
unordered_map<code_block *,cell>::const_iterator iter = code->remembered_set.begin();
unordered_map<code_block *,cell>::const_iterator end = code->remembered_set.end();
for(; iter != end; iter++)
{
if(current_gc->collecting_gen >= iter->second)
trace_literal_references(iter->first,strategy);
}
gc_stats.code_heap_scans++;
}
}
/* Mark all literals referenced from a word XT. Only for tenured
collections */
template<typename Strategy> void factor_vm::mark_code_block(code_block *compiled, Strategy &strategy)
{
check_code_address((cell)compiled);
code->mark_block(compiled);
trace_literal_references(compiled,strategy);
}
struct literal_and_word_reference_updater { struct literal_and_word_reference_updater {
factor_vm *myvm; factor_vm *myvm;
@ -398,193 +59,6 @@ void factor_vm::update_dirty_code_blocks()
code->youngest_referenced_generation = gen; code->youngest_referenced_generation = gen;
} }
template<typename Strategy>
cheney_collector<Strategy>::cheney_collector(factor_vm *myvm_, old_space *target_)
: myvm(myvm_), current_gc(myvm_->current_gc), target(target_)
{
scan = target->here;
}
template<typename Strategy> Strategy &cheney_collector<Strategy>::strategy()
{
return static_cast<Strategy &>(*this);
}
template<typename Strategy> object *cheney_collector<Strategy>::allot(cell size)
{
return target->allot(size);
}
template<typename Strategy> object *cheney_collector<Strategy>::copy_object(object *untagged)
{
return myvm->promote_object(untagged,strategy());
}
template<typename Strategy> bool cheney_collector<Strategy>::should_copy_p(object *pointer)
{
return strategy().should_copy_p(pointer);
}
template<typename Strategy> cell cheney_collector<Strategy>::trace_next(cell scan)
{
object *obj = (object *)scan;
myvm->trace_slots(obj,strategy());
return scan + myvm->untagged_object_size(obj);
}
template<typename Strategy> void cheney_collector<Strategy>::go()
{
strategy().copy_reachable_objects(scan,&target->here);
}
struct nursery_strategy : cheney_collector<nursery_strategy>
{
explicit nursery_strategy(factor_vm *myvm_, old_space *target_) :
cheney_collector<nursery_strategy>(myvm_,target_) {}
bool should_copy_p(object *untagged)
{
return myvm->nursery.contains_p(untagged);
}
void copy_reachable_objects(cell scan, cell *end)
{
while(scan < *end) scan = trace_next(scan);
}
};
struct aging_strategy : cheney_collector<aging_strategy>
{
zone *tenured;
explicit aging_strategy(factor_vm *myvm_, old_space *target_) :
cheney_collector<aging_strategy>(myvm_,target_),
tenured(myvm->data->tenured) {}
bool should_copy_p(object *untagged)
{
if(target->contains_p(untagged))
return false;
else
return !tenured->contains_p(untagged);
}
void copy_reachable_objects(cell scan, cell *end)
{
while(scan < *end) scan = trace_next(scan);
}
};
struct aging_agian_strategy : cheney_collector<aging_agian_strategy>
{
explicit aging_agian_strategy(factor_vm *myvm_, old_space *target_) :
cheney_collector<aging_agian_strategy>(myvm_,target_) {}
bool should_copy_p(object *untagged)
{
return !target->contains_p(untagged);
}
void copy_reachable_objects(cell scan, cell *end)
{
while(scan < *end) scan = trace_next(scan);
}
};
struct tenured_strategy : cheney_collector<tenured_strategy>
{
explicit tenured_strategy(factor_vm *myvm_, old_space *target_) :
cheney_collector<tenured_strategy>(myvm_,target_) {}
bool should_copy_p(object *untagged)
{
return !target->contains_p(untagged);
}
void copy_reachable_objects(cell scan, cell *end)
{
while(scan < *end)
{
myvm->mark_object_code_block(myvm->untag<object>(scan),*this);
scan = trace_next(scan);
}
}
};
void factor_vm::collect_nursery()
{
nursery_strategy collector(this,data->aging);
trace_roots(collector);
trace_contexts(collector);
trace_cards(tenured_gen,data->tenured,collector);
trace_cards(aging_gen,data->aging,collector);
trace_code_heap_roots(collector);
collector.go();
update_dirty_code_blocks();
nursery.here = nursery.start;
}
void factor_vm::collect_aging()
{
std::swap(data->aging,data->aging_semispace);
reset_generation(data->aging);
aging_strategy collector(this,data->aging);
trace_roots(collector);
trace_contexts(collector);
trace_cards(tenured_gen,data->tenured,collector);
trace_code_heap_roots(collector);
collector.go();
update_dirty_code_blocks();
nursery.here = nursery.start;
}
void factor_vm::collect_aging_again()
{
aging_agian_strategy collector(this,data->tenured);
trace_roots(collector);
trace_contexts(collector);
trace_cards(tenured_gen,data->tenured,collector);
trace_code_heap_roots(collector);
collector.go();
update_dirty_code_blocks();
reset_generation(data->aging);
nursery.here = nursery.start;
}
void factor_vm::collect_tenured(cell requested_bytes, bool trace_contexts_)
{
if(current_gc->growing_data_heap)
{
current_gc->old_data_heap = data;
set_data_heap(grow_data_heap(current_gc->old_data_heap,requested_bytes));
}
else
{
std::swap(data->tenured,data->tenured_semispace);
reset_generation(data->tenured);
}
tenured_strategy collector(this,data->tenured);
trace_roots(collector);
if(trace_contexts_) trace_contexts(collector);
collector.go();
free_unmarked_code_blocks();
reset_generation(data->aging);
nursery.here = nursery.start;
if(current_gc->growing_data_heap)
delete current_gc->old_data_heap;
}
void factor_vm::record_gc_stats() void factor_vm::record_gc_stats()
{ {
generation_statistics *s = &gc_stats.generations[current_gc->collecting_gen]; generation_statistics *s = &gc_stats.generations[current_gc->collecting_gen];
@ -599,11 +73,13 @@ void factor_vm::record_gc_stats()
/* Collect gen and all younger generations. /* Collect gen and all younger generations.
If growing_data_heap_ is true, we must grow the data heap to such a size that If growing_data_heap_ is true, we must grow the data heap to such a size that
an allocation of requested_bytes won't fail */ an allocation of requested_bytes won't fail */
void factor_vm::garbage_collection(cell collecting_gen_, bool growing_data_heap_, bool trace_contexts_, cell requested_bytes) void factor_vm::garbage_collection(cell collecting_gen_, bool growing_data_heap_, bool trace_contexts_p, cell requested_bytes)
{ {
assert(!gc_off); assert(!gc_off);
assert(!current_gc); assert(!current_gc);
save_stacks();
current_gc = new gc_state(data,growing_data_heap_,collecting_gen_); current_gc = new gc_state(data,growing_data_heap_,collecting_gen_);
/* Keep trying to GC higher and higher generations until we don't run out /* Keep trying to GC higher and higher generations until we don't run out
@ -640,12 +116,12 @@ void factor_vm::garbage_collection(cell collecting_gen_, bool growing_data_heap_
else if(current_gc->collecting_aging_p()) else if(current_gc->collecting_aging_p())
{ {
if(current_gc->collecting_aging_again) if(current_gc->collecting_aging_again)
collect_aging_again(); collect_to_tenured();
else else
collect_aging(); collect_aging();
} }
else if(current_gc->collecting_tenured_p()) else if(current_gc->collecting_tenured_p())
collect_tenured(requested_bytes,trace_contexts_); collect_full(requested_bytes,trace_contexts_p);
record_gc_stats(); record_gc_stats();

15
vm/data_gc.hpp
View File

@ -63,21 +63,6 @@ struct gc_state {
} }
}; };
template<typename Strategy> struct cheney_collector {
factor_vm *myvm;
gc_state *current_gc;
old_space *target;
cell scan;
explicit cheney_collector(factor_vm *myvm_, old_space *target);
Strategy &strategy();
object *allot(cell size);
cell trace_next(cell scan);
object *copy_object(object *untagged);
bool should_copy_p(object *untagged);
void go();
};
VM_C_API void inline_gc(cell *gc_roots_base, cell gc_roots_size, factor_vm *myvm); VM_C_API void inline_gc(cell *gc_roots_base, cell gc_roots_size, factor_vm *myvm);
} }

76
vm/full_collector.cpp
View File

@ -3,9 +3,8 @@
namespace factor namespace factor
{ {
full_collector::full_collector(factor_vm *myvm_, bool trace_contexts_p_) : full_collector::full_collector(factor_vm *myvm_) :
copying_collector<tenured_space,full_policy>(myvm_,myvm_->data->tenured,full_policy(myvm_)), copying_collector<tenured_space,full_policy>(myvm_,myvm_->data->tenured,full_policy(myvm_)) {}
trace_contexts_p(trace_contexts_p_) {}
struct stack_frame_marker { struct stack_frame_marker {
factor_vm *myvm; factor_vm *myvm;
@ -21,22 +20,29 @@ struct stack_frame_marker {
}; };
/* Mark code blocks executing in currently active stack frames. */ /* Mark code blocks executing in currently active stack frames. */
void full_collector::mark_active_blocks(context *stacks) void full_collector::mark_active_blocks()
{ {
cell top = (cell)stacks->callstack_top; context *stacks = this->myvm->stack_chain;
cell bottom = (cell)stacks->callstack_bottom;
stack_frame_marker marker(this); while(stacks)
myvm->iterate_callstack(top,bottom,marker); {
cell top = (cell)stacks->callstack_top;
cell bottom = (cell)stacks->callstack_bottom;
stack_frame_marker marker(this);
myvm->iterate_callstack(top,bottom,marker);
stacks = stacks->next;
}
} }
void full_collector::mark_object_code_block(object *object) void full_collector::mark_object_code_block(object *obj)
{ {
switch(object->h.hi_tag()) switch(obj->h.hi_tag())
{ {
case WORD_TYPE: case WORD_TYPE:
{ {
word *w = (word *)object; word *w = (word *)obj;
if(w->code) if(w->code)
mark_code_block(w->code); mark_code_block(w->code);
if(w->profiling) if(w->profiling)
@ -45,14 +51,14 @@ void full_collector::mark_object_code_block(object *object)
} }
case QUOTATION_TYPE: case QUOTATION_TYPE:
{ {
quotation *q = (quotation *)object; quotation *q = (quotation *)obj;
if(q->code) if(q->code)
mark_code_block(q->code); mark_code_block(q->code);
break; break;
} }
case CALLSTACK_TYPE: case CALLSTACK_TYPE:
{ {
callstack *stack = (callstack *)object; callstack *stack = (callstack *)obj;
stack_frame_marker marker(this); stack_frame_marker marker(this);
myvm->iterate_callstack_object(stack,marker); myvm->iterate_callstack_object(stack,marker);
break; break;
@ -78,11 +84,47 @@ void full_collector::mark_code_block(code_block *compiled)
trace_literal_references(compiled); trace_literal_references(compiled);
} }
void full_collector::go() void full_collector::cheneys_algorithm()
{ {
trace_roots(); while(scan && scan < target->here)
if(trace_contexts_p) trace_contexts(); {
cheneys_algorithm(); object *obj = (object *)scan;
this->trace_slots(obj);
this->mark_object_code_block(obj);
scan = target->next_object_after(this->myvm,scan);
}
}
void factor_vm::collect_full(cell requested_bytes, bool trace_contexts_p)
{
if(current_gc->growing_data_heap)
{
current_gc->old_data_heap = data;
set_data_heap(grow_data_heap(current_gc->old_data_heap,requested_bytes));
}
else
{
std::swap(data->tenured,data->tenured_semispace);
reset_generation(data->tenured);
}
full_collector collector(this);
collector.trace_roots();
if(trace_contexts_p)
{
collector.trace_contexts();
collector.mark_active_blocks();
}
collector.cheneys_algorithm();
free_unmarked_code_blocks();
reset_generation(data->aging);
nursery.here = nursery.start;
if(current_gc->growing_data_heap)
delete current_gc->old_data_heap;
} }
} }

6
vm/full_collector.hpp
View File

@ -16,12 +16,12 @@ struct full_policy {
struct full_collector : copying_collector<tenured_space,full_policy> { struct full_collector : copying_collector<tenured_space,full_policy> {
bool trace_contexts_p; bool trace_contexts_p;
full_collector(factor_vm *myvm_, bool trace_contexts_p_); full_collector(factor_vm *myvm_);
void mark_active_blocks(context *stacks); void mark_active_blocks();
void mark_object_code_block(object *object); void mark_object_code_block(object *object);
void trace_literal_references(code_block *compiled); void trace_literal_references(code_block *compiled);
void mark_code_block(code_block *compiled); void mark_code_block(code_block *compiled);
void go(); void cheneys_algorithm();
}; };
} }

20
vm/nursery_collector.cpp
View File

@ -7,14 +7,20 @@ nursery_collector::nursery_collector(factor_vm *myvm_) :
copying_collector<aging_space,nursery_policy> copying_collector<aging_space,nursery_policy>
(myvm_,myvm_->data->aging,nursery_policy(myvm_)) {} (myvm_,myvm_->data->aging,nursery_policy(myvm_)) {}
void nursery_collector::go() void factor_vm::collect_nursery()
{ {
trace_roots(); nursery_collector collector(this);
trace_contexts();
trace_cards(data->tenured); collector.trace_roots();
trace_cards(data->aging); collector.trace_contexts();
trace_code_heap_roots(); collector.trace_cards(data->tenured);
cheneys_algorithm(); collector.trace_cards(data->aging);
collector.trace_code_heap_roots();
collector.cheneys_algorithm();
update_dirty_code_blocks();
nursery.here = nursery.start;
} }
} }

1
vm/nursery_collector.hpp
View File

@ -14,7 +14,6 @@ struct nursery_policy {
struct nursery_collector : copying_collector<aging_space,nursery_policy> { struct nursery_collector : copying_collector<aging_space,nursery_policy> {
nursery_collector(factor_vm *myvm_); nursery_collector(factor_vm *myvm_);
void go();
}; };
} }

18
vm/to_tenured_collector.cpp
View File

@ -7,13 +7,19 @@ to_tenured_collector::to_tenured_collector(factor_vm *myvm_) :
copying_collector<tenured_space,to_tenured_policy> copying_collector<tenured_space,to_tenured_policy>
(myvm_,myvm_->data->tenured,to_tenured_policy(myvm_)) {} (myvm_,myvm_->data->tenured,to_tenured_policy(myvm_)) {}
void to_tenured_collector::go() void factor_vm::collect_to_tenured()
{ {
trace_roots(); to_tenured_collector collector(this);
trace_contexts();
trace_cards(data->tenured); collector.trace_roots();
trace_code_heap_roots(); collector.trace_contexts();
cheneys_algorithm(); collector.trace_cards(data->tenured);
collector.trace_code_heap_roots();
collector.cheneys_algorithm();
update_dirty_code_blocks();
reset_generation(data->aging);
nursery.here = nursery.start;
} }
} }

29
vm/vm.hpp
View File

@ -205,7 +205,7 @@ struct factor_vm
int bignum_unsigned_logbitp(int shift, bignum * bignum); int bignum_unsigned_logbitp(int shift, bignum * bignum);
bignum *digit_stream_to_bignum(unsigned int n_digits, unsigned int (*producer)(unsigned int, factor_vm *), unsigned int radix, int negative_p); bignum *digit_stream_to_bignum(unsigned int n_digits, unsigned int (*producer)(unsigned int, factor_vm *), unsigned int radix, int negative_p);
//data_heap //data heap
void init_card_decks(); void init_card_decks();
data_heap *grow_data_heap(data_heap *data, cell requested_bytes); data_heap *grow_data_heap(data_heap *data, cell requested_bytes);
void clear_cards(old_space *gen); void clear_cards(old_space *gen);
@ -262,32 +262,15 @@ struct factor_vm
*addr_to_deck((cell)obj) = card_mark_mask; *addr_to_deck((cell)obj) = card_mark_mask;
} }
// data_gc // gc
template<typename Strategy> object *resolve_forwarding(object *untagged, Strategy &strategy);
template<typename Strategy> void trace_handle(cell *handle, Strategy &strategy);
template<typename Strategy> object *promote_object(object *pointer, Strategy &strategy);
template<typename Strategy> void trace_slots(object *ptr, Strategy &strategy);
template<typename Strategy> void trace_card(card *ptr, old_space *gen, Strategy &strategy);
template<typename Strategy> void trace_card_deck(card_deck *deck, old_space *gen, card mask, card unmask, Strategy &strategy);
template<typename Strategy> void trace_cards(cell gen, old_space *z, Strategy &strategy);
template<typename Strategy> void trace_stack_elements(segment *region, cell top, Strategy &strategy);
template<typename Strategy> void trace_registered_locals(Strategy &strategy);
template<typename Strategy> void trace_registered_bignums(Strategy &strategy);
template<typename Strategy> void trace_roots(Strategy &strategy);
template<typename Strategy> void mark_active_blocks(context *stacks, Strategy &strategy);
template<typename Strategy> void trace_contexts(Strategy &strategy);
template<typename Strategy> void trace_literal_references(code_block *compiled, Strategy &strategy);
template<typename Strategy> void trace_code_heap_roots(Strategy &strategy);
template<typename Strategy> void mark_code_block(code_block *compiled, Strategy &strategy);
template<typename Strategy> void mark_object_code_block(object *object, Strategy &strategy);
void free_unmarked_code_blocks(); void free_unmarked_code_blocks();
void update_dirty_code_blocks(); void update_dirty_code_blocks();
void collect_nursery(); void collect_nursery();
void collect_aging(); void collect_aging();
void collect_aging_again(); void collect_to_tenured();
void collect_tenured(cell requested_bytes, bool trace_contexts_); void collect_full(cell requested_bytes, bool trace_contexts_p);
void record_gc_stats(); void record_gc_stats();
void garbage_collection(cell gen, bool growing_data_heap, bool trace_contexts, cell requested_bytes); void garbage_collection(cell gen, bool growing_data_heap, bool trace_contexts_p, cell requested_bytes);
void gc(); void gc();
void primitive_gc(); void primitive_gc();
void primitive_gc_stats(); void primitive_gc_stats();
@ -528,7 +511,7 @@ struct factor_vm
code_block *allot_code_block(cell size, cell type); code_block *allot_code_block(cell size, cell type);
code_block *add_code_block(cell type, cell code_, cell labels_, cell owner_, cell relocation_, cell literals_); code_block *add_code_block(cell type, cell code_, cell labels_, cell owner_, cell relocation_, cell literals_);
//code_heap //code heap
inline void check_code_pointer(cell ptr) inline void check_code_pointer(cell ptr)
{ {
#ifdef FACTOR_DEBUG #ifdef FACTOR_DEBUG