#include "master.hpp"
namespace factor
{
gc_event::gc_event(gc_op op_, factor_vm *parent) :
op(op_),
cards_scanned(0),
decks_scanned(0),
code_blocks_scanned(0),
start_time(current_micros()),
card_scan_time(0),
code_scan_time(0),
data_sweep_time(0),
code_sweep_time(0),
compaction_time(0)
{
nursery_size_before = parent->nursery.occupied_space();
aging_size_before = parent->data->aging->occupied_space();
tenured_size_before = parent->data->tenured->occupied_space();
tenured_free_block_count_before = parent->data->tenured->free_blocks.free_block_count;
code_size_before = parent->code->allocator->occupied_space();
code_free_block_count_before = parent->code->allocator->free_blocks.free_block_count;
start_time = current_micros();
}
void gc_event::started_card_scan()
{
card_scan_time = current_micros();
}
void gc_event::ended_card_scan(cell cards_scanned_, cell decks_scanned_)
{
cards_scanned += cards_scanned_;
decks_scanned += decks_scanned_;
card_scan_time = (current_micros() - card_scan_time);
}
void gc_event::started_code_scan()
{
code_scan_time = current_micros();
}
void gc_event::ended_code_scan(cell code_blocks_scanned_)
{
code_blocks_scanned += code_blocks_scanned_;
code_scan_time = (current_micros() - code_scan_time);
}
void gc_event::started_data_sweep()
{
data_sweep_time = current_micros();
}
void gc_event::ended_data_sweep()
{
data_sweep_time = (current_micros() - data_sweep_time);
}
void gc_event::started_code_sweep()
{
code_sweep_time = current_micros();
}
void gc_event::ended_code_sweep()
{
code_sweep_time = (current_micros() - code_sweep_time);
}
void gc_event::started_compaction()
{
compaction_time = current_micros();
}
void gc_event::ended_compaction()
{
compaction_time = (current_micros() - compaction_time);
}
void gc_event::ended_gc(factor_vm *parent)
{
nursery_size_after = parent->nursery.occupied_space();
aging_size_after = parent->data->aging->occupied_space();
tenured_size_after = parent->data->tenured->occupied_space();
tenured_free_block_count_after = parent->data->tenured->free_blocks.free_block_count;
code_size_after = parent->code->allocator->occupied_space();
code_free_block_count_after = parent->code->allocator->free_blocks.free_block_count;
total_time = current_micros() - start_time;
}
std::ostream &operator<<(std::ostream &out, const gc_event *event)
{
out << "";
return out;
}
gc_state::gc_state(gc_op op_, factor_vm *parent) : op(op_), start_time(current_micros())
{
event = new gc_event(op,parent);
}
gc_state::~gc_state()
{
delete event;
event = NULL;
}
void factor_vm::end_gc()
{
current_gc->event->ended_gc(this);
if(verbose_gc) std::cout << current_gc->event << std::endl;
if(gc_events) gc_events->push_back(*current_gc->event);
delete current_gc->event;
current_gc->event = NULL;
}
void factor_vm::start_gc_again()
{
end_gc();
switch(current_gc->op)
{
case collect_nursery_op:
current_gc->op = collect_aging_op;
break;
case collect_aging_op:
current_gc->op = collect_to_tenured_op;
break;
case collect_to_tenured_op:
current_gc->op = collect_full_op;
break;
case collect_full_op:
case collect_compact_op:
current_gc->op = collect_growing_heap_op;
break;
default:
critical_error("Bad GC op",current_gc->op);
break;
}
current_gc->event = new gc_event(current_gc->op,this);
}
void factor_vm::update_code_heap_for_minor_gc(std::set *remembered_set)
{
/* The youngest generation that any code block can now reference */
std::set::const_iterator iter = remembered_set->begin();
std::set::const_iterator end = remembered_set->end();
for(; iter != end; iter++) update_literal_references(*iter);
}
void factor_vm::gc(gc_op op, cell requested_bytes, bool trace_contexts_p)
{
assert(!gc_off);
assert(!current_gc);
save_stacks();
current_gc = new gc_state(op,this);
/* Keep trying to GC higher and higher generations until we don't run out
of space */
if(setjmp(current_gc->gc_unwind))
{
/* We come back here if a generation is full */
start_gc_again();
}
switch(current_gc->op)
{
case collect_nursery_op:
collect_nursery();
break;
case collect_aging_op:
collect_aging();
break;
case collect_to_tenured_op:
collect_to_tenured();
break;
case collect_full_op:
collect_mark_impl(trace_contexts_p);
collect_sweep_impl();
update_code_heap_words_and_literals();
break;
case collect_compact_op:
collect_mark_impl(trace_contexts_p);
collect_compact_impl(trace_contexts_p);
break;
case collect_growing_heap_op:
collect_growing_heap(requested_bytes,trace_contexts_p);
break;
default:
critical_error("Bad GC op\n",current_gc->op);
break;
}
end_gc();
delete current_gc;
current_gc = NULL;
}
void factor_vm::primitive_minor_gc()
{
gc(collect_nursery_op,
0, /* requested size */
true /* trace contexts? */);
}
void factor_vm::primitive_full_gc()
{
gc(collect_full_op,
0, /* requested size */
true /* trace contexts? */);
}
void factor_vm::primitive_compact_gc()
{
gc(collect_compact_op,
0, /* requested size */
true /* trace contexts? */);
}
/* classes.tuple uses this to reshape tuples; tools.deploy.shaker uses this
to coalesce equal but distinct quotations and wrappers. */
void factor_vm::primitive_become()
{
array *new_objects = untag_check(dpop());
array *old_objects = untag_check(dpop());
cell capacity = array_capacity(new_objects);
if(capacity != array_capacity(old_objects))
critical_error("bad parameters to become",0);
cell i;
for(i = 0; i < capacity; i++)
{
tagged