truffle: src/share/vm/gc_implementation/shared/vmGCOperations.cpp annotate

annotate src/share/vm/gc_implementation/shared/vmGCOperations.cpp @ 1842:6e0aac35bfa9

6980838: G1: guarantee(false) failed: thread has an unexpected active value in its SATB queue Summary: Under certain circumstances a safepoint could happen between a JavaThread object being created and that object being added to the Java threads list. This could cause the active field of that thread's SATB queue to get out-of-sync with respect to the other Java threads. The solution is to activate the SATB queue, when necessary, before adding the thread to the Java threads list, not when the JavaThread object is created. The changeset also includes a small fix to rename the surrogate locker thread from "Surrogate Locker Thread (CMS)" to "Surrogate Locker Thread (Concurrent GC)" since it's also used in G1. Reviewed-by: iveresov, ysr, johnc, jcoomes

author	tonyp
date	Fri, 01 Oct 2010 16:43:05 -0400
parents	c18cbe5936b8
children	f95d63e2154a

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
1552 c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1547 diff changeset	2 * Copyright (c) 2005, 2008, Oracle and/or its affiliates. All rights reserved.
0 a61af66fc99e Initial load duke parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load duke parents: diff changeset	4 *
a61af66fc99e Initial load duke parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load duke parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load duke parents: diff changeset	7 * published by the Free Software Foundation.
a61af66fc99e Initial load duke parents: diff changeset	8 *
a61af66fc99e Initial load duke parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load duke parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load duke parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load duke parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load duke parents: diff changeset	13 * accompanied this code).
a61af66fc99e Initial load duke parents: diff changeset	14 *
a61af66fc99e Initial load duke parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load duke parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load duke parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load duke parents: diff changeset	18 *
1552 c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1547 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1547 diff changeset	20 * or visit www.oracle.com if you need additional information or have any
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1547 diff changeset	21 * questions.
0 a61af66fc99e Initial load duke parents: diff changeset	22 *
a61af66fc99e Initial load duke parents: diff changeset	23 */
a61af66fc99e Initial load duke parents: diff changeset	24 # include "incls/_precompiled.incl"
a61af66fc99e Initial load duke parents: diff changeset	25 # include "incls/_vmGCOperations.cpp.incl"
a61af66fc99e Initial load duke parents: diff changeset	26
a61af66fc99e Initial load duke parents: diff changeset	27 HS_DTRACE_PROBE_DECL1(hotspot, gc__begin, bool);
a61af66fc99e Initial load duke parents: diff changeset	28 HS_DTRACE_PROBE_DECL(hotspot, gc__end);
a61af66fc99e Initial load duke parents: diff changeset	29
a61af66fc99e Initial load duke parents: diff changeset	30 // The same dtrace probe can't be inserted in two different files, so we
a61af66fc99e Initial load duke parents: diff changeset	31 // have to call it here, so it's only in one file. Can't create new probes
a61af66fc99e Initial load duke parents: diff changeset	32 // for the other file anymore. The dtrace probes have to remain stable.
a61af66fc99e Initial load duke parents: diff changeset	33 void VM_GC_Operation::notify_gc_begin(bool full) {
a61af66fc99e Initial load duke parents: diff changeset	34 HS_DTRACE_PROBE1(hotspot, gc__begin, full);
1547 fb1a39993f69 6951319: enable solaris builds using Sun Studio 12 update 1 jcoomes parents: 1392 diff changeset	35 HS_DTRACE_WORKAROUND_TAIL_CALL_BUG();
0 a61af66fc99e Initial load duke parents: diff changeset	36 }
a61af66fc99e Initial load duke parents: diff changeset	37
a61af66fc99e Initial load duke parents: diff changeset	38 void VM_GC_Operation::notify_gc_end() {
a61af66fc99e Initial load duke parents: diff changeset	39 HS_DTRACE_PROBE(hotspot, gc__end);
1547 fb1a39993f69 6951319: enable solaris builds using Sun Studio 12 update 1 jcoomes parents: 1392 diff changeset	40 HS_DTRACE_WORKAROUND_TAIL_CALL_BUG();
0 a61af66fc99e Initial load duke parents: diff changeset	41 }
a61af66fc99e Initial load duke parents: diff changeset	42
a61af66fc99e Initial load duke parents: diff changeset	43 void VM_GC_Operation::acquire_pending_list_lock() {
a61af66fc99e Initial load duke parents: diff changeset	44 // we may enter this with pending exception set
a61af66fc99e Initial load duke parents: diff changeset	45 instanceRefKlass::acquire_pending_list_lock(&_pending_list_basic_lock);
a61af66fc99e Initial load duke parents: diff changeset	46 }
a61af66fc99e Initial load duke parents: diff changeset	47
a61af66fc99e Initial load duke parents: diff changeset	48
a61af66fc99e Initial load duke parents: diff changeset	49 void VM_GC_Operation::release_and_notify_pending_list_lock() {
a61af66fc99e Initial load duke parents: diff changeset	50
a61af66fc99e Initial load duke parents: diff changeset	51 instanceRefKlass::release_and_notify_pending_list_lock(&_pending_list_basic_lock);
a61af66fc99e Initial load duke parents: diff changeset	52 }
a61af66fc99e Initial load duke parents: diff changeset	53
a61af66fc99e Initial load duke parents: diff changeset	54 // Allocations may fail in several threads at about the same time,
a61af66fc99e Initial load duke parents: diff changeset	55 // resulting in multiple gc requests. We only want to do one of them.
a61af66fc99e Initial load duke parents: diff changeset	56 // In case a GC locker is active and the need for a GC is already signalled,
a61af66fc99e Initial load duke parents: diff changeset	57 // we want to skip this GC attempt altogether, without doing a futile
a61af66fc99e Initial load duke parents: diff changeset	58 // safepoint operation.
a61af66fc99e Initial load duke parents: diff changeset	59 bool VM_GC_Operation::skip_operation() const {
a61af66fc99e Initial load duke parents: diff changeset	60 bool skip = (_gc_count_before != Universe::heap()->total_collections());
a61af66fc99e Initial load duke parents: diff changeset	61 if (_full && skip) {
a61af66fc99e Initial load duke parents: diff changeset	62 skip = (_full_gc_count_before != Universe::heap()->total_full_collections());
a61af66fc99e Initial load duke parents: diff changeset	63 }
a61af66fc99e Initial load duke parents: diff changeset	64 if (!skip && GC_locker::is_active_and_needs_gc()) {
a61af66fc99e Initial load duke parents: diff changeset	65 skip = Universe::heap()->is_maximal_no_gc();
a61af66fc99e Initial load duke parents: diff changeset	66 assert(!(skip && (_gc_cause == GCCause::_gc_locker)),
a61af66fc99e Initial load duke parents: diff changeset	67 "GC_locker cannot be active when initiating GC");
a61af66fc99e Initial load duke parents: diff changeset	68 }
a61af66fc99e Initial load duke parents: diff changeset	69 return skip;
a61af66fc99e Initial load duke parents: diff changeset	70 }
a61af66fc99e Initial load duke parents: diff changeset	71
a61af66fc99e Initial load duke parents: diff changeset	72 bool VM_GC_Operation::doit_prologue() {
a61af66fc99e Initial load duke parents: diff changeset	73 assert(Thread::current()->is_Java_thread(), "just checking");
a61af66fc99e Initial load duke parents: diff changeset	74
a61af66fc99e Initial load duke parents: diff changeset	75 acquire_pending_list_lock();
a61af66fc99e Initial load duke parents: diff changeset	76 // If the GC count has changed someone beat us to the collection
a61af66fc99e Initial load duke parents: diff changeset	77 // Get the Heap_lock after the pending_list_lock.
a61af66fc99e Initial load duke parents: diff changeset	78 Heap_lock->lock();
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 139 diff changeset	79
0 a61af66fc99e Initial load duke parents: diff changeset	80 // Check invocations
a61af66fc99e Initial load duke parents: diff changeset	81 if (skip_operation()) {
a61af66fc99e Initial load duke parents: diff changeset	82 // skip collection
a61af66fc99e Initial load duke parents: diff changeset	83 Heap_lock->unlock();
a61af66fc99e Initial load duke parents: diff changeset	84 release_and_notify_pending_list_lock();
a61af66fc99e Initial load duke parents: diff changeset	85 _prologue_succeeded = false;
a61af66fc99e Initial load duke parents: diff changeset	86 } else {
a61af66fc99e Initial load duke parents: diff changeset	87 _prologue_succeeded = true;
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 139 diff changeset	88 SharedHeap* sh = SharedHeap::heap();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 139 diff changeset	89 if (sh != NULL) sh->_thread_holds_heap_lock_for_gc = true;
0 a61af66fc99e Initial load duke parents: diff changeset	90 }
a61af66fc99e Initial load duke parents: diff changeset	91 return _prologue_succeeded;
a61af66fc99e Initial load duke parents: diff changeset	92 }
a61af66fc99e Initial load duke parents: diff changeset	93
a61af66fc99e Initial load duke parents: diff changeset	94
a61af66fc99e Initial load duke parents: diff changeset	95 void VM_GC_Operation::doit_epilogue() {
a61af66fc99e Initial load duke parents: diff changeset	96 assert(Thread::current()->is_Java_thread(), "just checking");
a61af66fc99e Initial load duke parents: diff changeset	97 // Release the Heap_lock first.
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 139 diff changeset	98 SharedHeap* sh = SharedHeap::heap();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 139 diff changeset	99 if (sh != NULL) sh->_thread_holds_heap_lock_for_gc = false;
0 a61af66fc99e Initial load duke parents: diff changeset	100 Heap_lock->unlock();
a61af66fc99e Initial load duke parents: diff changeset	101 release_and_notify_pending_list_lock();
a61af66fc99e Initial load duke parents: diff changeset	102 }
a61af66fc99e Initial load duke parents: diff changeset	103
a61af66fc99e Initial load duke parents: diff changeset	104 bool VM_GC_HeapInspection::doit_prologue() {
a61af66fc99e Initial load duke parents: diff changeset	105 if (Universe::heap()->supports_heap_inspection()) {
a61af66fc99e Initial load duke parents: diff changeset	106 return VM_GC_Operation::doit_prologue();
a61af66fc99e Initial load duke parents: diff changeset	107 } else {
a61af66fc99e Initial load duke parents: diff changeset	108 return false;
a61af66fc99e Initial load duke parents: diff changeset	109 }
a61af66fc99e Initial load duke parents: diff changeset	110 }
a61af66fc99e Initial load duke parents: diff changeset	111
a61af66fc99e Initial load duke parents: diff changeset	112 bool VM_GC_HeapInspection::skip_operation() const {
a61af66fc99e Initial load duke parents: diff changeset	113 assert(Universe::heap()->supports_heap_inspection(), "huh?");
a61af66fc99e Initial load duke parents: diff changeset	114 return false;
a61af66fc99e Initial load duke parents: diff changeset	115 }
a61af66fc99e Initial load duke parents: diff changeset	116
a61af66fc99e Initial load duke parents: diff changeset	117 void VM_GC_HeapInspection::doit() {
a61af66fc99e Initial load duke parents: diff changeset	118 HandleMark hm;
a61af66fc99e Initial load duke parents: diff changeset	119 CollectedHeap* ch = Universe::heap();
1392 bdb5361c461c 6897143: Stress test crashes during HeapInspection using ParallelGC. kevinw parents: 615 diff changeset	120 ch->ensure_parsability(false); // must happen, even if collection does
bdb5361c461c 6897143: Stress test crashes during HeapInspection using ParallelGC. kevinw parents: 615 diff changeset	121 // not happen (e.g. due to GC_locker)
0 a61af66fc99e Initial load duke parents: diff changeset	122 if (_full_gc) {
1392 bdb5361c461c 6897143: Stress test crashes during HeapInspection using ParallelGC. kevinw parents: 615 diff changeset	123 // The collection attempt below would be skipped anyway if
bdb5361c461c 6897143: Stress test crashes during HeapInspection using ParallelGC. kevinw parents: 615 diff changeset	124 // the gc locker is held. The following dump may then be a tad
bdb5361c461c 6897143: Stress test crashes during HeapInspection using ParallelGC. kevinw parents: 615 diff changeset	125 // misleading to someone expecting only live objects to show
bdb5361c461c 6897143: Stress test crashes during HeapInspection using ParallelGC. kevinw parents: 615 diff changeset	126 // up in the dump (see CR 6944195). Just issue a suitable warning
bdb5361c461c 6897143: Stress test crashes during HeapInspection using ParallelGC. kevinw parents: 615 diff changeset	127 // in that case and do not attempt to do a collection.
bdb5361c461c 6897143: Stress test crashes during HeapInspection using ParallelGC. kevinw parents: 615 diff changeset	128 // The latter is a subtle point, because even a failed attempt
bdb5361c461c 6897143: Stress test crashes during HeapInspection using ParallelGC. kevinw parents: 615 diff changeset	129 // to GC will, in fact, induce one in the future, which we
bdb5361c461c 6897143: Stress test crashes during HeapInspection using ParallelGC. kevinw parents: 615 diff changeset	130 // probably want to avoid in this case because the GC that we may
bdb5361c461c 6897143: Stress test crashes during HeapInspection using ParallelGC. kevinw parents: 615 diff changeset	131 // be about to attempt holds value for us only
bdb5361c461c 6897143: Stress test crashes during HeapInspection using ParallelGC. kevinw parents: 615 diff changeset	132 // if it happens now and not if it happens in the eventual
bdb5361c461c 6897143: Stress test crashes during HeapInspection using ParallelGC. kevinw parents: 615 diff changeset	133 // future.
bdb5361c461c 6897143: Stress test crashes during HeapInspection using ParallelGC. kevinw parents: 615 diff changeset	134 if (GC_locker::is_active()) {
bdb5361c461c 6897143: Stress test crashes during HeapInspection using ParallelGC. kevinw parents: 615 diff changeset	135 warning("GC locker is held; pre-dump GC was skipped");
bdb5361c461c 6897143: Stress test crashes during HeapInspection using ParallelGC. kevinw parents: 615 diff changeset	136 } else {
bdb5361c461c 6897143: Stress test crashes during HeapInspection using ParallelGC. kevinw parents: 615 diff changeset	137 ch->collect_as_vm_thread(GCCause::_heap_inspection);
bdb5361c461c 6897143: Stress test crashes during HeapInspection using ParallelGC. kevinw parents: 615 diff changeset	138 }
0 a61af66fc99e Initial load duke parents: diff changeset	139 }
615 c6c601a0f2d6 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC ysr parents: 356 diff changeset	140 HeapInspection::heap_inspection(_out, _need_prologue /* need_prologue */);
0 a61af66fc99e Initial load duke parents: diff changeset	141 }
a61af66fc99e Initial load duke parents: diff changeset	142
a61af66fc99e Initial load duke parents: diff changeset	143
a61af66fc99e Initial load duke parents: diff changeset	144 void VM_GenCollectForAllocation::doit() {
a61af66fc99e Initial load duke parents: diff changeset	145 JvmtiGCForAllocationMarker jgcm;
a61af66fc99e Initial load duke parents: diff changeset	146 notify_gc_begin(false);
a61af66fc99e Initial load duke parents: diff changeset	147
a61af66fc99e Initial load duke parents: diff changeset	148 GenCollectedHeap* gch = GenCollectedHeap::heap();
a61af66fc99e Initial load duke parents: diff changeset	149 GCCauseSetter gccs(gch, _gc_cause);
a61af66fc99e Initial load duke parents: diff changeset	150 _res = gch->satisfy_failed_allocation(_size, _tlab);
a61af66fc99e Initial load duke parents: diff changeset	151 assert(gch->is_in_reserved_or_null(_res), "result not in heap");
a61af66fc99e Initial load duke parents: diff changeset	152
a61af66fc99e Initial load duke parents: diff changeset	153 if (_res == NULL && GC_locker::is_active_and_needs_gc()) {
a61af66fc99e Initial load duke parents: diff changeset	154 set_gc_locked();
a61af66fc99e Initial load duke parents: diff changeset	155 }
a61af66fc99e Initial load duke parents: diff changeset	156 notify_gc_end();
a61af66fc99e Initial load duke parents: diff changeset	157 }
a61af66fc99e Initial load duke parents: diff changeset	158
a61af66fc99e Initial load duke parents: diff changeset	159 void VM_GenCollectFull::doit() {
a61af66fc99e Initial load duke parents: diff changeset	160 JvmtiGCFullMarker jgcm;
a61af66fc99e Initial load duke parents: diff changeset	161 notify_gc_begin(true);
a61af66fc99e Initial load duke parents: diff changeset	162
a61af66fc99e Initial load duke parents: diff changeset	163 GenCollectedHeap* gch = GenCollectedHeap::heap();
a61af66fc99e Initial load duke parents: diff changeset	164 GCCauseSetter gccs(gch, _gc_cause);
a61af66fc99e Initial load duke parents: diff changeset	165 gch->do_full_collection(gch->must_clear_all_soft_refs(), _max_level);
a61af66fc99e Initial load duke parents: diff changeset	166 notify_gc_end();
a61af66fc99e Initial load duke parents: diff changeset	167 }
139 c0492d52d55b 6539517: CR 6186200 should be extended to perm gen allocation to prevent spurious OOM's from perm gen apetrusenko parents: 0 diff changeset	168
c0492d52d55b 6539517: CR 6186200 should be extended to perm gen allocation to prevent spurious OOM's from perm gen apetrusenko parents: 0 diff changeset	169 void VM_GenCollectForPermanentAllocation::doit() {
c0492d52d55b 6539517: CR 6186200 should be extended to perm gen allocation to prevent spurious OOM's from perm gen apetrusenko parents: 0 diff changeset	170 JvmtiGCForAllocationMarker jgcm;
c0492d52d55b 6539517: CR 6186200 should be extended to perm gen allocation to prevent spurious OOM's from perm gen apetrusenko parents: 0 diff changeset	171 notify_gc_begin(true);
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 139 diff changeset	172 SharedHeap* heap = (SharedHeap*)Universe::heap();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 139 diff changeset	173 GCCauseSetter gccs(heap, _gc_cause);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 139 diff changeset	174 switch (heap->kind()) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 139 diff changeset	175 case (CollectedHeap::GenCollectedHeap): {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 139 diff changeset	176 GenCollectedHeap* gch = (GenCollectedHeap*)heap;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 139 diff changeset	177 gch->do_full_collection(gch->must_clear_all_soft_refs(),
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 139 diff changeset	178 gch->n_gens() - 1);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 139 diff changeset	179 break;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 139 diff changeset	180 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 139 diff changeset	181 #ifndef SERIALGC
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 139 diff changeset	182 case (CollectedHeap::G1CollectedHeap): {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 139 diff changeset	183 G1CollectedHeap* g1h = (G1CollectedHeap*)heap;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 139 diff changeset	184 g1h->do_full_collection(_gc_cause == GCCause::_last_ditch_collection);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 139 diff changeset	185 break;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 139 diff changeset	186 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 139 diff changeset	187 #endif // SERIALGC
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 139 diff changeset	188 default:
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 139 diff changeset	189 ShouldNotReachHere();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 139 diff changeset	190 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 139 diff changeset	191 _res = heap->perm_gen()->allocate(_size, false);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 139 diff changeset	192 assert(heap->is_in_reserved_or_null(_res), "result not in heap");
139 c0492d52d55b 6539517: CR 6186200 should be extended to perm gen allocation to prevent spurious OOM's from perm gen apetrusenko parents: 0 diff changeset	193 if (_res == NULL && GC_locker::is_active_and_needs_gc()) {
c0492d52d55b 6539517: CR 6186200 should be extended to perm gen allocation to prevent spurious OOM's from perm gen apetrusenko parents: 0 diff changeset	194 set_gc_locked();
c0492d52d55b 6539517: CR 6186200 should be extended to perm gen allocation to prevent spurious OOM's from perm gen apetrusenko parents: 0 diff changeset	195 }
c0492d52d55b 6539517: CR 6186200 should be extended to perm gen allocation to prevent spurious OOM's from perm gen apetrusenko parents: 0 diff changeset	196 notify_gc_end();
c0492d52d55b 6539517: CR 6186200 should be extended to perm gen allocation to prevent spurious OOM's from perm gen apetrusenko parents: 0 diff changeset	197 }

Mercurial > hg > truffle

annotate src/share/vm/gc_implementation/shared/vmGCOperations.cpp @ 1842:6e0aac35bfa9