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

comparison src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.cpp @ 3774:c9ca3f51cf41

6994322: Remove the is_tlab and is_noref / is_large_noref parameters from the CollectedHeap Summary: Remove two unused parameters from the mem_allocate() method and update its uses accordingly. Reviewed-by: stefank, johnc

author	tonyp
date	Thu, 16 Jun 2011 15:51:57 -0400
parents	6747fd0512e0
children	c2bf0120ee5d

comparison

equal deleted inserted replaced

-:5130fa1b24f1
+:c9ca3f51cf41
 // and the rest will not be executed. For that reason, this method loops
 // during failed allocation attempts. If the java heap becomes exhausted,
 // we rely on the size_policy object to force a bail out.
 HeapWord* ParallelScavengeHeap::mem_allocate(
 size_t size,
-bool is_noref,
-bool is_tlab,
 bool* gc_overhead_limit_was_exceeded) {
 assert(!SafepointSynchronize::is_at_safepoint(), "should not be at safepoint");
 assert(Thread::current() != (Thread*)VMThread::vm_thread(), "should not be in vm thread");
 assert(!Heap_lock->owned_by_self(), "this thread should not own the Heap_lock");
 // In general gc_overhead_limit_was_exceeded should be false so
 // set it so here and reset it to true only if the gc time
 // limit is being exceeded as checked below.
 *gc_overhead_limit_was_exceeded = false;
-HeapWord* result = young_gen()->allocate(size, is_tlab);
+HeapWord* result = young_gen()->allocate(size);
 uint loop_count = 0;
 uint gc_count = 0;
 while (result == NULL) {
 // total_collections() value!
 {
 MutexLocker ml(Heap_lock);
 gc_count = Universe::heap()->total_collections();
-result = young_gen()->allocate(size, is_tlab);
+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
 // 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 (!is_tlab &&
+if (size >= (young_gen()->eden_space()->capacity_in_words(Thread::current()) / 2)) {
-size >= (young_gen()->eden_space()->capacity_in_words(Thread::current()) / 2)) {
+result = old_gen()->allocate(size);
-result = old_gen()->allocate(size, is_tlab);
 if (result != NULL) {
 return result;
 }
 }
 if (GC_locker::is_active_and_needs_gc()) {
-// GC is locked out. If this is a TLAB allocation,
-// return NULL; the requestor will retry allocation
-// of an idividual object at a time.
-if (is_tlab) {
-return NULL;
-}
 // 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
 // we retry the allocation sequence from the beginning of the loop,
 }
 if (result == NULL) {
 // Generate a VM operation
-VM_ParallelGCFailedAllocation op(size, is_tlab, gc_count);
+VM_ParallelGCFailedAllocation op(size, gc_count);
 VMThread::execute(&op);
 // Did the VM operation execute? If so, return the result directly.
 // This prevents us from looping until time out on requests that can
 // not be satisfied.
 // time spent in gc crosses a threshold, we will bail out.
 loop_count++;
 if ((result == NULL) && (QueuedAllocationWarningCount > 0) &&
 (loop_count % QueuedAllocationWarningCount == 0)) {
 warning("ParallelScavengeHeap::mem_allocate retries %d times \n\t"
-" size=%d %s", loop_count, size, is_tlab ? "(TLAB)" : "");
+" size=%d", loop_count, size);
 }
 }
 return result;
 }
 // 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,
 // and when to attempt collections, but no collection specific policy.
-HeapWord* ParallelScavengeHeap::failed_mem_allocate(size_t size, bool is_tlab) {
+HeapWord* ParallelScavengeHeap::failed_mem_allocate(size_t size) {
 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");
 // unless we collect.
 // First level allocation failure, scavenge and allocate in young gen.
 GCCauseSetter gccs(this, GCCause::_allocation_failure);
 PSScavenge::invoke();
-HeapWord* result = young_gen()->allocate(size, is_tlab);
+HeapWord* result = young_gen()->allocate(size);
 // Second level allocation failure.
 //   Mark sweep and allocate in young generation.
 if (result == NULL) {
 // There is some chance the scavenge method decided to invoke mark_sweep.
 // Don't mark sweep twice if so.
 if (mark_sweep_invocation_count == total_invocations()) {
 invoke_full_gc(false);
-result = young_gen()->allocate(size, is_tlab);
+result = young_gen()->allocate(size);
 }
 }
 // Third level allocation failure.
 //   After mark sweep and young generation allocation failure,
 //   allocate in old generation.
-if (result == NULL && !is_tlab) {
+if (result == NULL) {
-result = old_gen()->allocate(size, is_tlab);
+result = old_gen()->allocate(size);
 }
 // Fourth level allocation failure. We're running out of memory.
 //   More complete mark sweep and allocate in young generation.
 if (result == NULL) {
 invoke_full_gc(true);
-result = young_gen()->allocate(size, is_tlab);
+result = young_gen()->allocate(size);
 }
 // Fifth level allocation failure.
 //   After more complete mark sweep, allocate in old generation.
-if (result == NULL && !is_tlab) {
+if (result == NULL) {
-result = old_gen()->allocate(size, is_tlab);
+result = old_gen()->allocate(size);
 }
 return result;
 }
 size_t ParallelScavengeHeap::unsafe_max_tlab_alloc(Thread* thr) const {
 return young_gen()->eden_space()->unsafe_max_tlab_alloc(thr);
 }
 HeapWord* ParallelScavengeHeap::allocate_new_tlab(size_t size) {
-return young_gen()->allocate(size, true);
+return young_gen()->allocate(size);
 }
 void ParallelScavengeHeap::accumulate_statistics_all_tlabs() {
 CollectedHeap::accumulate_statistics_all_tlabs();
 }

Mercurial > hg > truffle

comparison src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.cpp @ 3774:c9ca3f51cf41