Mercurial > hg > truffle
annotate src/share/vm/memory/gcLocker.hpp @ 20543:e7d0505c8a30
8059758: Footprint regressions with JDK-8038423
Summary: Changes in JDK-8038423 always initialize (zero out) virtual memory used for auxiliary data structures. This causes a footprint regression for G1 in startup benchmarks. This is because they do not touch that memory at all, so the operating system does not actually commit these pages. The fix is to, if the initialization value of the data structures matches the default value of just committed memory (=0), do not do anything.
Reviewed-by: jwilhelm, brutisso
| author | tschatzl |
|---|---|
| date | Fri, 10 Oct 2014 15:51:58 +0200 |
| parents | 9c3dc501b5eb |
| children | 52b4284cb496 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
17467
55fb97c4c58d
8029233: Update copyright year to match last edit in jdk8 hotspot repository for 2013
mikael
parents:
12301
diff
changeset
|
2 * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved. |
| 0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 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 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_MEMORY_GCLOCKER_HPP |
| 26 #define SHARE_VM_MEMORY_GCLOCKER_HPP | |
| 27 | |
| 28 #include "gc_interface/collectedHeap.hpp" | |
| 29 #include "memory/genCollectedHeap.hpp" | |
| 30 #include "memory/universe.hpp" | |
| 31 #include "oops/oop.hpp" | |
|
7180
f34d701e952e
8003935: Simplify the needed includes for using Thread::current()
stefank
parents:
4949
diff
changeset
|
32 #include "runtime/thread.inline.hpp" |
| 1972 | 33 #ifdef TARGET_OS_FAMILY_linux |
| 34 # include "os_linux.inline.hpp" | |
| 35 #endif | |
| 36 #ifdef TARGET_OS_FAMILY_solaris | |
| 37 # include "os_solaris.inline.hpp" | |
| 38 #endif | |
| 39 #ifdef TARGET_OS_FAMILY_windows | |
| 40 # include "os_windows.inline.hpp" | |
| 41 #endif | |
| 3960 | 42 #ifdef TARGET_OS_FAMILY_bsd |
| 43 # include "os_bsd.inline.hpp" | |
| 44 #endif | |
| 1972 | 45 |
| 0 | 46 // The direct lock/unlock calls do not force a collection if an unlock |
| 47 // decrements the count to zero. Avoid calling these if at all possible. | |
| 48 | |
| 49 class GC_locker: public AllStatic { | |
| 50 private: | |
|
4867
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
51 // The _jni_lock_count keeps track of the number of threads that are |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
52 // currently in a critical region. It's only kept up to date when |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
53 // _needs_gc is true. The current value is computed during |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
54 // safepointing and decremented during the slow path of GC_locker |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
55 // unlocking. |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
56 static volatile jint _jni_lock_count; // number of jni active instances. |
| 0 | 57 static volatile bool _needs_gc; // heap is filling, we need a GC |
| 58 // note: bool is typedef'd as jint | |
| 59 static volatile bool _doing_gc; // unlock_critical() is doing a GC | |
| 60 | |
|
4867
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
61 #ifdef ASSERT |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
62 // This lock count is updated for all operations and is used to |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
63 // validate the jni_lock_count that is computed during safepoints. |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
64 static volatile jint _debug_jni_lock_count; |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
65 #endif |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
66 |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
67 // At a safepoint, visit all threads and count the number of active |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
68 // critical sections. This is used to ensure that all active |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
69 // critical sections are exited before a new one is started. |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
70 static void verify_critical_count() NOT_DEBUG_RETURN; |
| 0 | 71 |
|
4867
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
72 static void jni_lock(JavaThread* thread); |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
73 static void jni_unlock(JavaThread* thread); |
| 0 | 74 |
|
4949
ad3b47344802
7144318: GCLocker assert failure: assert(_needs_gc || SafepointSynchronize::is_at_safepoint(
never
parents:
4944
diff
changeset
|
75 static bool is_active_internal() { |
|
ad3b47344802
7144318: GCLocker assert failure: assert(_needs_gc || SafepointSynchronize::is_at_safepoint(
never
parents:
4944
diff
changeset
|
76 verify_critical_count(); |
|
17876
9c3dc501b5eb
8028498: runtime/SharedArchiveFile/CdsDifferentObjectAlignment.java asserts in RT_Baseline
sjohanss
parents:
17467
diff
changeset
|
77 return _jni_lock_count > 0; |
|
4949
ad3b47344802
7144318: GCLocker assert failure: assert(_needs_gc || SafepointSynchronize::is_at_safepoint(
never
parents:
4944
diff
changeset
|
78 } |
|
ad3b47344802
7144318: GCLocker assert failure: assert(_needs_gc || SafepointSynchronize::is_at_safepoint(
never
parents:
4944
diff
changeset
|
79 |
| 0 | 80 public: |
| 81 // Accessors | |
|
4949
ad3b47344802
7144318: GCLocker assert failure: assert(_needs_gc || SafepointSynchronize::is_at_safepoint(
never
parents:
4944
diff
changeset
|
82 static bool is_active() { |
| 12301 | 83 assert(SafepointSynchronize::is_at_safepoint(), "only read at safepoint"); |
|
4949
ad3b47344802
7144318: GCLocker assert failure: assert(_needs_gc || SafepointSynchronize::is_at_safepoint(
never
parents:
4944
diff
changeset
|
84 return is_active_internal(); |
|
ad3b47344802
7144318: GCLocker assert failure: assert(_needs_gc || SafepointSynchronize::is_at_safepoint(
never
parents:
4944
diff
changeset
|
85 } |
| 0 | 86 static bool needs_gc() { return _needs_gc; } |
|
4867
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
87 |
| 0 | 88 // Shorthand |
|
4949
ad3b47344802
7144318: GCLocker assert failure: assert(_needs_gc || SafepointSynchronize::is_at_safepoint(
never
parents:
4944
diff
changeset
|
89 static bool is_active_and_needs_gc() { |
|
ad3b47344802
7144318: GCLocker assert failure: assert(_needs_gc || SafepointSynchronize::is_at_safepoint(
never
parents:
4944
diff
changeset
|
90 // Use is_active_internal since _needs_gc can change from true to |
|
ad3b47344802
7144318: GCLocker assert failure: assert(_needs_gc || SafepointSynchronize::is_at_safepoint(
never
parents:
4944
diff
changeset
|
91 // false outside of a safepoint, triggering the assert in |
|
ad3b47344802
7144318: GCLocker assert failure: assert(_needs_gc || SafepointSynchronize::is_at_safepoint(
never
parents:
4944
diff
changeset
|
92 // is_active. |
|
ad3b47344802
7144318: GCLocker assert failure: assert(_needs_gc || SafepointSynchronize::is_at_safepoint(
never
parents:
4944
diff
changeset
|
93 return needs_gc() && is_active_internal(); |
|
ad3b47344802
7144318: GCLocker assert failure: assert(_needs_gc || SafepointSynchronize::is_at_safepoint(
never
parents:
4944
diff
changeset
|
94 } |
| 0 | 95 |
|
4867
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
96 // In debug mode track the locking state at all times |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
97 static void increment_debug_jni_lock_count() { |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
98 #ifdef ASSERT |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
99 assert(_debug_jni_lock_count >= 0, "bad value"); |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
100 Atomic::inc(&_debug_jni_lock_count); |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
101 #endif |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
102 } |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
103 static void decrement_debug_jni_lock_count() { |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
104 #ifdef ASSERT |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
105 assert(_debug_jni_lock_count > 0, "bad value"); |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
106 Atomic::dec(&_debug_jni_lock_count); |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
107 #endif |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
108 } |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
109 |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
110 // Set the current lock count |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
111 static void set_jni_lock_count(int count) { |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
112 _jni_lock_count = count; |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
113 verify_critical_count(); |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
114 } |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
115 |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
116 // Sets _needs_gc if is_active() is true. Returns is_active(). |
| 0 | 117 static bool check_active_before_gc(); |
| 118 | |
| 119 // Stalls the caller (who should not be in a jni critical section) | |
| 120 // until needs_gc() clears. Note however that needs_gc() may be | |
| 121 // set at a subsequent safepoint and/or cleared under the | |
| 122 // JNICritical_lock, so the caller may not safely assert upon | |
| 123 // return from this method that "!needs_gc()" since that is | |
| 124 // not a stable predicate. | |
| 125 static void stall_until_clear(); | |
| 126 | |
| 127 // The following two methods are used for JNI critical regions. | |
| 128 // If we find that we failed to perform a GC because the GC_locker | |
| 129 // was active, arrange for one as soon as possible by allowing | |
| 130 // all threads in critical regions to complete, but not allowing | |
| 131 // other critical regions to be entered. The reasons for that are: | |
| 132 // 1) a GC request won't be starved by overlapping JNI critical | |
| 133 // region activities, which can cause unnecessary OutOfMemory errors. | |
| 134 // 2) even if allocation requests can still be satisfied before GC locker | |
| 135 // becomes inactive, for example, in tenured generation possibly with | |
| 136 // heap expansion, those allocations can trigger lots of safepointing | |
| 137 // attempts (ineffective GC attempts) and require Heap_lock which | |
| 138 // slow down allocations tremendously. | |
| 139 // | |
| 140 // Note that critical regions can be nested in a single thread, so | |
| 141 // we must allow threads already in critical regions to continue. | |
| 142 // | |
| 143 // JNI critical regions are the only participants in this scheme | |
| 144 // because they are, by spec, well bounded while in a critical region. | |
| 145 // | |
|
4867
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
146 // Each of the following two method is split into a fast path and a |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
147 // slow path. JNICritical_lock is only grabbed in the slow path. |
| 0 | 148 // _needs_gc is initially false and every java thread will go |
|
4867
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
149 // through the fast path, which simply increments or decrements the |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
150 // current thread's critical count. When GC happens at a safepoint, |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
151 // GC_locker::is_active() is checked. Since there is no safepoint in |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
152 // the fast path of lock_critical() and unlock_critical(), there is |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
153 // no race condition between the fast path and GC. After _needs_gc |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
154 // is set at a safepoint, every thread will go through the slow path |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
155 // after the safepoint. Since after a safepoint, each of the |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
156 // following two methods is either entered from the method entry and |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
157 // falls into the slow path, or is resumed from the safepoints in |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
158 // the method, which only exist in the slow path. So when _needs_gc |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
159 // is set, the slow path is always taken, till _needs_gc is cleared. |
| 0 | 160 static void lock_critical(JavaThread* thread); |
| 161 static void unlock_critical(JavaThread* thread); | |
|
4873
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
4867
diff
changeset
|
162 |
|
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
4867
diff
changeset
|
163 static address needs_gc_address() { return (address) &_needs_gc; } |
| 0 | 164 }; |
| 165 | |
| 166 | |
| 167 // A No_GC_Verifier object can be placed in methods where one assumes that | |
| 168 // no garbage collection will occur. The destructor will verify this property | |
| 169 // unless the constructor is called with argument false (not verifygc). | |
| 170 // | |
| 171 // The check will only be done in debug mode and if verifygc true. | |
| 172 | |
| 173 class No_GC_Verifier: public StackObj { | |
| 174 friend class Pause_No_GC_Verifier; | |
| 175 | |
| 176 protected: | |
| 177 bool _verifygc; | |
| 178 unsigned int _old_invocations; | |
| 179 | |
| 180 public: | |
| 181 #ifdef ASSERT | |
| 182 No_GC_Verifier(bool verifygc = true); | |
| 183 ~No_GC_Verifier(); | |
| 184 #else | |
| 185 No_GC_Verifier(bool verifygc = true) {} | |
| 186 ~No_GC_Verifier() {} | |
| 187 #endif | |
| 188 }; | |
| 189 | |
| 190 // A Pause_No_GC_Verifier is used to temporarily pause the behavior | |
| 191 // of a No_GC_Verifier object. If we are not in debug mode or if the | |
| 192 // No_GC_Verifier object has a _verifygc value of false, then there | |
| 193 // is nothing to do. | |
| 194 | |
| 195 class Pause_No_GC_Verifier: public StackObj { | |
| 196 private: | |
| 197 No_GC_Verifier * _ngcv; | |
| 198 | |
| 199 public: | |
| 200 #ifdef ASSERT | |
| 201 Pause_No_GC_Verifier(No_GC_Verifier * ngcv); | |
| 202 ~Pause_No_GC_Verifier(); | |
| 203 #else | |
| 204 Pause_No_GC_Verifier(No_GC_Verifier * ngcv) {} | |
| 205 ~Pause_No_GC_Verifier() {} | |
| 206 #endif | |
| 207 }; | |
| 208 | |
| 209 | |
| 210 // A No_Safepoint_Verifier object will throw an assertion failure if | |
| 211 // the current thread passes a possible safepoint while this object is | |
| 212 // instantiated. A safepoint, will either be: an oop allocation, blocking | |
| 213 // on a Mutex or JavaLock, or executing a VM operation. | |
| 214 // | |
| 215 // If StrictSafepointChecks is turned off, it degrades into a No_GC_Verifier | |
| 216 // | |
| 217 class No_Safepoint_Verifier : public No_GC_Verifier { | |
| 218 friend class Pause_No_Safepoint_Verifier; | |
| 219 | |
| 220 private: | |
| 221 bool _activated; | |
| 222 Thread *_thread; | |
| 223 public: | |
| 224 #ifdef ASSERT | |
|
98
deb97b8ef02b
6679708: No_Safepoint_Verifier and BacktraceBuilder have uninitialized fields
never
parents:
0
diff
changeset
|
225 No_Safepoint_Verifier(bool activated = true, bool verifygc = true ) : |
|
deb97b8ef02b
6679708: No_Safepoint_Verifier and BacktraceBuilder have uninitialized fields
never
parents:
0
diff
changeset
|
226 No_GC_Verifier(verifygc), |
|
deb97b8ef02b
6679708: No_Safepoint_Verifier and BacktraceBuilder have uninitialized fields
never
parents:
0
diff
changeset
|
227 _activated(activated) { |
| 0 | 228 _thread = Thread::current(); |
| 229 if (_activated) { | |
| 230 _thread->_allow_allocation_count++; | |
| 231 _thread->_allow_safepoint_count++; | |
| 232 } | |
| 233 } | |
| 234 | |
| 235 ~No_Safepoint_Verifier() { | |
| 236 if (_activated) { | |
| 237 _thread->_allow_allocation_count--; | |
| 238 _thread->_allow_safepoint_count--; | |
| 239 } | |
| 240 } | |
| 241 #else | |
| 242 No_Safepoint_Verifier(bool activated = true, bool verifygc = true) : No_GC_Verifier(verifygc){} | |
| 243 ~No_Safepoint_Verifier() {} | |
| 244 #endif | |
| 245 }; | |
| 246 | |
| 247 // A Pause_No_Safepoint_Verifier is used to temporarily pause the | |
| 248 // behavior of a No_Safepoint_Verifier object. If we are not in debug | |
| 249 // mode then there is nothing to do. If the No_Safepoint_Verifier | |
| 250 // object has an _activated value of false, then there is nothing to | |
| 251 // do for safepoint and allocation checking, but there may still be | |
| 252 // something to do for the underlying No_GC_Verifier object. | |
| 253 | |
| 254 class Pause_No_Safepoint_Verifier : public Pause_No_GC_Verifier { | |
| 255 private: | |
| 256 No_Safepoint_Verifier * _nsv; | |
| 257 | |
| 258 public: | |
| 259 #ifdef ASSERT | |
| 260 Pause_No_Safepoint_Verifier(No_Safepoint_Verifier * nsv) | |
| 261 : Pause_No_GC_Verifier(nsv) { | |
| 262 | |
| 263 _nsv = nsv; | |
| 264 if (_nsv->_activated) { | |
| 265 _nsv->_thread->_allow_allocation_count--; | |
| 266 _nsv->_thread->_allow_safepoint_count--; | |
| 267 } | |
| 268 } | |
| 269 | |
| 270 ~Pause_No_Safepoint_Verifier() { | |
| 271 if (_nsv->_activated) { | |
| 272 _nsv->_thread->_allow_allocation_count++; | |
| 273 _nsv->_thread->_allow_safepoint_count++; | |
| 274 } | |
| 275 } | |
| 276 #else | |
| 277 Pause_No_Safepoint_Verifier(No_Safepoint_Verifier * nsv) | |
| 278 : Pause_No_GC_Verifier(nsv) {} | |
| 279 ~Pause_No_Safepoint_Verifier() {} | |
| 280 #endif | |
| 281 }; | |
| 282 | |
|
806
821269eca479
6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents:
196
diff
changeset
|
283 // 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
|
284 // 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
|
285 // prevent re-entrant calls to GC. |
|
821269eca479
6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents:
196
diff
changeset
|
286 class SkipGCALot : public StackObj { |
|
821269eca479
6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents:
196
diff
changeset
|
287 private: |
|
821269eca479
6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents:
196
diff
changeset
|
288 bool _saved; |
|
821269eca479
6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents:
196
diff
changeset
|
289 Thread* _t; |
|
821269eca479
6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents:
196
diff
changeset
|
290 |
|
821269eca479
6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents:
196
diff
changeset
|
291 public: |
|
821269eca479
6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents:
196
diff
changeset
|
292 #ifdef ASSERT |
|
821269eca479
6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents:
196
diff
changeset
|
293 SkipGCALot(Thread* t) : _t(t) { |
|
821269eca479
6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents:
196
diff
changeset
|
294 _saved = _t->skip_gcalot(); |
|
821269eca479
6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents:
196
diff
changeset
|
295 _t->set_skip_gcalot(true); |
|
821269eca479
6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents:
196
diff
changeset
|
296 } |
|
821269eca479
6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents:
196
diff
changeset
|
297 |
|
821269eca479
6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents:
196
diff
changeset
|
298 ~SkipGCALot() { |
|
821269eca479
6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents:
196
diff
changeset
|
299 assert(_t->skip_gcalot(), "Save-restore protocol invariant"); |
|
821269eca479
6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents:
196
diff
changeset
|
300 _t->set_skip_gcalot(_saved); |
|
821269eca479
6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents:
196
diff
changeset
|
301 } |
|
821269eca479
6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents:
196
diff
changeset
|
302 #else |
|
821269eca479
6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents:
196
diff
changeset
|
303 SkipGCALot(Thread* t) { } |
|
821269eca479
6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents:
196
diff
changeset
|
304 ~SkipGCALot() { } |
|
821269eca479
6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents:
196
diff
changeset
|
305 #endif |
|
821269eca479
6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents:
196
diff
changeset
|
306 }; |
|
821269eca479
6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents:
196
diff
changeset
|
307 |
| 0 | 308 // JRT_LEAF currently can be called from either _thread_in_Java or |
| 309 // _thread_in_native mode. In _thread_in_native, it is ok | |
| 310 // for another thread to trigger GC. The rest of the JRT_LEAF | |
| 311 // rules apply. | |
| 312 class JRT_Leaf_Verifier : public No_Safepoint_Verifier { | |
| 313 static bool should_verify_GC(); | |
| 314 public: | |
| 315 #ifdef ASSERT | |
| 316 JRT_Leaf_Verifier(); | |
| 317 ~JRT_Leaf_Verifier(); | |
| 318 #else | |
| 319 JRT_Leaf_Verifier() {} | |
| 320 ~JRT_Leaf_Verifier() {} | |
| 321 #endif | |
| 322 }; | |
| 323 | |
| 324 // A No_Alloc_Verifier object can be placed in methods where one assumes that | |
| 325 // no allocation will occur. The destructor will verify this property | |
| 326 // unless the constructor is called with argument false (not activated). | |
| 327 // | |
| 328 // The check will only be done in debug mode and if activated. | |
| 329 // Note: this only makes sense at safepoints (otherwise, other threads may | |
| 330 // allocate concurrently.) | |
| 331 | |
| 332 class No_Alloc_Verifier : public StackObj { | |
| 333 private: | |
| 334 bool _activated; | |
| 335 | |
| 336 public: | |
| 337 #ifdef ASSERT | |
| 338 No_Alloc_Verifier(bool activated = true) { | |
| 339 _activated = activated; | |
| 340 if (_activated) Thread::current()->_allow_allocation_count++; | |
| 341 } | |
| 342 | |
| 343 ~No_Alloc_Verifier() { | |
| 344 if (_activated) Thread::current()->_allow_allocation_count--; | |
| 345 } | |
| 346 #else | |
| 347 No_Alloc_Verifier(bool activated = true) {} | |
| 348 ~No_Alloc_Verifier() {} | |
| 349 #endif | |
| 350 }; | |
| 1972 | 351 |
| 352 #endif // SHARE_VM_MEMORY_GCLOCKER_HPP |