truffle: src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.cpp comparison

comparison src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.cpp @ 4914:23c0eb012d6f

6330863: vm/gc/InfiniteList.java fails intermittently due to timeout Summary: in some cases, allocate from the old gen before doing a full gc Reviewed-by: stefank, jmasa

author	jcoomes
date	Thu, 16 Feb 2012 13:13:53 -0800
parents	53074c2c4600
children	b632e80fc9dc

comparison

equal deleted inserted replaced

-:ab4422d0ed59
+:23c0eb012d6f
 /*
-* Copyright (c) 2001, 2011, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 {
 MutexLocker ml(Heap_lock);
 gc_count = Universe::heap()->total_collections();
 result = young_gen()->allocate(size);
-// (1) If the requested object is too large to easily fit in the
-//     young_gen, or
-// (2) If GC is locked out via GCLocker, young gen is full and
-//     the need for a GC already signalled to GCLocker (done
-//     at a safepoint),
-// ... then, rather than force a safepoint and (a potentially futile)
-// collection (attempt) for each allocation, try allocation directly
-// in old_gen. For case (2) above, we may in the future allow
-// TLAB allocation directly in the old gen.
 if (result != NULL) {
 return result;
 }
-if (size >= (young_gen()->eden_space()->capacity_in_words(Thread::current()) / 2)) {
-result = old_gen()->allocate(size);
+// If certain conditions hold, try allocating from the old gen.
-if (result != NULL) {
+result = mem_allocate_old_gen(size);
-return result;
+if (result != NULL) {
-}
+return result;
 }
+// Failed to allocate without a gc.
 if (GC_locker::is_active_and_needs_gc()) {
 // If this thread is not in a jni critical section, we stall
 // the requestor until the critical section has cleared and
 // GC allowed. When the critical section clears, a GC is
 // initiated by the last thread exiting the critical section; so
 }
 }
 }
 if (result == NULL) {
 // Generate a VM operation
 VM_ParallelGCFailedAllocation op(size, gc_count);
 VMThread::execute(&op);
 // Did the VM operation execute? If so, return the result directly.
 }
 return result;
 }
+// A "death march" is a series of ultra-slow allocations in which a full gc is
+// done before each allocation, and after the full gc the allocation still
+// cannot be satisfied from the young gen.  This routine detects that condition;
+// it should be called after a full gc has been done and the allocation
+// attempted from the young gen. The parameter 'addr' should be the result of
+// that young gen allocation attempt.
+void
+ParallelScavengeHeap::death_march_check(HeapWord* const addr, size_t size) {
+if (addr != NULL) {
+_death_march_count = 0;  // death march has ended
+} else if (_death_march_count == 0) {
+if (should_alloc_in_eden(size)) {
+_death_march_count = 1;    // death march has started
+}
+}
+}
+HeapWord* ParallelScavengeHeap::mem_allocate_old_gen(size_t size) {
+if (!should_alloc_in_eden(size) || GC_locker::is_active_and_needs_gc()) {
+// Size is too big for eden, or gc is locked out.
+return old_gen()->allocate(size);
+}
+// If a "death march" is in progress, allocate from the old gen a limited
+// number of times before doing a GC.
+if (_death_march_count > 0) {
+if (_death_march_count < 64) {
+++_death_march_count;
+return old_gen()->allocate(size);
+} else {
+_death_march_count = 0;
+}
+}
+return NULL;
+}
 // Failed allocation policy. Must be called from the VM thread, and
 // only at a safepoint! Note that this method has policy for allocation
 // flow, and NOT collection policy. So we do not check for gc collection
 // time over limit here, that is the responsibility of the heap specific
 // collection methods. This method decides where to attempt allocations,
 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");
 assert(!Heap_lock->owned_by_self(), "this thread should not own the Heap_lock");
-size_t mark_sweep_invocation_count = total_invocations();
+// We assume that allocation in eden will fail unless we collect.
-// We assume (and assert!) that an allocation at this point will fail
-// unless we collect.
 // First level allocation failure, scavenge and allocate in young gen.
 GCCauseSetter gccs(this, GCCause::_allocation_failure);
-PSScavenge::invoke();
+const bool invoked_full_gc = PSScavenge::invoke();
 HeapWord* result = young_gen()->allocate(size);
 // Second level allocation failure.
 //   Mark sweep and allocate in young generation.
-if (result == NULL) {
+if (result == NULL && !invoked_full_gc) {
-// There is some chance the scavenge method decided to invoke mark_sweep.
+invoke_full_gc(false);
-// Don't mark sweep twice if so.
+result = young_gen()->allocate(size);
-if (mark_sweep_invocation_count == total_invocations()) {
+}
-invoke_full_gc(false);
-result = young_gen()->allocate(size);
+death_march_check(result, size);
-}
-}
 // Third level allocation failure.
 //   After mark sweep and young generation allocation failure,
 //   allocate in old generation.
 if (result == NULL) {

Mercurial > hg > truffle

comparison src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.cpp @ 4914:23c0eb012d6f