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

VM: removes the collector class 

The cheneys_algorithm() method can be moved to slot_visitor (because it
kind of visists objects), and then there is no need for the collector
class.
locals-and-roots
Björn Lindqvist 2016-05-04 17:52:04 +02:00
parent f629a95b03
commit 583fb5825b
6 changed files with 62 additions and 72 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
vm/aging_collector.cpp
View File

@ -26,26 +26,26 @@ void factor_vm::collect_aging() {
raised. */
current_gc->op = collect_to_tenured_op;
collector<tenured_space, to_tenured_policy> collector(this,
data->tenured,
to_tenured_policy(this));
gc_workhorse<tenured_space, to_tenured_policy>
workhorse(this, data->tenured, to_tenured_policy(this));
slot_visitor<gc_workhorse<tenured_space, to_tenured_policy>>
visitor(this, workhorse);
gc_event* event = current_gc->event;
if (event)
event->reset_timer();
collector.visitor.visit_cards(data->tenured, card_points_to_aging, 0xff);
if (event) {
event->ended_card_scan(collector.visitor.cards_scanned,
collector.visitor.decks_scanned);
}
visitor.visit_cards(data->tenured, card_points_to_aging, 0xff);
if (event)
event->ended_card_scan(visitor.cards_scanned, visitor.decks_scanned);
if (event)
event->reset_timer();
collector.visitor.visit_code_heap_roots(&code->points_to_aging);
visitor.visit_code_heap_roots(&code->points_to_aging);
if (event)
event->ended_code_scan(code->points_to_aging.size());
collector.visitor.visit_mark_stack(&mark_stack);
visitor.visit_mark_stack(&mark_stack);
}
{
/* If collection fails here, do a to_tenured collection. */
@ -54,12 +54,15 @@ void factor_vm::collect_aging() {
std::swap(data->aging, data->aging_semispace);
data->reset_aging();
collector<aging_space, aging_policy> collector(this,
data->aging,
aging_policy(this));
aging_space *target = data->aging;
gc_workhorse<aging_space, aging_policy>
workhorse(this, target, aging_policy(this));
slot_visitor<gc_workhorse<aging_space, aging_policy>>
visitor(this, workhorse);
cell scan = target->start + target->occupied_space();
collector.visitor.visit_all_roots();
collector.cheneys_algorithm();
visitor.visit_all_roots();
visitor.cheneys_algorithm(target, scan);
data->reset_nursery();
code->clear_remembered_set();

21
vm/collector.hpp
View File

@ -59,25 +59,4 @@ struct gc_workhorse : no_fixup {
}
};
template <typename TargetGeneration, typename Policy> struct collector {
data_heap* data;
TargetGeneration* target;
slot_visitor<gc_workhorse<TargetGeneration, Policy> > visitor;
cell scan;
collector(factor_vm* parent, TargetGeneration* target, Policy policy)
: data(parent->data),
target(target),
visitor(parent, gc_workhorse<TargetGeneration, Policy>(parent, target, policy)) {
scan = target->start + target->occupied_space();
}
void cheneys_algorithm() {
while (scan && scan < this->target->here) {
this->visitor.visit_object((object*)scan);
scan = this->target->next_object_after(scan);
}
}
};
}

5
vm/full_collector.cpp
View File

