annotate src/share/vm/memory/gcLocker.hpp @ 1994:6cd6d394f280

7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed()) 7002546: regression on SpecJbb2005 on 7b118 comparing to 7b117 on small heaps Summary: Relaxed assertion checking related to incremental_collection_failed flag to allow for ExplicitGCInvokesConcurrent behaviour where we do not want a failing scavenge to bail to a stop-world collection. Parameterized incremental_collection_will_fail() so we can selectively use, or not use, as appropriate, the statistical prediction at specific use sites. This essentially reverts the scavenge bail-out logic to what it was prior to some recent changes that had inadvertently started using the statistical prediction which can be noisy in the presence of bursty loads. Added some associated verbose non-product debugging messages. Reviewed-by: johnc, tonyp
author ysr
date Tue, 07 Dec 2010 21:55:53 -0800
parents f95d63e2154a
children f08d439fab8c
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1 /*
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
2 * Copyright (c) 1997, 2010, 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: 844
diff changeset
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 844
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: 844
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
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
25 #ifndef SHARE_VM_MEMORY_GCLOCKER_HPP
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
26 #define SHARE_VM_MEMORY_GCLOCKER_HPP
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
27
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
28 #include "gc_interface/collectedHeap.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
29 #include "memory/genCollectedHeap.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
30 #include "memory/universe.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
31 #include "oops/oop.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
32 #ifdef TARGET_OS_FAMILY_linux
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
33 # include "os_linux.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
34 # include "thread_linux.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
35 #endif
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
36 #ifdef TARGET_OS_FAMILY_solaris
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
37 # include "os_solaris.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
38 # include "thread_solaris.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
39 #endif
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
40 #ifdef TARGET_OS_FAMILY_windows
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
41 # include "os_windows.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
42 # include "thread_windows.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
43 #endif
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
44
0
a61af66fc99e Initial load
duke
parents:
diff changeset
45 // The direct lock/unlock calls do not force a collection if an unlock
a61af66fc99e Initial load
duke
parents:
diff changeset
46 // decrements the count to zero. Avoid calling these if at all possible.
a61af66fc99e Initial load
duke
parents:
diff changeset
47
a61af66fc99e Initial load
duke
parents:
diff changeset
48 class GC_locker: public AllStatic {
a61af66fc99e Initial load
duke
parents:
diff changeset
49 private:
a61af66fc99e Initial load
duke
parents:
diff changeset
50 static volatile jint _jni_lock_count; // number of jni active instances
a61af66fc99e Initial load
duke
parents:
diff changeset
51 static volatile jint _lock_count; // number of other active instances
a61af66fc99e Initial load
duke
parents:
diff changeset
52 static volatile bool _needs_gc; // heap is filling, we need a GC
a61af66fc99e Initial load
duke
parents:
diff changeset
53 // note: bool is typedef'd as jint
a61af66fc99e Initial load
duke
parents:
diff changeset
54 static volatile bool _doing_gc; // unlock_critical() is doing a GC
a61af66fc99e Initial load
duke
parents:
diff changeset
55
a61af66fc99e Initial load
duke
parents:
diff changeset
56 // Accessors
a61af66fc99e Initial load
duke
parents:
diff changeset
57 static bool is_jni_active() {
a61af66fc99e Initial load
duke
parents:
diff changeset
58 return _jni_lock_count > 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
59 }
a61af66fc99e Initial load
duke
parents:
diff changeset
60
a61af66fc99e Initial load
duke
parents:
diff changeset
61 static void set_needs_gc() {
a61af66fc99e Initial load
duke
parents:
diff changeset
62 assert(SafepointSynchronize::is_at_safepoint(),
a61af66fc99e Initial load
duke
parents:
diff changeset
63 "needs_gc is only set at a safepoint");
a61af66fc99e Initial load
duke
parents:
diff changeset
64 _needs_gc = true;
a61af66fc99e Initial load
duke
parents:
diff changeset
65 }
a61af66fc99e Initial load
duke
parents:
diff changeset
66
a61af66fc99e Initial load
duke
parents:
diff changeset
67 static void clear_needs_gc() {
a61af66fc99e Initial load
duke
parents:
diff changeset
68 assert_lock_strong(JNICritical_lock);
a61af66fc99e Initial load
duke
parents:
diff changeset
69 _needs_gc = false;
a61af66fc99e Initial load
duke
parents:
diff changeset
70 }
a61af66fc99e Initial load
duke
parents:
diff changeset
71
a61af66fc99e Initial load
duke
parents:
diff changeset
72 static void jni_lock() {
a61af66fc99e Initial load
duke
parents:
diff changeset
73 Atomic::inc(&_jni_lock_count);
a61af66fc99e Initial load
duke
parents:
diff changeset
74 CHECK_UNHANDLED_OOPS_ONLY(
a61af66fc99e Initial load
duke
parents:
diff changeset
75 if (CheckUnhandledOops) { Thread::current()->_gc_locked_out_count++; })
a61af66fc99e Initial load
duke
parents:
diff changeset
76 assert(Universe::heap() == NULL || !Universe::heap()->is_gc_active(),
a61af66fc99e Initial load
duke
parents:
diff changeset
77 "locking failed");
a61af66fc99e Initial load
duke
parents:
diff changeset
78 }
a61af66fc99e Initial load
duke
parents:
diff changeset
79
a61af66fc99e Initial load
duke
parents:
diff changeset
80 static void jni_unlock() {
a61af66fc99e Initial load
duke
parents:
diff changeset
81 Atomic::dec(&_jni_lock_count);
a61af66fc99e Initial load
duke
parents:
diff changeset
82 CHECK_UNHANDLED_OOPS_ONLY(
a61af66fc99e Initial load
duke
parents:
diff changeset
83 if (CheckUnhandledOops) { Thread::current()->_gc_locked_out_count--; })
a61af66fc99e Initial load
duke
parents:
diff changeset
84 }
a61af66fc99e Initial load
duke
parents:
diff changeset
85
a61af66fc99e Initial load
duke
parents:
diff changeset
86 static void jni_lock_slow();
a61af66fc99e Initial load
duke
parents:
diff changeset
87 static void jni_unlock_slow();
a61af66fc99e Initial load
duke
parents:
diff changeset
88
a61af66fc99e Initial load
duke
parents:
diff changeset
89 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
90 // Accessors
a61af66fc99e Initial load
duke
parents:
diff changeset
91 static bool is_active();
a61af66fc99e Initial load
duke
parents:
diff changeset
92 static bool needs_gc() { return _needs_gc; }
a61af66fc99e Initial load
duke
parents:
diff changeset
93 // Shorthand
a61af66fc99e Initial load
duke
parents:
diff changeset
94 static bool is_active_and_needs_gc() { return is_active() && needs_gc();}
a61af66fc99e Initial load
duke
parents:
diff changeset
95
a61af66fc99e Initial load
duke
parents:
diff changeset
96 // Calls set_needs_gc() if is_active() is true. Returns is_active().
a61af66fc99e Initial load
duke
parents:
diff changeset
97 static bool check_active_before_gc();
a61af66fc99e Initial load
duke
parents:
diff changeset
98
a61af66fc99e Initial load
duke
parents:
diff changeset
99 // Stalls the caller (who should not be in a jni critical section)
a61af66fc99e Initial load
duke
parents:
diff changeset
100 // until needs_gc() clears. Note however that needs_gc() may be
a61af66fc99e Initial load
duke
parents:
diff changeset
101 // set at a subsequent safepoint and/or cleared under the
a61af66fc99e Initial load
duke
parents:
diff changeset
102 // JNICritical_lock, so the caller may not safely assert upon
a61af66fc99e Initial load
duke
parents:
diff changeset
103 // return from this method that "!needs_gc()" since that is
a61af66fc99e Initial load
duke
parents:
diff changeset
104 // not a stable predicate.
a61af66fc99e Initial load
duke
parents:
diff changeset
105 static void stall_until_clear();
a61af66fc99e Initial load
duke
parents:
diff changeset
106
a61af66fc99e Initial load
duke
parents:
diff changeset
107 // Non-structured GC locking: currently needed for JNI. Use with care!
a61af66fc99e Initial load
duke
parents:
diff changeset
108 static void lock();
a61af66fc99e Initial load
duke
parents:
diff changeset
109 static void unlock();
a61af66fc99e Initial load
duke
parents:
diff changeset
110
a61af66fc99e Initial load
duke
parents:
diff changeset
111 // The following two methods are used for JNI critical regions.
a61af66fc99e Initial load
duke
parents:
diff changeset
112 // If we find that we failed to perform a GC because the GC_locker
a61af66fc99e Initial load
duke
parents:
diff changeset
113 // was active, arrange for one as soon as possible by allowing
a61af66fc99e Initial load
duke
parents:
diff changeset
114 // all threads in critical regions to complete, but not allowing
a61af66fc99e Initial load
duke
parents:
diff changeset
115 // other critical regions to be entered. The reasons for that are:
a61af66fc99e Initial load
duke
parents:
diff changeset
116 // 1) a GC request won't be starved by overlapping JNI critical
a61af66fc99e Initial load
duke
parents:
diff changeset
117 // region activities, which can cause unnecessary OutOfMemory errors.
a61af66fc99e Initial load
duke
parents:
diff changeset
118 // 2) even if allocation requests can still be satisfied before GC locker
a61af66fc99e Initial load
duke
parents:
diff changeset
119 // becomes inactive, for example, in tenured generation possibly with
a61af66fc99e Initial load
duke
parents:
diff changeset
120 // heap expansion, those allocations can trigger lots of safepointing
a61af66fc99e Initial load
duke
parents:
diff changeset
121 // attempts (ineffective GC attempts) and require Heap_lock which
a61af66fc99e Initial load
duke
parents:
diff changeset
122 // slow down allocations tremendously.
a61af66fc99e Initial load
duke
parents:
diff changeset
123 //
a61af66fc99e Initial load
duke
parents:
diff changeset
124 // Note that critical regions can be nested in a single thread, so
a61af66fc99e Initial load
duke
parents:
diff changeset
125 // we must allow threads already in critical regions to continue.
a61af66fc99e Initial load
duke
parents:
diff changeset
126 //
a61af66fc99e Initial load
duke
parents:
diff changeset
127 // JNI critical regions are the only participants in this scheme
a61af66fc99e Initial load
duke
parents:
diff changeset
128 // because they are, by spec, well bounded while in a critical region.
a61af66fc99e Initial load
duke
parents:
diff changeset
129 //
a61af66fc99e Initial load
duke
parents:
diff changeset
130 // Each of the following two method is split into a fast path and a slow
a61af66fc99e Initial load
duke
parents:
diff changeset
131 // path. JNICritical_lock is only grabbed in the slow path.
a61af66fc99e Initial load
duke
parents:
diff changeset
132 // _needs_gc is initially false and every java thread will go
a61af66fc99e Initial load
duke
parents:
diff changeset
133 // through the fast path (which does the same thing as the slow path
a61af66fc99e Initial load
duke
parents:
diff changeset
134 // when _needs_gc is false). When GC happens at a safepoint,
a61af66fc99e Initial load
duke
parents:
diff changeset
135 // GC_locker::is_active() is checked. Since there is no safepoint in the
a61af66fc99e Initial load
duke
parents:
diff changeset
136 // fast path of lock_critical() and unlock_critical(), there is no race
a61af66fc99e Initial load
duke
parents:
diff changeset
137 // condition between the fast path and GC. After _needs_gc is set at a
a61af66fc99e Initial load
duke
parents:
diff changeset
138 // safepoint, every thread will go through the slow path after the safepoint.
a61af66fc99e Initial load
duke
parents:
diff changeset
139 // Since after a safepoint, each of the following two methods is either
a61af66fc99e Initial load
duke
parents:
diff changeset
140 // entered from the method entry and falls into the slow path, or is
a61af66fc99e Initial load
duke
parents:
diff changeset
141 // resumed from the safepoints in the method, which only exist in the slow
a61af66fc99e Initial load
duke
parents:
diff changeset
142 // path. So when _needs_gc is set, the slow path is always taken, till
a61af66fc99e Initial load
duke
parents:
diff changeset
143 // _needs_gc is cleared.
a61af66fc99e Initial load
duke
parents:
diff changeset
144 static void lock_critical(JavaThread* thread);
a61af66fc99e Initial load
duke
parents:
diff changeset
145 static void unlock_critical(JavaThread* thread);
a61af66fc99e Initial load
duke
parents:
diff changeset
146 };
a61af66fc99e Initial load
duke
parents:
diff changeset
147
a61af66fc99e Initial load
duke
parents:
diff changeset
148
a61af66fc99e Initial load
duke
parents:
diff changeset
149 // A No_GC_Verifier object can be placed in methods where one assumes that
a61af66fc99e Initial load
duke
parents:
diff changeset
150 // no garbage collection will occur. The destructor will verify this property
a61af66fc99e Initial load
duke
parents:
diff changeset
151 // unless the constructor is called with argument false (not verifygc).
a61af66fc99e Initial load
duke
parents:
diff changeset
152 //
a61af66fc99e Initial load
duke
parents:
diff changeset
153 // The check will only be done in debug mode and if verifygc true.
a61af66fc99e Initial load
duke
parents:
diff changeset
154
a61af66fc99e Initial load
duke
parents:
diff changeset
155 class No_GC_Verifier: public StackObj {
a61af66fc99e Initial load
duke
parents:
diff changeset
156 friend class Pause_No_GC_Verifier;
a61af66fc99e Initial load
duke
parents:
diff changeset
157
a61af66fc99e Initial load
duke
parents:
diff changeset
158 protected:
a61af66fc99e Initial load
duke
parents:
diff changeset
159 bool _verifygc;
a61af66fc99e Initial load
duke
parents:
diff changeset
160 unsigned int _old_invocations;
a61af66fc99e Initial load
duke
parents:
diff changeset
161
a61af66fc99e Initial load
duke
parents:
diff changeset
162 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
163 #ifdef ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
164 No_GC_Verifier(bool verifygc = true);
a61af66fc99e Initial load
duke
parents:
diff changeset
165 ~No_GC_Verifier();
a61af66fc99e Initial load
duke
parents:
diff changeset
166 #else
a61af66fc99e Initial load
duke
parents:
diff changeset
167 No_GC_Verifier(bool verifygc = true) {}
a61af66fc99e Initial load
duke
parents:
diff changeset
168 ~No_GC_Verifier() {}
a61af66fc99e Initial load
duke
parents:
diff changeset
169 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
170 };
a61af66fc99e Initial load
duke
parents:
diff changeset
171
a61af66fc99e Initial load
duke
parents:
diff changeset
172 // A Pause_No_GC_Verifier is used to temporarily pause the behavior
a61af66fc99e Initial load
duke
parents:
diff changeset
173 // of a No_GC_Verifier object. If we are not in debug mode or if the
a61af66fc99e Initial load
duke
parents:
diff changeset
174 // No_GC_Verifier object has a _verifygc value of false, then there
a61af66fc99e Initial load
duke
parents:
diff changeset
175 // is nothing to do.
a61af66fc99e Initial load
duke
parents:
diff changeset
176
a61af66fc99e Initial load
duke
parents:
diff changeset
177 class Pause_No_GC_Verifier: public StackObj {
a61af66fc99e Initial load
duke
parents:
diff changeset
178 private:
a61af66fc99e Initial load
duke
parents:
diff changeset
179 No_GC_Verifier * _ngcv;
a61af66fc99e Initial load
duke
parents:
diff changeset
180
a61af66fc99e Initial load
duke
parents:
diff changeset
181 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
182 #ifdef ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
183 Pause_No_GC_Verifier(No_GC_Verifier * ngcv);
a61af66fc99e Initial load
duke
parents:
diff changeset
184 ~Pause_No_GC_Verifier();
a61af66fc99e Initial load
duke
parents:
diff changeset
185 #else
a61af66fc99e Initial load
duke
parents:
diff changeset
186 Pause_No_GC_Verifier(No_GC_Verifier * ngcv) {}
a61af66fc99e Initial load
duke
parents:
diff changeset
187 ~Pause_No_GC_Verifier() {}
a61af66fc99e Initial load
duke
parents:
diff changeset
188 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
189 };
a61af66fc99e Initial load
duke
parents:
diff changeset
190
a61af66fc99e Initial load
duke
parents:
diff changeset
191
a61af66fc99e Initial load
duke
parents:
diff changeset
192 // A No_Safepoint_Verifier object will throw an assertion failure if
a61af66fc99e Initial load
duke
parents:
diff changeset
193 // the current thread passes a possible safepoint while this object is
a61af66fc99e Initial load
duke
parents:
diff changeset
194 // instantiated. A safepoint, will either be: an oop allocation, blocking
a61af66fc99e Initial load
duke
parents:
diff changeset
195 // on a Mutex or JavaLock, or executing a VM operation.
a61af66fc99e Initial load
duke
parents:
diff changeset
196 //
a61af66fc99e Initial load
duke
parents:
diff changeset
197 // If StrictSafepointChecks is turned off, it degrades into a No_GC_Verifier
a61af66fc99e Initial load
duke
parents:
diff changeset
198 //
a61af66fc99e Initial load
duke
parents:
diff changeset
199 class No_Safepoint_Verifier : public No_GC_Verifier {
a61af66fc99e Initial load
duke
parents:
diff changeset
200 friend class Pause_No_Safepoint_Verifier;
a61af66fc99e Initial load
duke
parents:
diff changeset
201
a61af66fc99e Initial load
duke
parents:
diff changeset
202 private:
a61af66fc99e Initial load
duke
parents:
diff changeset
203 bool _activated;
a61af66fc99e Initial load
duke
parents:
diff changeset
204 Thread *_thread;
a61af66fc99e Initial load
duke
parents:
diff changeset
205 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
206 #ifdef ASSERT
98
deb97b8ef02b 6679708: No_Safepoint_Verifier and BacktraceBuilder have uninitialized fields
never
parents: 0
diff changeset
207 No_Safepoint_Verifier(bool activated = true, bool verifygc = true ) :
deb97b8ef02b 6679708: No_Safepoint_Verifier and BacktraceBuilder have uninitialized fields
never
parents: 0
diff changeset
208 No_GC_Verifier(verifygc),
deb97b8ef02b 6679708: No_Safepoint_Verifier and BacktraceBuilder have uninitialized fields
never
parents: 0
diff changeset
209 _activated(activated) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
210 _thread = Thread::current();
a61af66fc99e Initial load
duke
parents:
diff changeset
211 if (_activated) {
a61af66fc99e Initial load
duke
parents:
diff changeset
212 _thread->_allow_allocation_count++;
a61af66fc99e Initial load
duke
parents:
diff changeset
213 _thread->_allow_safepoint_count++;
a61af66fc99e Initial load
duke
parents:
diff changeset
214 }
a61af66fc99e Initial load
duke
parents:
diff changeset
215 }
a61af66fc99e Initial load
duke
parents:
diff changeset
216
a61af66fc99e Initial load
duke
parents:
diff changeset
217 ~No_Safepoint_Verifier() {
a61af66fc99e Initial load
duke
parents:
diff changeset
218 if (_activated) {
a61af66fc99e Initial load
duke
parents:
diff changeset
219 _thread->_allow_allocation_count--;
a61af66fc99e Initial load
duke
parents:
diff changeset
220 _thread->_allow_safepoint_count--;
a61af66fc99e Initial load
duke
parents:
diff changeset
221 }
a61af66fc99e Initial load
duke
parents:
diff changeset
222 }
a61af66fc99e Initial load
duke
parents:
diff changeset
223 #else
a61af66fc99e Initial load
duke
parents:
diff changeset
224 No_Safepoint_Verifier(bool activated = true, bool verifygc = true) : No_GC_Verifier(verifygc){}
a61af66fc99e Initial load
duke
parents:
diff changeset
225 ~No_Safepoint_Verifier() {}
a61af66fc99e Initial load
duke
parents:
diff changeset
226 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
227 };
a61af66fc99e Initial load
duke
parents:
diff changeset
228
a61af66fc99e Initial load
duke
parents:
diff changeset
229 // A Pause_No_Safepoint_Verifier is used to temporarily pause the
a61af66fc99e Initial load
duke
parents:
diff changeset
230 // behavior of a No_Safepoint_Verifier object. If we are not in debug
a61af66fc99e Initial load
duke
parents:
diff changeset
231 // mode then there is nothing to do. If the No_Safepoint_Verifier
a61af66fc99e Initial load
duke
parents:
diff changeset
232 // object has an _activated value of false, then there is nothing to
a61af66fc99e Initial load
duke
parents:
diff changeset
233 // do for safepoint and allocation checking, but there may still be
a61af66fc99e Initial load
duke
parents:
diff changeset
234 // something to do for the underlying No_GC_Verifier object.
a61af66fc99e Initial load
duke
parents:
diff changeset
235
a61af66fc99e Initial load
duke
parents:
diff changeset
236 class Pause_No_Safepoint_Verifier : public Pause_No_GC_Verifier {
a61af66fc99e Initial load
duke
parents:
diff changeset
237 private:
a61af66fc99e Initial load
duke
parents:
diff changeset
238 No_Safepoint_Verifier * _nsv;
a61af66fc99e Initial load
duke
parents:
diff changeset
239
a61af66fc99e Initial load
duke
parents:
diff changeset
240 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
241 #ifdef ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
242 Pause_No_Safepoint_Verifier(No_Safepoint_Verifier * nsv)
a61af66fc99e Initial load
duke
parents:
diff changeset
243 : Pause_No_GC_Verifier(nsv) {
a61af66fc99e Initial load
duke
parents:
diff changeset
244
a61af66fc99e Initial load
duke
parents:
diff changeset
245 _nsv = nsv;
a61af66fc99e Initial load
duke
parents:
diff changeset
246 if (_nsv->_activated) {
a61af66fc99e Initial load
duke
parents:
diff changeset
247 _nsv->_thread->_allow_allocation_count--;
a61af66fc99e Initial load
duke
parents:
diff changeset
248 _nsv->_thread->_allow_safepoint_count--;
a61af66fc99e Initial load
duke
parents:
diff changeset
249 }
a61af66fc99e Initial load
duke
parents:
diff changeset
250 }
a61af66fc99e Initial load
duke
parents:
diff changeset
251
a61af66fc99e Initial load
duke
parents:
diff changeset
252 ~Pause_No_Safepoint_Verifier() {
a61af66fc99e Initial load
duke
parents:
diff changeset
253 if (_nsv->_activated) {
a61af66fc99e Initial load
duke
parents:
diff changeset
254 _nsv->_thread->_allow_allocation_count++;
a61af66fc99e Initial load
duke
parents:
diff changeset
255 _nsv->_thread->_allow_safepoint_count++;
a61af66fc99e Initial load
duke
parents:
diff changeset
256 }
a61af66fc99e Initial load
duke
parents:
diff changeset
257 }
a61af66fc99e Initial load
duke
parents:
diff changeset
258 #else
a61af66fc99e Initial load
duke
parents:
diff changeset
259 Pause_No_Safepoint_Verifier(No_Safepoint_Verifier * nsv)
a61af66fc99e Initial load
duke
parents:
diff changeset
260 : Pause_No_GC_Verifier(nsv) {}
a61af66fc99e Initial load
duke
parents:
diff changeset
261 ~Pause_No_Safepoint_Verifier() {}
a61af66fc99e Initial load
duke
parents:
diff changeset
262 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
263 };
a61af66fc99e Initial load
duke
parents:
diff changeset
264
806
821269eca479 6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents: 196
diff changeset
265 // A SkipGCALot object is used to elide the usual effect of gc-a-lot
821269eca479 6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents: 196
diff changeset
266 // over a section of execution by a thread. Currently, it's used only to
821269eca479 6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents: 196
diff changeset
267 // prevent re-entrant calls to GC.
821269eca479 6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents: 196
diff changeset
268 class SkipGCALot : public StackObj {
821269eca479 6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents: 196
diff changeset
269 private:
821269eca479 6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents: 196
diff changeset
270 bool _saved;
821269eca479 6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents: 196
diff changeset
271 Thread* _t;
821269eca479 6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents: 196
diff changeset
272
821269eca479 6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents: 196
diff changeset
273 public:
821269eca479 6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents: 196
diff changeset
274 #ifdef ASSERT
821269eca479 6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents: 196
diff changeset
275 SkipGCALot(Thread* t) : _t(t) {
821269eca479 6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents: 196
diff changeset
276 _saved = _t->skip_gcalot();
821269eca479 6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents: 196
diff changeset
277 _t->set_skip_gcalot(true);
821269eca479 6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents: 196
diff changeset
278 }
821269eca479 6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents: 196
diff changeset
279
821269eca479 6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents: 196
diff changeset
280 ~SkipGCALot() {
821269eca479 6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents: 196
diff changeset
281 assert(_t->skip_gcalot(), "Save-restore protocol invariant");
821269eca479 6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents: 196
diff changeset
282 _t->set_skip_gcalot(_saved);
821269eca479 6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents: 196
diff changeset
283 }
821269eca479 6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents: 196
diff changeset
284 #else
821269eca479 6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents: 196
diff changeset
285 SkipGCALot(Thread* t) { }
821269eca479 6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents: 196
diff changeset
286 ~SkipGCALot() { }
821269eca479 6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents: 196
diff changeset
287 #endif
821269eca479 6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents: 196
diff changeset
288 };
821269eca479 6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents: 196
diff changeset
289
0
a61af66fc99e Initial load
duke
parents:
diff changeset
290 // JRT_LEAF currently can be called from either _thread_in_Java or
a61af66fc99e Initial load
duke
parents:
diff changeset
291 // _thread_in_native mode. In _thread_in_native, it is ok
a61af66fc99e Initial load
duke
parents:
diff changeset
292 // for another thread to trigger GC. The rest of the JRT_LEAF
a61af66fc99e Initial load
duke
parents:
diff changeset
293 // rules apply.
a61af66fc99e Initial load
duke
parents:
diff changeset
294 class JRT_Leaf_Verifier : public No_Safepoint_Verifier {
a61af66fc99e Initial load
duke
parents:
diff changeset
295 static bool should_verify_GC();
a61af66fc99e Initial load
duke
parents:
diff changeset
296 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
297 #ifdef ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
298 JRT_Leaf_Verifier();
a61af66fc99e Initial load
duke
parents:
diff changeset
299 ~JRT_Leaf_Verifier();
a61af66fc99e Initial load
duke
parents:
diff changeset
300 #else
a61af66fc99e Initial load
duke
parents:
diff changeset
301 JRT_Leaf_Verifier() {}
a61af66fc99e Initial load
duke
parents:
diff changeset
302 ~JRT_Leaf_Verifier() {}
a61af66fc99e Initial load
duke
parents:
diff changeset
303 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
304 };
a61af66fc99e Initial load
duke
parents:
diff changeset
305
a61af66fc99e Initial load
duke
parents:
diff changeset
306 // A No_Alloc_Verifier object can be placed in methods where one assumes that
a61af66fc99e Initial load
duke
parents:
diff changeset
307 // no allocation will occur. The destructor will verify this property
a61af66fc99e Initial load
duke
parents:
diff changeset
308 // unless the constructor is called with argument false (not activated).
a61af66fc99e Initial load
duke
parents:
diff changeset
309 //
a61af66fc99e Initial load
duke
parents:
diff changeset
310 // The check will only be done in debug mode and if activated.
a61af66fc99e Initial load
duke
parents:
diff changeset
311 // Note: this only makes sense at safepoints (otherwise, other threads may
a61af66fc99e Initial load
duke
parents:
diff changeset
312 // allocate concurrently.)
a61af66fc99e Initial load
duke
parents:
diff changeset
313
a61af66fc99e Initial load
duke
parents:
diff changeset
314 class No_Alloc_Verifier : public StackObj {
a61af66fc99e Initial load
duke
parents:
diff changeset
315 private:
a61af66fc99e Initial load
duke
parents:
diff changeset
316 bool _activated;
a61af66fc99e Initial load
duke
parents:
diff changeset
317
a61af66fc99e Initial load
duke
parents:
diff changeset
318 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
319 #ifdef ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
320 No_Alloc_Verifier(bool activated = true) {
a61af66fc99e Initial load
duke
parents:
diff changeset
321 _activated = activated;
a61af66fc99e Initial load
duke
parents:
diff changeset
322 if (_activated) Thread::current()->_allow_allocation_count++;
a61af66fc99e Initial load
duke
parents:
diff changeset
323 }
a61af66fc99e Initial load
duke
parents:
diff changeset
324
a61af66fc99e Initial load
duke
parents:
diff changeset
325 ~No_Alloc_Verifier() {
a61af66fc99e Initial load
duke
parents:
diff changeset
326 if (_activated) Thread::current()->_allow_allocation_count--;
a61af66fc99e Initial load
duke
parents:
diff changeset
327 }
a61af66fc99e Initial load
duke
parents:
diff changeset
328 #else
a61af66fc99e Initial load
duke
parents:
diff changeset
329 No_Alloc_Verifier(bool activated = true) {}
a61af66fc99e Initial load
duke
parents:
diff changeset
330 ~No_Alloc_Verifier() {}
a61af66fc99e Initial load
duke
parents:
diff changeset
331 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
332 };
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
333
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
334 #endif // SHARE_VM_MEMORY_GCLOCKER_HPP