void ObjectWalker::seed(GCData& data) {
ObjectArray *current_rs = memory_->remember_set();
for(ObjectArray::iterator oi = current_rs->begin();
oi != current_rs->end();
++oi) {
Object* tmp = *oi;
// unremember_object throws a NULL in to remove an object
// so we don't have to compact the set in unremember
if(tmp) saw_object(0, tmp);
}
for(Roots::Iterator i(data.roots()); i.more(); i.advance()) {
saw_object(0, i->get());
}
{
std::lock_guard<std::mutex> guard(data.thread_nexus()->threads_mutex());
for(ThreadList::iterator i = data.thread_nexus()->threads()->begin();
i != data.thread_nexus()->threads()->end();
++i)
{
scan(*i, false);
}
}
}
/* Understands how to read the inside of an object and find all references
* located within. It copies the objects pointed to, but does not follow into
* those further (ie, not recursive) */
void GarbageCollector::scan_object(Object* obj) {
Object* slot;
// If this object's refs are weak, then add it to the weak_refs
// vector and don't look at it otherwise.
if(obj->RefsAreWeak) {
if(!weak_refs) {
weak_refs = new ObjectArray(0);
}
weak_refs->push_back(obj);
return;
}
if(obj->klass() && obj->klass()->reference_p()) {
slot = saw_object(obj->klass());
if(slot) object_memory->set_class(obj, slot);
}
if(obj->ivars() && obj->ivars()->reference_p()) {
slot = saw_object(obj->ivars());
if(slot) obj->ivars(object_memory->state, slot);
}
TypeInfo* ti = object_memory->type_info[obj->obj_type];
assert(ti);
ObjectMark mark(this);
ti->mark(obj, mark);
}
void ImmixGC::walk_finalizers() {
FinalizerHandler* fh = object_memory_->finalizer_handler();
if(!fh) return;
for(FinalizerHandler::iterator i = fh->begin();
!i.end();
/* advance is handled in the loop */)
{
FinalizeObject& fi = i.current();
bool live = fi.object->marked_p(object_memory_->mark());
if(fi.ruby_finalizer) {
if(Object* fwd = saw_object(fi.ruby_finalizer)) {
fi.ruby_finalizer = fwd;
}
}
if(Object* fwd = saw_object(fi.object)) {
fi.object = fwd;
}
i.next(live);
}
}
void ObjectWalker::seed(GCData& data) {
ObjectArray *current_rs = object_memory_->remember_set();
for(ObjectArray::iterator oi = current_rs->begin();
oi != current_rs->end();
++oi) {
Object* tmp = *oi;
// unremember_object throws a NULL in to remove an object
// so we don't have to compact the set in unremember
if(tmp) saw_object(tmp);
}
for(Roots::Iterator i(data.roots()); i.more(); i.advance()) {
saw_object(i->get());
}
if(data.threads()) {
for(std::list<ManagedThread*>::iterator i = data.threads()->begin();
i != data.threads()->end();
++i) {
scan(*i, false);
}
}
for(Allocator<capi::Handle>::Iterator i(data.handles()->allocator()); i.more(); i.advance()) {
saw_object(i->object());
}
}
void ImmixGC::collect_scan(GCData* data) {
for(Roots::Iterator i(data->roots()); i.more(); i.advance()) {
if(Object* fwd = saw_object(i->get())) {
i->set(fwd);
}
}
{
utilities::thread::SpinLock::LockGuard guard(data->thread_nexus()->threads_lock());
for(ThreadList::iterator i = data->thread_nexus()->threads()->begin();
i != data->thread_nexus()->threads()->end();
++i)
{
scan(*i, false);
}
}
for(Allocator<capi::Handle>::Iterator i(data->handles()->allocator()); i.more(); i.advance()) {
if(i->in_use_p() && !i->weak_p()) {
if(Object* fwd = saw_object(i->object())) {
i->set_object(fwd);
}
}
}
std::list<capi::GlobalHandle*>* gh = data->global_handle_locations();
if(gh) {
for(std::list<capi::GlobalHandle*>::iterator i = gh->begin();
i != gh->end();
++i) {
capi::Handle** loc = (*i)->handle();
if(capi::Handle* hdl = *loc) {
if(!REFERENCE_P(hdl)) continue;
if(hdl->valid_p()) {
Object* obj = hdl->object();
if(obj && obj->reference_p()) {
if(Object* fwd = saw_object(obj)) {
hdl->set_object(fwd);
}
}
} else {
std::cerr << "Detected bad handle checking global capi handles\n";
}
}
}
}
/* TODO: JIT
if(LLVMState* ls = data->llvm_state()) ls->gc_scan(this);
*/
}
void MarkSweepGC::collect(Roots &roots, CallFrameLocationList& call_frames) {
Object* tmp;
Root* root = static_cast<Root*>(roots.head());
while(root) {
tmp = root->get();
if(tmp->reference_p()) {
saw_object(tmp);
}
root = static_cast<Root*>(root->next());
}
// Walk all the call frames
for(CallFrameLocationList::const_iterator i = call_frames.begin();
i != call_frames.end();
++i) {
CallFrame** loc = *i;
walk_call_frame(*loc);
}
while(!mark_stack_.empty()) {
tmp = mark_stack_.back();
mark_stack_.pop_back();
scan_object(tmp);
}
after_marked();
}
void ImmixGC::collect_scan(GCData* data) {
for(Roots::Iterator i(data->roots()); i.more(); i.advance()) {
Object* tmp = i->get();
if(tmp->reference_p()) saw_object(tmp);
}
if(data->threads()) {
for(std::list<ManagedThread*>::iterator i = data->threads()->begin();
i != data->threads()->end();
++i) {
scan(*i, false);
}
}
for(Allocator<capi::Handle>::Iterator i(data->handles()->allocator()); i.more(); i.advance()) {
if(i->in_use_p() && !i->weak_p()) {
saw_object(i->object());
}
}
std::list<capi::GlobalHandle*>* gh = data->global_handle_locations();
if(gh) {
for(std::list<capi::GlobalHandle*>::iterator i = gh->begin();
i != gh->end();
++i) {
capi::Handle** loc = (*i)->handle();
if(capi::Handle* hdl = *loc) {
if(!REFERENCE_P(hdl)) continue;
if(hdl->valid_p()) {
Object* obj = hdl->object();
if(obj && obj->reference_p()) {
saw_object(obj);
}
} else {
std::cerr << "Detected bad handle checking global capi handles\n";
}
}
}
}
#ifdef ENABLE_LLVM
if(LLVMState* ls = data->llvm_state()) ls->gc_scan(this);
#endif
}
void ImmixGC::collect_finish(GCData* data) {
collect_scan(data);
ObjectArray* marked_set = object_memory_->swap_marked_set();
for(ObjectArray::iterator oi = marked_set->begin();
oi != marked_set->end();
++oi) {
Object* obj = *oi;
if(obj) saw_object(obj);
}
delete marked_set;
// Users manipulate values accessible from the data* within an
// RData without running a write barrier. Thusly if we see any rdata
// we must always scan it again here because it could contain new pointers.
//
// We do this in a loop because the scanning might generate new entries
// on the mark stack.
do {
for(Allocator<capi::Handle>::Iterator i(data->handles()->allocator()); i.more(); i.advance()) {
capi::Handle* hdl = i.current();
if(!hdl->in_use_p()) continue;
if(hdl->is_rdata()) {
Object* obj = hdl->object();
if(obj->marked_p(object_memory_->mark())) {
scan_object(obj);
}
}
}
} while(process_mark_stack());
// We've now finished marking the entire object graph.
// Clean weakrefs before keeping additional objects alive
// for finalization, so people don't get a hold of finalized
// objects through weakrefs.
clean_weakrefs();
// Marking objects to be Finalized can cause more things to continue to
// live, so we must check the mark_stack again.
do {
walk_finalizers();
scan_fibers(data, true);
} while(process_mark_stack());
// Remove unreachable locked objects still in the list
if(data->threads()) {
for(std::list<ManagedThread*>::iterator i = data->threads()->begin();
i != data->threads()->end();
++i) {
clean_locked_objects(*i, false);
}
}
// Clear unreachable objects from the various remember sets
unsigned int mark = object_memory_->mark();
object_memory_->unremember_objects(mark);
}
/**
* Scans the specified Object +obj+ for references to other Objects, and
* marks those Objects as reachable. Understands how to read the inside of
* an Object and find all references located within. For each reference
* found, it marks the object pointed to as live (which may trigger
* movement of the object in a copying garbage collector), but does not
* recursively scan into the referenced object (since such recursion could
* be arbitrarily deep, depending on the object graph, and this could cause
* the stack to blow up).
* /param obj The Object to be scanned for references to other Objects.
*/
void GarbageCollector::scan_object(Object* obj) {
Object* slot;
#ifdef ENABLE_OBJECT_WATCH
if(watched_p(obj)) {
std::cout << "detected " << obj << " during scan_object.\n";
}
#endif
// Check and update an inflated header
if(obj->inflated_header_p()) {
obj->inflated_header()->reset_object(obj);
}
slot = saw_object(obj->klass());
if(slot) obj->klass(object_memory_, force_as<Class>(slot));
if(obj->ivars()->reference_p()) {
slot = saw_object(obj->ivars());
if(slot) obj->ivars(object_memory_, slot);
}
// Handle Tuple directly, because it's so common
if(Tuple* tup = try_as<Tuple>(obj)) {
int size = tup->num_fields();
for(int i = 0; i < size; i++) {
slot = tup->field[i];
if(slot->reference_p()) {
slot = saw_object(slot);
if(slot) {
tup->field[i] = slot;
object_memory_->write_barrier(tup, slot);
}
}
}
} else {
TypeInfo* ti = object_memory_->type_info[obj->type_id()];
ObjectMark mark(this);
ti->mark(obj, mark);
}
}
void GarbageCollector::scan(ManagedThread* thr, bool young_only) {
for(Roots::Iterator ri(thr->roots()); ri.more(); ri.advance()) {
ri->set(saw_object(ri->get()));
}
scan(thr->variable_root_buffers(), young_only);
scan(thr->root_buffers(), young_only);
if(VM* vm = thr->as_vm()) {
vm->gc_scan(this);
}
std::list<ObjectHeader*>& los = thr->locked_objects();
for(std::list<ObjectHeader*>::iterator i = los.begin();
i != los.end();
++i) {
*i = saw_object(static_cast<Object*>(*i));
}
}
/**
* Scans the specified Object +obj+ for references to other Objects, and
* marks those Objects as reachable. Understands how to read the inside of
* an Object and find all references located within. For each reference
* found, it marks the object pointed to as live (which may trigger
* movement of the object in a copying garbage collector), but does not
* recursively scan into the referenced object (since such recursion could
* be arbitrarily deep, depending on the object graph, and this could cause
* the stack to blow up).
* /param obj The Object to be scanned for references to other Objects.
*/
void GarbageCollector::scan_object(Object* obj) {
#ifdef ENABLE_OBJECT_WATCH
if(watched_p(obj)) {
std::cout << "detected " << obj << " during scan_object.\n";
}
#endif
// We set scanned here before we finish scanning the object.
// This is done so we don't have a race condition while we're
// scanning the object and another thread updates a field during
// the phase where the object is partially scanned.
scanned_object(obj);
if(Object* klass = saw_object(obj->klass())) {
obj->klass(object_memory_, force_as<Class>(klass));
}
if(obj->ivars()->reference_p()) {
if(Object* ivars = saw_object(obj->ivars())) {
obj->ivars(object_memory_, ivars);
}
}
// Handle Tuple directly, because it's so common
if(Tuple* tup = try_as<Tuple>(obj)) {
native_int size = tup->num_fields();
for(native_int i = 0; i < size; i++) {
Object* slot = tup->field[i];
if(slot->reference_p()) {
if(Object* moved = saw_object(slot)) {
tup->field[i] = moved;
object_memory_->write_barrier(tup, moved);
}
}
}
} else {
TypeInfo* ti = object_memory_->type_info[obj->type_id()];
ObjectMark mark(this);
ti->mark(obj, mark);
}
}
void GarbageCollector::scan(ManagedThread* thr, bool young_only) {
for(Roots::Iterator ri(thr->roots()); ri.more(); ri.advance()) {
ri->set(saw_object(ri->get()));
}
scan(thr->variable_root_buffers(), young_only);
scan(thr->root_buffers(), young_only);
if(VM* vm = thr->as_vm()) {
if(CallFrame* cf = vm->saved_call_frame()) {
walk_call_frame(cf);
}
}
std::list<ObjectHeader*>& los = thr->locked_objects();
for(std::list<ObjectHeader*>::iterator i = los.begin();
i != los.end();
i++) {
*i = saw_object((Object*)*i);
}
}
void GarbageCollector::scan(ManagedThread* thr, bool young_only) {
for(Roots::Iterator ri(thr->roots()); ri.more(); ri.advance()) {
ri->set(saw_object(ri->get()));
}
scan(thr->variable_root_buffers(), young_only);
scan(thr->root_buffers(), young_only);
if(VM* vm = thr->as_vm()) {
vm->gc_scan(this);
}
}
void BakerGC::walk_finalizers() {
FinalizerHandler* fh = object_memory_->finalizer_handler();
if(!fh) return;
for(FinalizerHandler::iterator i = fh->begin();
!i.end();
/* advance is handled in the loop */)
{
FinalizeObject& fi = i.current();
bool live = true;
if(fi.object->young_object_p()) {
live = fi.object->forwarded_p();
if(Object* fwd = saw_object(fi.object)) {
fi.object = fwd;
}
} else {
// If this object is mature, scan it. This
// means that any young objects it refers to are properly
// GC'ed and kept alive if necessary
scan_object(fi.object);
}
Object* fin = fi.ruby_finalizer;
if(fin && fin->reference_p()) {
if(fin->young_object_p()) {
if(Object* fwd = saw_object(fin)) {
fi.ruby_finalizer = fwd;
}
} else {
// If this object is mature, scan it. This
// means that any young objects it refers to are properly
// GC'ed and kept alive if necessary
scan_object(fin);
}
}
i.next(live);
}
}
void HeapDebug::walk(Roots &roots) {
Object* tmp;
Root* root = static_cast<Root*>(roots.head());
while(root) {
tmp = root->get();
if(tmp->reference_p()) {
saw_object(tmp);
}
root = static_cast<Root*>(root->next());
}
}
void BakerGC::walk_finalizers() {
FinalizerHandler* fh = object_memory_->finalizer_handler();
if(!fh) return;
for(FinalizerHandler::iterator i = fh->begin();
!i.end();
/* advance is handled in the loop */)
{
FinalizeObject& fi = i.current();
bool live = true;
if(fi.object->young_object_p()) {
live = fi.object->forwarded_p();
fi.object = saw_object(fi.object);
}
if(fi.ruby_finalizer && fi.ruby_finalizer->young_object_p()) {
fi.ruby_finalizer = saw_object(fi.ruby_finalizer);
}
i.next(live);
}
}
void ImmixGC::check_finalize() {
for(std::list<FinalizeObject>::iterator i = object_memory_->finalize().begin();
i != object_memory_->finalize().end(); ) {
FinalizeObject& fi = *i;
switch(i->status) {
case FinalizeObject::eLive:
// We have to still keep it alive though until we finish with it.
i->object = saw_object(i->object);
if(!i->object->marked_p(object_memory_->mark())) {
i->status = FinalizeObject::eQueued;
object_memory_->to_finalize().push_back(&fi);
}
break;
case FinalizeObject::eQueued:
// Nothing, we haven't gotten to it yet.
// Keep waiting and keep i->object updated.
i->object = saw_object(i->object);
break;
case FinalizeObject::eFinalized:
if(!i->object->marked_p(object_memory_->mark())) {
// finalized and done with.
i = object_memory_->finalize().erase(i);
continue;
} else {
// RESURECTION!
i->status = FinalizeObject::eQueued;
i->object = saw_object(i->object);
}
break;
}
i++;
}
}
void GarbageCollector::scan(RootBuffers& buffers, bool young_only) {
for(RootBuffers::Iterator i(buffers);
i.more();
i.advance())
{
Object** buffer = i->buffer();
for(int idx = 0; idx < i->size(); idx++) {
Object* tmp = buffer[idx];
if(tmp->reference_p() && (!young_only || tmp->young_object_p())) {
buffer[idx] = saw_object(tmp);
}
}
}
}
void GarbageCollector::scan(VariableRootBuffers& buffers, bool young_only) {
for(VariableRootBuffers::Iterator vi(buffers);
vi.more();
vi.advance())
{
Object*** buffer = vi->buffer();
for(int idx = 0; idx < vi->size(); idx++) {
Object** var = buffer[idx];
Object* tmp = *var;
if(tmp->reference_p() && (!young_only || tmp->young_object_p())) {
*var = saw_object(tmp);
}
}
}
}
void GarbageCollector::scan(VariableRootBuffers& buffers,
bool young_only, AddressDisplacement* offset)
{
VariableRootBuffer* vrb = displace(buffers.front(), offset);
while(vrb) {
Object*** buffer = displace(vrb->buffer(), offset);
for(int idx = 0; idx < vrb->size(); idx++) {
Object** var = displace(buffer[idx], offset);
Object* tmp = *var;
if(tmp && tmp->reference_p() && (!young_only || tmp->young_object_p())) {
*var = saw_object(tmp);
}
}
vrb = displace((VariableRootBuffer*)vrb->next(), offset);
}
}
void MarkSweepGC::collect(Roots &roots) {
Object* tmp;
Root* root = static_cast<Root*>(roots.head());
while(root) {
tmp = root->get();
if(tmp->reference_p()) {
saw_object(tmp);
}
root = static_cast<Root*>(root->next());
}
// Cleanup all weakrefs seen
clean_weakrefs();
// Sweep up the garbage
sweep_objects();
}
/**
* Perform garbage collection on the young objects.
*/
void BakerGC::collect(GCData& data, YoungCollectStats* stats) {
#ifdef HAVE_VALGRIND_H
VALGRIND_MAKE_MEM_DEFINED(next->start().as_int(), next->size());
VALGRIND_MAKE_MEM_DEFINED(current->start().as_int(), current->size());
#endif
Object* tmp;
ObjectArray *current_rs = object_memory_->swap_remember_set();
total_objects = 0;
copy_spills_ = 0;
reset_promoted();
// Start by copying objects in the remember set
for(ObjectArray::iterator oi = current_rs->begin();
oi != current_rs->end();
++oi) {
tmp = *oi;
// unremember_object throws a NULL in to remove an object
// so we don't have to compact the set in unremember
if(tmp) {
// assert(tmp->mature_object_p());
// assert(!tmp->forwarded_p());
// Remove the Remember bit, since we're clearing the set.
tmp->clear_remember();
scan_object(tmp);
}
}
delete current_rs;
for(std::list<gc::WriteBarrier*>::iterator wbi = object_memory_->aux_barriers().begin();
wbi != object_memory_->aux_barriers().end();
++wbi) {
gc::WriteBarrier* wb = *wbi;
ObjectArray* rs = wb->swap_remember_set();
for(ObjectArray::iterator oi = rs->begin();
oi != rs->end();
++oi) {
tmp = *oi;
if(tmp) {
tmp->clear_remember();
scan_object(tmp);
}
}
delete rs;
}
for(Roots::Iterator i(data.roots()); i.more(); i.advance()) {
i->set(saw_object(i->get()));
}
if(data.threads()) {
for(std::list<ManagedThread*>::iterator i = data.threads()->begin();
i != data.threads()->end();
++i) {
scan(*i, true);
}
}
for(Allocator<capi::Handle>::Iterator i(data.handles()->allocator()); i.more(); i.advance()) {
if(!i->in_use_p()) continue;
if(!i->weak_p() && i->object()->young_object_p()) {
i->set_object(saw_object(i->object()));
// Users manipulate values accessible from the data* within an
// RData without running a write barrier. Thusly if we see a mature
// rdata, we must always scan it because it could contain
// young pointers.
} else if(!i->object()->young_object_p() && i->is_rdata()) {
scan_object(i->object());
}
assert(i->object()->type_id() > InvalidType && i->object()->type_id() < LastObjectType);
}
std::list<capi::GlobalHandle*>* gh = data.global_handle_locations();
if(gh) {
for(std::list<capi::GlobalHandle*>::iterator i = gh->begin();
i != gh->end();
++i) {
capi::GlobalHandle* global_handle = *i;
capi::Handle** loc = global_handle->handle();
if(capi::Handle* hdl = *loc) {
if(!REFERENCE_P(hdl)) continue;
if(hdl->valid_p()) {
Object* obj = hdl->object();
if(obj && obj->reference_p() && obj->young_object_p()) {
hdl->set_object(saw_object(obj));
}
} else {
std::cerr << "Detected bad handle checking global capi handles\n";
}
}
}
}
#ifdef ENABLE_LLVM
if(LLVMState* ls = data.llvm_state()) ls->gc_scan(this);
#endif
// Handle all promotions to non-young space that occurred.
handle_promotions();
assert(fully_scanned_p());
// We're now done seeing the entire object graph of normal, live references.
// Now we get to handle the unusual references, like finalizers and such.
// Objects with finalizers must be kept alive until the finalizers have
// run.
walk_finalizers();
// Process possible promotions from processing objects with finalizers.
handle_promotions();
if(!promoted_stack_.empty()) rubinius::bug("promote stack has elements!");
if(!fully_scanned_p()) rubinius::bug("more young refs");
// Check any weakrefs and replace dead objects with nil
clean_weakrefs(true);
// Swap the 2 halves
Heap *x = next;
next = current;
current = x;
if(stats) {
stats->lifetime = lifetime_;
stats->percentage_used = current->percentage_used();
stats->promoted_objects = promoted_objects_;
stats->excess_objects = copy_spills_;
}
// Tune the age at which promotion occurs
if(autotune_) {
double used = current->percentage_used();
if(used > cOverFullThreshold) {
if(tune_threshold_ >= cOverFullTimes) {
if(lifetime_ > cMinimumLifetime) lifetime_--;
} else {
tune_threshold_++;
}
} else if(used < cUnderFullThreshold) {
if(tune_threshold_ <= cUnderFullTimes) {
if(lifetime_ < cMaximumLifetime) lifetime_++;
} else {
tune_threshold_--;
}
} else if(tune_threshold_ > 0) {
tune_threshold_--;
} else if(tune_threshold_ < 0) {
tune_threshold_++;
} else if(tune_threshold_ == 0) {
if(lifetime_ < original_lifetime_) {
lifetime_++;
} else if(lifetime_ > original_lifetime_) {
lifetime_--;
}
}
}
}
void ImmixGC::collect(GCData& data) {
Object* tmp;
gc_.clear_lines();
for(Roots::Iterator i(data.roots()); i.more(); i.advance()) {
tmp = i->get();
if(tmp->reference_p()) {
saw_object(tmp);
}
}
for(capi::Handles::Iterator i(*data.handles()); i.more(); i.advance()) {
if(!i->weak_p()) saw_object(i->object());
}
for(capi::Handles::Iterator i(*data.cached_handles()); i.more(); i.advance()) {
if(!i->weak_p()) saw_object(i->object());
}
for(VariableRootBuffers::Iterator i(data.variable_buffers());
i.more(); i.advance()) {
Object*** buffer = i->buffer();
for(int idx = 0; idx < i->size(); idx++) {
Object** var = buffer[idx];
Object* tmp = *var;
if(tmp->reference_p() && tmp->young_object_p()) {
saw_object(tmp);
}
}
}
// Walk all the call frames
for(CallFrameLocationList::const_iterator i = data.call_frames().begin();
i != data.call_frames().end();
i++) {
CallFrame** loc = *i;
walk_call_frame(*loc);
}
gc_.process_mark_stack(allocator_);
// Sweep up the garbage
gc_.sweep_blocks();
// This resets the allocator state to sync it up with the BlockAllocator
// properly.
allocator_.get_new_block();
ObjectArray *current_rs = object_memory->remember_set;
int cleared = 0;
for(ObjectArray::iterator oi = current_rs->begin();
oi != current_rs->end();
oi++) {
tmp = *oi;
// unremember_object throws a NULL in to remove an object
// so we don't have to compact the set in unremember
if(tmp) {
assert(tmp->zone == MatureObjectZone);
assert(!tmp->forwarded_p());
if(!tmp->marked_p()) {
cleared++;
*oi = NULL;
}
}
}
// Switch the which_mark_ for next time.
which_mark_ = (which_mark_ == 1 ? 2 : 1);
#ifdef IMMIX_DEBUG
std::cout << "Immix: RS size cleared: " << cleared << "\n";
immix::Chunks& chunks = gc_.block_allocator().chunks();
std::cout << "chunks=" << chunks.size() << "\n";
immix::AllBlockIterator iter(chunks);
int blocks_seen = 0;
int total_objects = 0;
int total_object_bytes = 0;
while(immix::Block* block = iter.next()) {
blocks_seen++;
std::cout << "block " << block << ", holes=" << block->holes() << " "
<< "objects=" << block->objects() << " "
<< "object_bytes=" << block->object_bytes() << " "
<< "frag=" << block->fragmentation_ratio()
<< "\n";
total_objects += block->objects();
total_object_bytes += block->object_bytes();
}
std::cout << blocks_seen << " blocks\n";
std::cout << gc_.bytes_allocated() << " bytes allocated\n";
std::cout << total_object_bytes << " object bytes / " << total_objects << " objects\n";
int* holes = new int[10];
for(int i = 0; i < 10; i++) {
holes[i] = 0;
}
immix::AllBlockIterator iter2(chunks);
while(immix::Block* block = iter2.next()) {
int h = block->holes();
if(h > 9) h = 9;
holes[h]++;
}
std::cout << "== hole stats ==\n";
for(int i = 0; i < 10; i++) {
if(holes[i] > 0) {
std::cout << i << ": " << holes[i] << "\n";
}
}
#endif
}
/**
* Performs a garbage collection of the immix space.
*/
void ImmixGC::collect(GCData& data) {
Object* tmp;
gc_.clear_lines();
int via_handles_ = 0;
int via_roots = 0;
for(Roots::Iterator i(data.roots()); i.more(); i.advance()) {
tmp = i->get();
if(tmp->reference_p()) saw_object(tmp);
via_roots++;
}
if(data.threads()) {
for(std::list<ManagedThread*>::iterator i = data.threads()->begin();
i != data.threads()->end();
++i) {
scan(*i, false);
}
}
for(Allocator<capi::Handle>::Iterator i(data.handles()->allocator()); i.more(); i.advance()) {
if(i->in_use_p() && !i->weak_p()) {
saw_object(i->object());
via_handles_++;
}
}
std::list<capi::GlobalHandle*>* gh = data.global_handle_locations();
if(gh) {
for(std::list<capi::GlobalHandle*>::iterator i = gh->begin();
i != gh->end();
++i) {
capi::Handle** loc = (*i)->handle();
if(capi::Handle* hdl = *loc) {
if(!REFERENCE_P(hdl)) continue;
if(hdl->valid_p()) {
Object* obj = hdl->object();
if(obj && obj->reference_p()) {
saw_object(obj);
via_handles_++;
}
} else {
std::cerr << "Detected bad handle checking global capi handles\n";
}
}
}
}
#ifdef ENABLE_LLVM
if(LLVMState* ls = data.llvm_state()) ls->gc_scan(this);
#endif
gc_.process_mark_stack(allocator_);
// We've now finished marking the entire object graph.
// Marking objects to be Finalized can cause more things to continue to
// live, so we must check the mark_stack again.
do {
walk_finalizers();
} while(gc_.process_mark_stack(allocator_));
clean_weakrefs();
// Remove unreachable locked objects still in the list
if(data.threads()) {
for(std::list<ManagedThread*>::iterator i = data.threads()->begin();
i != data.threads()->end();
++i) {
clean_locked_objects(*i, false);
}
}
// Sweep up the garbage
gc_.sweep_blocks();
// This resets the allocator state to sync it up with the BlockAllocator
// properly.
allocator_.get_new_block();
// Clear unreachable objects from the various remember sets
int cleared = 0;
unsigned int mark = object_memory_->mark();
cleared = object_memory_->unremember_objects(mark);
for(std::list<gc::WriteBarrier*>::iterator wbi = object_memory_->aux_barriers().begin();
wbi != object_memory_->aux_barriers().end();
++wbi) {
gc::WriteBarrier* wb = *wbi;
cleared += wb->unremember_objects(mark);
}
// Now, calculate how much space we're still using.
immix::Chunks& chunks = gc_.block_allocator().chunks();
immix::AllBlockIterator iter(chunks);
int live_bytes = 0;
int total_bytes = 0;
while(immix::Block* block = iter.next()) {
total_bytes += immix::cBlockSize;
live_bytes += block->bytes_from_lines();
}
double percentage_live = (double)live_bytes / (double)total_bytes;
if(object_memory_->state()->shared.config.gc_immix_debug) {
std::cerr << "[GC IMMIX: " << clear_marked_objects() << " marked"
<< ", "
<< via_roots << " roots "
<< via_handles_ << " handles "
<< (int)(percentage_live * 100) << "% live"
<< ", " << live_bytes << "/" << total_bytes
<< "]\n";
}
if(percentage_live >= 0.90) {
if(object_memory_->state()->shared.config.gc_immix_debug) {
std::cerr << "[GC IMMIX: expanding. "
<< (int)(percentage_live * 100)
<< "%]\n";
}
gc_.block_allocator().add_chunk();
}
#ifdef IMMIX_DEBUG
std::cout << "Immix: RS size cleared: " << cleared << "\n";
immix::Chunks& chunks = gc_.block_allocator().chunks();
std::cout << "chunks=" << chunks.size() << "\n";
immix::AllBlockIterator iter(chunks);
int blocks_seen = 0;
int total_objects = 0;
int total_object_bytes = 0;
while(immix::Block* block = iter.next()) {
blocks_seen++;
std::cout << "block " << block << ", holes=" << block->holes() << " "
<< "objects=" << block->objects() << " "
<< "object_bytes=" << block->object_bytes() << " "
<< "frag=" << block->fragmentation_ratio()
<< "\n";
total_objects += block->objects();
total_object_bytes += block->object_bytes();
}
std::cout << blocks_seen << " blocks\n";
std::cout << gc_.bytes_allocated() << " bytes allocated\n";
std::cout << total_object_bytes << " object bytes / " << total_objects << " objects\n";
int* holes = new int[10];
for(int i = 0; i < 10; i++) {
holes[i] = 0;
}
immix::AllBlockIterator iter2(chunks);
while(immix::Block* block = iter2.next()) {
int h = block->holes();
if(h > 9) h = 9;
holes[h]++;
}
std::cout << "== hole stats ==\n";
for(int i = 0; i < 10; i++) {
if(holes[i] > 0) {
std::cout << i << ": " << holes[i] << "\n";
}
}
delete[] holes;
holes = NULL;
#endif
}
void ImmixGC::check_finalize() {
// If finalizers are running right now, just fixup any finalizer references
if(object_memory_->running_finalizers()) {
for(std::list<FinalizeObject>::iterator i = object_memory_->finalize().begin();
i != object_memory_->finalize().end();
++i) {
if(i->object) {
i->object = saw_object(i->object);
}
if(i->ruby_finalizer) {
i->ruby_finalizer = saw_object(i->ruby_finalizer);
}
}
return;
}
for(std::list<FinalizeObject>::iterator i = object_memory_->finalize().begin();
i != object_memory_->finalize().end(); )
{
FinalizeObject& fi = *i;
if(i->ruby_finalizer) {
i->ruby_finalizer = saw_object(i->ruby_finalizer);
}
bool remove = false;
switch(i->status) {
case FinalizeObject::eLive:
if(!i->object->marked_p(object_memory_->mark())) {
// Run C finalizers now rather that queue them.
if(i->finalizer) {
State state_obj(state());
(*i->finalizer)(&state_obj, i->object);
i->status = FinalizeObject::eFinalized;
remove = true;
} else {
i->queued();
object_memory_->add_to_finalize(&fi);
// We have to still keep it alive though until we finish with it.
i->object = saw_object(i->object);
}
} else {
// Update the reference
i->object = saw_object(i->object);
}
break;
case FinalizeObject::eQueued:
// Nothing, we haven't gotten to it yet.
// Keep waiting and keep i->object updated.
i->object = saw_object(i->object);
i->queue_count++;
break;
case FinalizeObject::eFinalized:
if(!i->object->marked_p(object_memory_->mark())) {
// finalized and done with.
remove = true;
} else {
// RESURRECTION!
i->queued();
i->object = saw_object(i->object);
}
break;
}
if(remove) {
i = object_memory_->finalize().erase(i);
} else {
++i;
}
}
}
void ImmixGC::collect(GCData& data) {
Object* tmp;
gc_.clear_lines();
int via_handles_ = 0;
int via_roots = 0;
int via_stack = 0;
int callframes = 0;
for(Roots::Iterator i(data.roots()); i.more(); i.advance()) {
tmp = i->get();
if(tmp->reference_p()) saw_object(tmp);
via_roots++;
}
if(data.threads()) {
for(std::list<ManagedThread*>::iterator i = data.threads()->begin();
i != data.threads()->end();
i++) {
for(Roots::Iterator ri((*i)->roots()); ri.more(); ri.advance()) {
ri->set(saw_object(ri->get()));
}
}
}
for(capi::Handles::Iterator i(*data.handles()); i.more(); i.advance()) {
if(i->in_use_p() && !i->weak_p()) {
saw_object(i->object());
via_handles_++;
}
}
for(capi::Handles::Iterator i(*data.cached_handles()); i.more(); i.advance()) {
if(i->in_use_p() && !i->weak_p()) {
saw_object(i->object());
via_handles_++;
}
}
std::list<capi::Handle**>* gh = data.global_handle_locations();
if(gh) {
for(std::list<capi::Handle**>::iterator i = gh->begin();
i != gh->end();
i++) {
capi::Handle** loc = *i;
if(capi::Handle* hdl = *loc) {
if(!CAPI_REFERENCE_P(hdl)) continue;
if(hdl->valid_p()) {
Object* obj = hdl->object();
if(obj && obj->reference_p()) {
saw_object(obj);
via_handles_++;
}
} else {
std::cerr << "Detected bad handle checking global capi handles\n";
}
}
}
}
for(VariableRootBuffers::Iterator i(data.variable_buffers());
i.more(); i.advance()) {
Object*** buffer = i->buffer();
for(int idx = 0; idx < i->size(); idx++) {
Object** var = buffer[idx];
Object* tmp = *var;
via_stack++;
if(tmp->reference_p() && tmp->young_object_p()) {
saw_object(tmp);
}
}
}
// Walk all the call frames
for(CallFrameLocationList::const_iterator i = data.call_frames().begin();
i != data.call_frames().end();
i++) {
callframes++;
CallFrame** loc = *i;
walk_call_frame(*loc);
}
gc_.process_mark_stack(allocator_);
// We've now finished marking the entire object graph.
check_finalize();
// Finalize can cause more things to continue to live, so we must
// check the mark_stack again.
gc_.process_mark_stack(allocator_);
// Sweep up the garbage
gc_.sweep_blocks();
// This resets the allocator state to sync it up with the BlockAllocator
// properly.
allocator_.get_new_block();
ObjectArray *current_rs = object_memory_->remember_set();
int cleared = 0;
for(ObjectArray::iterator oi = current_rs->begin();
oi != current_rs->end();
oi++) {
tmp = *oi;
// unremember_object throws a NULL in to remove an object
// so we don't have to compact the set in unremember
if(tmp) {
assert(tmp->zone() == MatureObjectZone);
assert(!tmp->forwarded_p());
if(!tmp->marked_p(object_memory_->mark())) {
cleared++;
*oi = NULL;
}
}
}
for(std::list<gc::WriteBarrier*>::iterator wbi = object_memory_->aux_barriers().begin();
wbi != object_memory_->aux_barriers().end();
wbi++) {
gc::WriteBarrier* wb = *wbi;
ObjectArray* rs = wb->remember_set();
for(ObjectArray::iterator oi = rs->begin();
oi != rs->end();
oi++) {
tmp = *oi;
if(tmp) {
assert(tmp->zone() == MatureObjectZone);
assert(!tmp->forwarded_p());
if(!tmp->marked_p(object_memory_->mark())) {
cleared++;
*oi = NULL;
}
}
}
}
// Now, calculate how much space we're still using.
immix::Chunks& chunks = gc_.block_allocator().chunks();
immix::AllBlockIterator iter(chunks);
int live_bytes = 0;
int total_bytes = 0;
while(immix::Block* block = iter.next()) {
total_bytes += immix::cBlockSize;
live_bytes += block->bytes_from_lines();
}
double percentage_live = (double)live_bytes / (double)total_bytes;
if(object_memory_->state->shared.config.gc_immix_debug) {
std::cerr << "[GC IMMIX: " << clear_marked_objects() << " marked"
<< ", "
<< via_roots << " roots "
<< via_handles_ << " handles "
<< (int)(percentage_live * 100) << "% live"
<< ", " << live_bytes << "/" << total_bytes
<< "]\n";
}
if(percentage_live >= 0.90) {
if(object_memory_->state->shared.config.gc_immix_debug) {
std::cerr << "[GC IMMIX: expanding. "
<< (int)(percentage_live * 100)
<< "%]\n";
}
gc_.block_allocator().add_chunk();
}
#ifdef IMMIX_DEBUG
std::cout << "Immix: RS size cleared: " << cleared << "\n";
immix::Chunks& chunks = gc_.block_allocator().chunks();
std::cout << "chunks=" << chunks.size() << "\n";
immix::AllBlockIterator iter(chunks);
int blocks_seen = 0;
int total_objects = 0;
int total_object_bytes = 0;
while(immix::Block* block = iter.next()) {
blocks_seen++;
std::cout << "block " << block << ", holes=" << block->holes() << " "
<< "objects=" << block->objects() << " "
<< "object_bytes=" << block->object_bytes() << " "
<< "frag=" << block->fragmentation_ratio()
<< "\n";
total_objects += block->objects();
total_object_bytes += block->object_bytes();
}
std::cout << blocks_seen << " blocks\n";
std::cout << gc_.bytes_allocated() << " bytes allocated\n";
std::cout << total_object_bytes << " object bytes / " << total_objects << " objects\n";
int* holes = new int[10];
for(int i = 0; i < 10; i++) {
holes[i] = 0;
}
immix::AllBlockIterator iter2(chunks);
while(immix::Block* block = iter2.next()) {
int h = block->holes();
if(h > 9) h = 9;
holes[h]++;
}
std::cout << "== hole stats ==\n";
for(int i = 0; i < 10; i++) {
if(holes[i] > 0) {
std::cout << i << ": " << holes[i] << "\n";
}
}
#endif
}
/**
* Marks the specified Object +obj+ as live.
*/
Object* mark_object(Object* obj) {
if(!obj || !obj->reference_p()) return obj;
Object* tmp = saw_object(obj);
if(tmp) return tmp;
return obj;
}
/* Perform garbage collection on the young objects. */
void BakerGC::collect(GCData& data) {
#ifdef RBX_GC_STATS
stats::GCStats::get()->bytes_copied.start();
stats::GCStats::get()->objects_copied.start();
stats::GCStats::get()->objects_promoted.start();
stats::GCStats::get()->collect_young.start();
#endif
Object* tmp;
ObjectArray *current_rs = object_memory->remember_set;
object_memory->remember_set = new ObjectArray(0);
total_objects = 0;
// Tracks all objects that we promoted during this run, so
// we can scan them at the end.
promoted_ = new ObjectArray(0);
promoted_current = promoted_insert = promoted_->begin();
for(ObjectArray::iterator oi = current_rs->begin();
oi != current_rs->end();
++oi) {
tmp = *oi;
// unremember_object throws a NULL in to remove an object
// so we don't have to compact the set in unremember
if(tmp) {
assert(tmp->zone == MatureObjectZone);
assert(!tmp->forwarded_p());
// Remove the Remember bit, since we're clearing the set.
tmp->clear_remember();
scan_object(tmp);
}
}
delete current_rs;
for(Roots::Iterator i(data.roots()); i.more(); i.advance()) {
tmp = i->get();
if(tmp->reference_p() && tmp->young_object_p()) {
i->set(saw_object(tmp));
}
}
for(VariableRootBuffers::Iterator i(data.variable_buffers());
i.more(); i.advance()) {
Object*** buffer = i->buffer();
for(int idx = 0; idx < i->size(); idx++) {
Object** var = buffer[idx];
Object* tmp = *var;
if(tmp->reference_p() && tmp->young_object_p()) {
*var = saw_object(tmp);
}
}
}
// Walk all the call frames
for(CallFrameLocationList::iterator i = data.call_frames().begin();
i != data.call_frames().end();
i++) {
CallFrame** loc = *i;
walk_call_frame(*loc);
}
/* Ok, now handle all promoted objects. This is setup a little weird
* so I should explain.
*
* We want to scan each promoted object. But this scanning will likely
* cause more objects to be promoted. Adding to an ObjectArray that your
* iterating over blows up the iterators, so instead we rotate the
* current promoted set out as we iterator over it, and stick an
* empty ObjectArray in.
*
* This way, when there are no more objects that are promoted, the last
* ObjectArray will be empty.
* */
promoted_current = promoted_insert = promoted_->begin();
while(promoted_->size() > 0 || !fully_scanned_p()) {
if(promoted_->size() > 0) {
for(;promoted_current != promoted_->end();
++promoted_current) {
tmp = *promoted_current;
assert(tmp->zone == MatureObjectZone);
scan_object(tmp);
if(watched_p(tmp)) {
std::cout << "detected " << tmp << " during scan of promoted objects.\n";
}
}
promoted_->resize(promoted_insert - promoted_->begin());
promoted_current = promoted_insert = promoted_->begin();
}
/* As we're handling promoted objects, also handle unscanned objects.
* Scanning these unscanned objects (via the scan pointer) will
* cause more promotions. */
copy_unscanned();
}
assert(promoted_->size() == 0);
delete promoted_;
promoted_ = NULL;
assert(fully_scanned_p());
/* Another than is going to be found is found now, so we go back and
* look at everything in current and call delete_object() on anything
* thats not been forwarded. */
find_lost_souls();
/* Check any weakrefs and replace dead objects with nil*/
clean_weakrefs(true);
/* Swap the 2 halves */
Heap *x = next;
next = current;
current = x;
next->reset();
#ifdef RBX_GC_STATS
stats::GCStats::get()->collect_young.stop();
stats::GCStats::get()->objects_copied.stop();
stats::GCStats::get()->objects_promoted.stop();
stats::GCStats::get()->bytes_copied.stop();
#endif
}
void ObjectWalker::seed(GCData& data) {
Object* tmp;
ObjectArray *current_rs = object_memory_->remember_set();
for(ObjectArray::iterator oi = current_rs->begin();
oi != current_rs->end();
++oi) {
tmp = *oi;
// unremember_object throws a NULL in to remove an object
// so we don't have to compact the set in unremember
if(tmp) saw_object(tmp);
}
for(std::list<gc::WriteBarrier*>::iterator wbi = object_memory_->aux_barriers().begin();
wbi != object_memory_->aux_barriers().end();
++wbi) {
gc::WriteBarrier* wb = *wbi;
ObjectArray* rs = wb->remember_set();
for(ObjectArray::iterator oi = rs->begin();
oi != rs->end();
++oi) {
tmp = *oi;
if(tmp) saw_object(tmp);
}
}
for(Roots::Iterator i(data.roots()); i.more(); i.advance()) {
saw_object(i->get());
}
if(data.threads()) {
for(std::list<ManagedThread*>::iterator i = data.threads()->begin();
i != data.threads()->end();
++i) {
for(Roots::Iterator ri((*i)->roots()); ri.more(); ri.advance()) {
saw_object(ri->get());
}
}
}
for(capi::Handles::Iterator i(*data.handles()); i.more(); i.advance()) {
saw_object(i->object());
}
for(capi::Handles::Iterator i(*data.cached_handles()); i.more(); i.advance()) {
saw_object(i->object());
}
for(VariableRootBuffers::Iterator i(data.variable_buffers());
i.more(); i.advance()) {
Object*** buffer = i->buffer();
for(int idx = 0; idx < i->size(); idx++) {
Object** var = buffer[idx];
Object* tmp = *var;
saw_object(tmp);
}
}
RootBuffers* rb = data.root_buffers();
if(rb) {
for(RootBuffers::Iterator i(*rb);
i.more();
i.advance())
{
Object** buffer = i->buffer();
for(int idx = 0; idx < i->size(); idx++) {
saw_object(buffer[idx]);
}
}
}
// Walk all the call frames
for(CallFrameLocationList::iterator i = data.call_frames().begin();
i != data.call_frames().end();
++i) {
CallFrame** loc = *i;
walk_call_frame(*loc);
}
}
/**
* Perform garbage collection on the young objects.
*/
void BakerGC::collect(GCData* data, YoungCollectStats* stats) {
#ifdef HAVE_VALGRIND_H
(void)VALGRIND_MAKE_MEM_DEFINED(next->start().as_int(), next->size());
(void)VALGRIND_MAKE_MEM_DEFINED(current->start().as_int(), current->size());
#endif
mprotect(next->start(), next->size(), PROT_READ | PROT_WRITE);
mprotect(current->start(), current->size(), PROT_READ | PROT_WRITE);
check_growth_start();
ObjectArray *current_rs = object_memory_->swap_remember_set();
total_objects = 0;
copy_spills_ = 0;
reset_promoted();
// Start by copying objects in the remember set
for(ObjectArray::iterator oi = current_rs->begin();
oi != current_rs->end();
++oi) {
Object* tmp = *oi;
// unremember_object throws a NULL in to remove an object
// so we don't have to compact the set in unremember
if(tmp) {
// Remove the Remember bit, since we're clearing the set.
tmp->clear_remember();
scan_object(tmp);
}
}
delete current_rs;
scan_mark_set();
scan_mature_mark_stack();
for(Roots::Iterator i(data->roots()); i.more(); i.advance()) {
i->set(saw_object(i->get()));
}
if(data->threads()) {
for(std::list<ManagedThread*>::iterator i = data->threads()->begin();
i != data->threads()->end();
++i) {
scan(*i, true);
}
}
for(Allocator<capi::Handle>::Iterator i(data->handles()->allocator()); i.more(); i.advance()) {
if(!i->in_use_p()) continue;
if(!i->weak_p() && i->object()->young_object_p()) {
i->set_object(saw_object(i->object()));
// Users manipulate values accessible from the data* within an
// RData without running a write barrier. Thusly if we see a mature
// rdata, we must always scan it because it could contain
// young pointers.
} else if(!i->object()->young_object_p() && i->is_rdata()) {
scan_object(i->object());
}
}
std::list<capi::GlobalHandle*>* gh = data->global_handle_locations();
if(gh) {
for(std::list<capi::GlobalHandle*>::iterator i = gh->begin();
i != gh->end();
++i) {
capi::GlobalHandle* global_handle = *i;
capi::Handle** loc = global_handle->handle();
if(capi::Handle* hdl = *loc) {
if(!REFERENCE_P(hdl)) continue;
if(hdl->valid_p()) {
Object* obj = hdl->object();
if(obj && obj->reference_p() && obj->young_object_p()) {
hdl->set_object(saw_object(obj));
}
} else {
std::cerr << "Detected bad handle checking global capi handles\n";
}
}
}
}
#ifdef ENABLE_LLVM
if(LLVMState* ls = data->llvm_state()) ls->gc_scan(this);
#endif
// Handle all promotions to non-young space that occurred.
handle_promotions();
assert(fully_scanned_p());
// We're now done seeing the entire object graph of normal, live references.
// Now we get to handle the unusual references, like finalizers and such.
// Check any weakrefs and replace dead objects with nil
// We need to do this before checking finalizers so people can't access
// objects kept alive for finalization through weakrefs.
clean_weakrefs(true);
do {
// Objects with finalizers must be kept alive until the finalizers have
// run.
walk_finalizers();
// Scan any fibers that aren't running but still active
scan_fibers(data, false);
handle_promotions();
} while(!promoted_stack_.empty() && !fully_scanned_p());
// Remove unreachable locked objects still in the list
if(data->threads()) {
for(std::list<ManagedThread*>::iterator i = data->threads()->begin();
i != data->threads()->end();
++i) {
clean_locked_objects(*i, true);
}
}
// Update the pending mark set to remove unreachable objects.
update_mark_set();
// Update the existing mark stack of the mature gen because young
// objects might have moved.
update_mature_mark_stack();
// Update the weak ref set to remove unreachable weak refs.
update_weak_refs_set();
// Swap the 2 halves
Heap* x = next;
next = current;
current = x;
if(stats) {
stats->lifetime = lifetime_;
stats->percentage_used = current->percentage_used();
stats->promoted_objects = promoted_objects_;
stats->excess_objects = copy_spills_;
}
// Tune the age at which promotion occurs
if(autotune_lifetime_) {
double used = current->percentage_used();
if(used > cOverFullThreshold) {
if(tune_threshold_ >= cOverFullTimes) {
if(lifetime_ > cMinimumLifetime) lifetime_--;
} else {
tune_threshold_++;
}
} else if(used < cUnderFullThreshold) {
if(tune_threshold_ <= cUnderFullTimes) {
if(lifetime_ < cMaximumLifetime) lifetime_++;
} else {
tune_threshold_--;
}
} else if(tune_threshold_ > 0) {
tune_threshold_--;
} else if(tune_threshold_ < 0) {
tune_threshold_++;
} else if(tune_threshold_ == 0) {
if(lifetime_ < original_lifetime_) {
lifetime_++;
} else if(lifetime_ > original_lifetime_) {
lifetime_--;
}
}
}
}
