Mercurial > hg > truffle
annotate src/share/vm/services/lowMemoryDetector.cpp @ 5763:a3d71693e0ce
removed bytecode disassembly from CodeCacheRuntime into separate BytecodeDisassembler class
removed VM call for doing bytecode disassembly
added support for explicitly excluding classes from JaCoCo (put '// JaCoCo Exclude' somewhere in the source file)
added node intrinsics to MaterializeNode
added snippets for the UnsignedMath classes
each file opened by CFGPrinter now includes a unique id in its name to avoid a race of multiple threads writing to the same file
the IdealGraphPrinter uses the new BytecodeDisassembler mechanism
teh UnsignedMath class is exclude from JaCoCo processing as it is used in snippets
author | Doug Simon <doug.simon@oracle.com> |
---|---|
date | Wed, 04 Jul 2012 21:57:49 +0200 |
parents | bf8517f4e4d0 |
children | da91efe96a93 |
rev | line source |
---|---|
0 | 1 /* |
2195
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
2 * Copyright (c) 2003, 2011, 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:
1142
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1142
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:
1142
diff
changeset
|
21 * questions. |
0 | 22 * |
23 */ | |
24 | |
1972 | 25 #include "precompiled.hpp" |
26 #include "classfile/systemDictionary.hpp" | |
27 #include "classfile/vmSymbols.hpp" | |
28 #include "oops/oop.inline.hpp" | |
29 #include "runtime/interfaceSupport.hpp" | |
30 #include "runtime/java.hpp" | |
31 #include "runtime/javaCalls.hpp" | |
32 #include "runtime/mutex.hpp" | |
33 #include "runtime/mutexLocker.hpp" | |
34 #include "services/lowMemoryDetector.hpp" | |
35 #include "services/management.hpp" | |
0 | 36 |
37 volatile bool LowMemoryDetector::_enabled_for_collected_pools = false; | |
38 volatile jint LowMemoryDetector::_disabled_count = 0; | |
39 | |
40 bool LowMemoryDetector::has_pending_requests() { | |
2195
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
41 assert(Service_lock->owned_by_self(), "Must own Service_lock"); |
0 | 42 bool has_requests = false; |
43 int num_memory_pools = MemoryService::num_memory_pools(); | |
44 for (int i = 0; i < num_memory_pools; i++) { | |
45 MemoryPool* pool = MemoryService::get_memory_pool(i); | |
46 SensorInfo* sensor = pool->usage_sensor(); | |
47 if (sensor != NULL) { | |
48 has_requests = has_requests || sensor->has_pending_requests(); | |
49 } | |
50 | |
51 SensorInfo* gc_sensor = pool->gc_usage_sensor(); | |
52 if (gc_sensor != NULL) { | |
53 has_requests = has_requests || gc_sensor->has_pending_requests(); | |
54 } | |
55 } | |
56 return has_requests; | |
57 } | |
58 | |
2195
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
59 void LowMemoryDetector::process_sensor_changes(TRAPS) { |
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
60 ResourceMark rm(THREAD); |
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
61 HandleMark hm(THREAD); |
0 | 62 |
2195
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
63 // No need to hold Service_lock to call out to Java |
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
64 int num_memory_pools = MemoryService::num_memory_pools(); |
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
65 for (int i = 0; i < num_memory_pools; i++) { |
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
66 MemoryPool* pool = MemoryService::get_memory_pool(i); |
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
67 SensorInfo* sensor = pool->usage_sensor(); |
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
68 SensorInfo* gc_sensor = pool->gc_usage_sensor(); |
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
69 if (sensor != NULL && sensor->has_pending_requests()) { |
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
70 sensor->process_pending_requests(CHECK); |
0 | 71 } |
2195
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
72 if (gc_sensor != NULL && gc_sensor->has_pending_requests()) { |
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
73 gc_sensor->process_pending_requests(CHECK); |
0 | 74 } |
75 } | |
76 } | |
77 | |
78 // This method could be called from any Java threads | |
79 // and also VMThread. | |
80 void LowMemoryDetector::detect_low_memory() { | |
2195
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
81 MutexLockerEx ml(Service_lock, Mutex::_no_safepoint_check_flag); |
0 | 82 |
83 bool has_pending_requests = false; | |
84 int num_memory_pools = MemoryService::num_memory_pools(); | |
85 for (int i = 0; i < num_memory_pools; i++) { | |
86 MemoryPool* pool = MemoryService::get_memory_pool(i); | |
87 SensorInfo* sensor = pool->usage_sensor(); | |
88 if (sensor != NULL && | |
89 pool->usage_threshold()->is_high_threshold_supported() && | |
90 pool->usage_threshold()->high_threshold() != 0) { | |
91 MemoryUsage usage = pool->get_memory_usage(); | |
92 sensor->set_gauge_sensor_level(usage, | |
93 pool->usage_threshold()); | |
94 has_pending_requests = has_pending_requests || sensor->has_pending_requests(); | |
95 } | |
96 } | |
97 | |
98 if (has_pending_requests) { | |
2195
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
99 Service_lock->notify_all(); |
0 | 100 } |
101 } | |
102 | |
103 // This method could be called from any Java threads | |
104 // and also VMThread. | |
105 void LowMemoryDetector::detect_low_memory(MemoryPool* pool) { | |
106 SensorInfo* sensor = pool->usage_sensor(); | |
107 if (sensor == NULL || | |
108 !pool->usage_threshold()->is_high_threshold_supported() || | |
109 pool->usage_threshold()->high_threshold() == 0) { | |
110 return; | |
111 } | |
112 | |
113 { | |
2195
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
114 MutexLockerEx ml(Service_lock, Mutex::_no_safepoint_check_flag); |
0 | 115 |
116 MemoryUsage usage = pool->get_memory_usage(); | |
117 sensor->set_gauge_sensor_level(usage, | |
118 pool->usage_threshold()); | |
119 if (sensor->has_pending_requests()) { | |
120 // notify sensor state update | |
2195
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
121 Service_lock->notify_all(); |
0 | 122 } |
123 } | |
124 } | |
125 | |
126 // Only called by VMThread at GC time | |
127 void LowMemoryDetector::detect_after_gc_memory(MemoryPool* pool) { | |
128 SensorInfo* sensor = pool->gc_usage_sensor(); | |
129 if (sensor == NULL || | |
130 !pool->gc_usage_threshold()->is_high_threshold_supported() || | |
131 pool->gc_usage_threshold()->high_threshold() == 0) { | |
132 return; | |
133 } | |
134 | |
135 { | |
2195
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
136 MutexLockerEx ml(Service_lock, Mutex::_no_safepoint_check_flag); |
0 | 137 |
138 MemoryUsage usage = pool->get_last_collection_usage(); | |
139 sensor->set_counter_sensor_level(usage, pool->gc_usage_threshold()); | |
140 | |
141 if (sensor->has_pending_requests()) { | |
142 // notify sensor state update | |
2195
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
143 Service_lock->notify_all(); |
0 | 144 } |
145 } | |
146 } | |
147 | |
148 // recompute enabled flag | |
149 void LowMemoryDetector::recompute_enabled_for_collected_pools() { | |
150 bool enabled = false; | |
151 int num_memory_pools = MemoryService::num_memory_pools(); | |
152 for (int i=0; i<num_memory_pools; i++) { | |
153 MemoryPool* pool = MemoryService::get_memory_pool(i); | |
154 if (pool->is_collected_pool() && is_enabled(pool)) { | |
155 enabled = true; | |
156 break; | |
157 } | |
158 } | |
159 _enabled_for_collected_pools = enabled; | |
160 } | |
161 | |
162 SensorInfo::SensorInfo() { | |
163 _sensor_obj = NULL; | |
164 _sensor_on = false; | |
165 _sensor_count = 0; | |
166 _pending_trigger_count = 0; | |
167 _pending_clear_count = 0; | |
168 } | |
169 | |
170 // When this method is used, the memory usage is monitored | |
171 // as a gauge attribute. Sensor notifications (trigger or | |
172 // clear) is only emitted at the first time it crosses | |
173 // a threshold. | |
174 // | |
175 // High and low thresholds are designed to provide a | |
176 // hysteresis mechanism to avoid repeated triggering | |
177 // of notifications when the attribute value makes small oscillations | |
178 // around the high or low threshold value. | |
179 // | |
180 // The sensor will be triggered if: | |
181 // (1) the usage is crossing above the high threshold and | |
182 // the sensor is currently off and no pending | |
183 // trigger requests; or | |
184 // (2) the usage is crossing above the high threshold and | |
185 // the sensor will be off (i.e. sensor is currently on | |
186 // and has pending clear requests). | |
187 // | |
188 // Subsequent crossings of the high threshold value do not cause | |
189 // any triggers unless the usage becomes less than the low threshold. | |
190 // | |
191 // The sensor will be cleared if: | |
192 // (1) the usage is crossing below the low threshold and | |
193 // the sensor is currently on and no pending | |
194 // clear requests; or | |
195 // (2) the usage is crossing below the low threshold and | |
196 // the sensor will be on (i.e. sensor is currently off | |
197 // and has pending trigger requests). | |
198 // | |
199 // Subsequent crossings of the low threshold value do not cause | |
200 // any clears unless the usage becomes greater than or equal | |
201 // to the high threshold. | |
202 // | |
203 // If the current level is between high and low threhsold, no change. | |
204 // | |
205 void SensorInfo::set_gauge_sensor_level(MemoryUsage usage, ThresholdSupport* high_low_threshold) { | |
206 assert(high_low_threshold->is_high_threshold_supported(), "just checking"); | |
207 | |
208 bool is_over_high = high_low_threshold->is_high_threshold_crossed(usage); | |
209 bool is_below_low = high_low_threshold->is_low_threshold_crossed(usage); | |
210 | |
211 assert(!(is_over_high && is_below_low), "Can't be both true"); | |
212 | |
213 if (is_over_high && | |
214 ((!_sensor_on && _pending_trigger_count == 0) || | |
215 _pending_clear_count > 0)) { | |
216 // low memory detected and need to increment the trigger pending count | |
217 // if the sensor is off or will be off due to _pending_clear_ > 0 | |
218 // Request to trigger the sensor | |
219 _pending_trigger_count++; | |
220 _usage = usage; | |
221 | |
222 if (_pending_clear_count > 0) { | |
223 // non-zero pending clear requests indicates that there are | |
224 // pending requests to clear this sensor. | |
225 // This trigger request needs to clear this clear count | |
226 // since the resulting sensor flag should be on. | |
227 _pending_clear_count = 0; | |
228 } | |
229 } else if (is_below_low && | |
230 ((_sensor_on && _pending_clear_count == 0) || | |
231 (_pending_trigger_count > 0 && _pending_clear_count == 0))) { | |
232 // memory usage returns below the threshold | |
233 // Request to clear the sensor if the sensor is on or will be on due to | |
234 // _pending_trigger_count > 0 and also no clear request | |
235 _pending_clear_count++; | |
236 } | |
237 } | |
238 | |
239 // When this method is used, the memory usage is monitored as a | |
240 // simple counter attribute. The sensor will be triggered | |
241 // whenever the usage is crossing the threshold to keep track | |
242 // of the number of times the VM detects such a condition occurs. | |
243 // | |
244 // High and low thresholds are designed to provide a | |
245 // hysteresis mechanism to avoid repeated triggering | |
246 // of notifications when the attribute value makes small oscillations | |
247 // around the high or low threshold value. | |
248 // | |
249 // The sensor will be triggered if: | |
250 // - the usage is crossing above the high threshold regardless | |
251 // of the current sensor state. | |
252 // | |
253 // The sensor will be cleared if: | |
254 // (1) the usage is crossing below the low threshold and | |
255 // the sensor is currently on; or | |
256 // (2) the usage is crossing below the low threshold and | |
257 // the sensor will be on (i.e. sensor is currently off | |
258 // and has pending trigger requests). | |
259 void SensorInfo::set_counter_sensor_level(MemoryUsage usage, ThresholdSupport* counter_threshold) { | |
260 assert(counter_threshold->is_high_threshold_supported(), "just checking"); | |
261 | |
262 bool is_over_high = counter_threshold->is_high_threshold_crossed(usage); | |
263 bool is_below_low = counter_threshold->is_low_threshold_crossed(usage); | |
264 | |
265 assert(!(is_over_high && is_below_low), "Can't be both true"); | |
266 | |
267 if (is_over_high) { | |
268 _pending_trigger_count++; | |
269 _usage = usage; | |
270 _pending_clear_count = 0; | |
271 } else if (is_below_low && (_sensor_on || _pending_trigger_count > 0)) { | |
272 _pending_clear_count++; | |
273 } | |
274 } | |
275 | |
276 void SensorInfo::oops_do(OopClosure* f) { | |
277 f->do_oop((oop*) &_sensor_obj); | |
278 } | |
279 | |
280 void SensorInfo::process_pending_requests(TRAPS) { | |
281 if (!has_pending_requests()) { | |
282 return; | |
283 } | |
284 | |
285 int pending_count = pending_trigger_count(); | |
286 if (pending_clear_count() > 0) { | |
287 clear(pending_count, CHECK); | |
288 } else { | |
289 trigger(pending_count, CHECK); | |
290 } | |
291 | |
292 } | |
293 | |
294 void SensorInfo::trigger(int count, TRAPS) { | |
295 assert(count <= _pending_trigger_count, "just checking"); | |
296 | |
297 if (_sensor_obj != NULL) { | |
298 klassOop k = Management::sun_management_Sensor_klass(CHECK); | |
299 instanceKlassHandle sensorKlass (THREAD, k); | |
300 Handle sensor_h(THREAD, _sensor_obj); | |
301 Handle usage_h = MemoryService::create_MemoryUsage_obj(_usage, CHECK); | |
302 | |
303 JavaValue result(T_VOID); | |
304 JavaCallArguments args(sensor_h); | |
305 args.push_int((int) count); | |
306 args.push_oop(usage_h); | |
307 | |
308 JavaCalls::call_virtual(&result, | |
309 sensorKlass, | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
310 vmSymbols::trigger_name(), |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
311 vmSymbols::trigger_method_signature(), |
0 | 312 &args, |
313 CHECK); | |
314 } | |
315 | |
316 { | |
2195
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
317 // Holds Service_lock and update the sensor state |
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
318 MutexLockerEx ml(Service_lock, Mutex::_no_safepoint_check_flag); |
0 | 319 _sensor_on = true; |
320 _sensor_count += count; | |
321 _pending_trigger_count = _pending_trigger_count - count; | |
322 } | |
323 } | |
324 | |
325 void SensorInfo::clear(int count, TRAPS) { | |
326 if (_sensor_obj != NULL) { | |
327 klassOop k = Management::sun_management_Sensor_klass(CHECK); | |
328 instanceKlassHandle sensorKlass (THREAD, k); | |
329 Handle sensor(THREAD, _sensor_obj); | |
330 | |
331 JavaValue result(T_VOID); | |
332 JavaCallArguments args(sensor); | |
333 args.push_int((int) count); | |
334 JavaCalls::call_virtual(&result, | |
335 sensorKlass, | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
336 vmSymbols::clear_name(), |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
337 vmSymbols::int_void_signature(), |
0 | 338 &args, |
339 CHECK); | |
340 } | |
341 | |
342 { | |
2195
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
343 // Holds Service_lock and update the sensor state |
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
344 MutexLockerEx ml(Service_lock, Mutex::_no_safepoint_check_flag); |
0 | 345 _sensor_on = false; |
346 _pending_clear_count = 0; | |
347 _pending_trigger_count = _pending_trigger_count - count; | |
348 } | |
349 } | |
350 | |
351 //-------------------------------------------------------------- | |
352 // Non-product code | |
353 | |
354 #ifndef PRODUCT | |
355 void SensorInfo::print() { | |
356 tty->print_cr("%s count = %ld pending_triggers = %ld pending_clears = %ld", | |
357 (_sensor_on ? "on" : "off"), | |
358 _sensor_count, _pending_trigger_count, _pending_clear_count); | |
359 } | |
360 | |
361 #endif // PRODUCT |