@ -42,9 +42,8 @@ void factor_vm::update_code_roots_for_sweep() {
void factor_vm::collect_mark_impl() {
gc_workhorse<tenured_space, full_policy>
workhorse(this, this->data->tenured, full_policy(this));
slot_visitor<gc_workhorse<tenured_space, full_policy> >
visitor(this, workhorse);
slot_visitor<gc_workhorse<tenured_space, full_policy>>
visitor(this, workhorse);
mark_stack.clear();

28
vm/nursery_collector.cpp
View File

@ -20,31 +20,31 @@ void factor_vm::collect_nursery() {
/* Copy live objects from the nursery (as determined by the root set and
marked cards in aging and tenured) to aging space. */
nursery_policy policy(this->data->nursery);
collector<aging_space, nursery_policy>
collector(this, this->data->aging, policy);
gc_workhorse<aging_space, nursery_policy>
workhorse(this, data->aging, nursery_policy(data->nursery));
slot_visitor<gc_workhorse<aging_space, nursery_policy>>
visitor(this, workhorse);
collector.visitor.visit_all_roots();
cell scan = data->aging->start + data->aging->occupied_space();
visitor.visit_all_roots();
gc_event* event = current_gc->event;
if (event)
event->reset_timer();
collector.visitor.visit_cards(data->tenured, card_points_to_nursery,
card_points_to_nursery);
collector.visitor.visit_cards(data->aging, card_points_to_nursery, 0xff);
if (event) {
event->ended_card_scan(collector.visitor.cards_scanned,
collector.visitor.decks_scanned);
}
visitor.visit_cards(data->tenured, card_points_to_nursery,
card_points_to_nursery);
visitor.visit_cards(data->aging, card_points_to_nursery, 0xff);
if (event)
event->ended_card_scan(visitor.cards_scanned, visitor.decks_scanned);
if (event)
event->reset_timer();
collector.visitor.visit_code_heap_roots(&code->points_to_nursery);
visitor.visit_code_heap_roots(&code->points_to_nursery);
if (event)
event->ended_code_scan(code->points_to_nursery.size());
collector.cheneys_algorithm();
visitor.cheneys_algorithm(data->aging, scan);
data->reset_nursery();
code->points_to_nursery.clear();

26
vm/slot_visitor.hpp
View File

@ -152,11 +152,12 @@ template <typename Fixup> struct slot_visitor {
template <typename SourceGeneration>
cell visit_card(SourceGeneration* gen, cell index, cell start);
template <typename SourceGeneration>
void visit_cards(SourceGeneration* gen, card mask, card unmask);
void visit_code_heap_roots(std::set<code_block*>* remembered_set);
template <typename TargetGeneration>
void cheneys_algorithm(TargetGeneration* gen, cell scan);
};
template <typename Fixup>
@ -599,12 +600,21 @@ void slot_visitor<Fixup>::visit_cards(SourceGeneration* gen,
template <typename Fixup>
void slot_visitor<Fixup>::visit_code_heap_roots(std::set<code_block*>* remembered_set) {
FACTOR_FOR_EACH(*remembered_set) {
code_block* compiled = *iter;
visit_code_block_objects(compiled);
visit_embedded_literals(compiled);
compiled->flush_icache();
}
FACTOR_FOR_EACH(*remembered_set) {
code_block* compiled = *iter;
visit_code_block_objects(compiled);
visit_embedded_literals(compiled);
compiled->flush_icache();
}
}
template <typename Fixup>
template <typename TargetGeneration>
void slot_visitor<Fixup>::cheneys_algorithm(TargetGeneration* gen, cell scan) {
while (scan && scan < gen->here) {
visit_object((object*)scan);
scan = gen->next_object_after(scan);
}
}
}

21
vm/to_tenured_collector.cpp
View File

@ -4,30 +4,29 @@ namespace factor {
void factor_vm::collect_to_tenured() {
/* Copy live objects from aging space to tenured space. */
collector<tenured_space, to_tenured_policy> collector(this,
data->tenured,
to_tenured_policy(this));
gc_workhorse<tenured_space, to_tenured_policy>
workhorse(this, data->tenured, to_tenured_policy(this));
slot_visitor<gc_workhorse<tenured_space, to_tenured_policy>>
visitor(this, workhorse);
mark_stack.clear();
collector.visitor.visit_all_roots();
visitor.visit_all_roots();
gc_event* event = current_gc->event;
if (event)
event->reset_timer();
collector.visitor.visit_cards(data->tenured, card_points_to_aging, 0xff);
if (event) {
event->ended_card_scan(collector.visitor.cards_scanned,
collector.visitor.decks_scanned);
}
visitor.visit_cards(data->tenured, card_points_to_aging, 0xff);
if (event)
event->ended_card_scan(visitor.cards_scanned, visitor.decks_scanned);
if (event)
event->reset_timer();
collector.visitor.visit_code_heap_roots(&code->points_to_aging);
visitor.visit_code_heap_roots(&code->points_to_aging);
if (event)
event->ended_code_scan(code->points_to_aging.size());
collector.visitor.visit_mark_stack(&mark_stack);
visitor.visit_mark_stack(&mark_stack);
data->reset_nursery();
data->reset_aging();