// This method contains all heap specific policy for invoking mark sweep. // PSMarkSweep::invoke_no_policy() will only attempt to mark-sweep-compact // the heap. It will do nothing further. If we need to bail out for policy // reasons, scavenge before full gc, or any other specialized behavior, it // needs to be added here. // // Note that this method should only be called from the vm_thread while // at a safepoint! void PSMarkSweep::invoke(bool maximum_heap_compaction) { assert(SafepointSynchronize::is_at_safepoint(), "should be at safepoint"); assert(Thread::current() == (Thread*)VMThread::vm_thread(), "should be in vm thread"); assert(!Universe::heap()->is_gc_active(), "not reentrant"); ParallelScavengeHeap* heap = (ParallelScavengeHeap*)Universe::heap(); GCCause::Cause gc_cause = heap->gc_cause(); PSAdaptiveSizePolicy* policy = heap->size_policy(); // Before each allocation/collection attempt, find out from the // policy object if GCs are, on the whole, taking too long. If so, // bail out without attempting a collection. The exceptions are // for explicitly requested GC's. if (!policy->gc_time_limit_exceeded() || GCCause::is_user_requested_gc(gc_cause) || GCCause::is_serviceability_requested_gc(gc_cause)) { IsGCActiveMark mark; if (ScavengeBeforeFullGC) { PSScavenge::invoke_no_policy(); } int count = (maximum_heap_compaction)?1:MarkSweepAlwaysCompactCount; IntFlagSetting flag_setting(MarkSweepAlwaysCompactCount, count); PSMarkSweep::invoke_no_policy(maximum_heap_compaction); } }
void PSMarkSweep::invoke(bool maximum_heap_compaction) { assert(SafepointSynchronize::is_at_safepoint(), "should be at safepoint"); assert(Thread::current() == (Thread*)VMThread::vm_thread(), "should be in vm thread"); assert(!ParallelScavengeHeap::heap()->is_gc_active(), "not reentrant"); ParallelScavengeHeap* heap = ParallelScavengeHeap::heap(); GCCause::Cause gc_cause = heap->gc_cause(); PSAdaptiveSizePolicy* policy = heap->size_policy(); IsGCActiveMark mark; if (ScavengeBeforeFullGC) { PSScavenge::invoke_no_policy(); } const bool clear_all_soft_refs = heap->collector_policy()->should_clear_all_soft_refs(); uint count = maximum_heap_compaction ? 1 : MarkSweepAlwaysCompactCount; UIntFlagSetting flag_setting(MarkSweepAlwaysCompactCount, count); PSMarkSweep::invoke_no_policy(clear_all_soft_refs || maximum_heap_compaction); }
// This method contains all heap specific policy for invoking mark sweep. // PSMarkSweep::invoke_no_policy() will only attempt to mark-sweep-compact // the heap. It will do nothing further. If we need to bail out for policy // reasons, scavenge before full gc, or any other specialized behavior, it // needs to be added here. // // Note that this method should only be called from the vm_thread while // at a safepoint! void PSMarkSweep::invoke(bool& notify_ref_lock, bool maximum_heap_compaction) { assert(SafepointSynchronize::is_at_safepoint(), "should be at safepoint"); assert(Thread::current() == (Thread*)VMThread::vm_thread(), "should be in vm thread"); assert(!Universe::heap()->is_gc_active(), "not reentrant"); AdaptiveSizePolicy* policy = ParallelScavengeHeap::size_policy(); // Before each allocation/collection attempt, find out from the // policy object if GCs are, on the whole, taking too long. If so, // bail out without attempting a collection. if (!policy->gc_time_limit_exceeded()) { IsGCActiveMark mark; if (ScavengeBeforeFullGC) { PSScavenge::invoke_no_policy(notify_ref_lock); } int count = (maximum_heap_compaction)?1:MarkSweepAlwaysCompactCount; IntFlagSetting flag_setting(MarkSweepAlwaysCompactCount, count); PSMarkSweep::invoke_no_policy(notify_ref_lock, maximum_heap_compaction); } }