Mercurial > hg > graal-compiler
annotate src/share/vm/memory/genCollectedHeap.cpp @ 20295:3f2894c5052e
8048112: G1 Full GC needs to support the case when the very first region is not available
Summary: Refactor preparation for compaction during Full GC so that it lazily initializes the first compaction point. This also avoids problems later when the first region may not be committed. Also reviewed by K. Barrett.
Reviewed-by: brutisso
author | tschatzl |
---|---|
date | Mon, 21 Jul 2014 10:00:31 +0200 |
parents | 2c6ef90f030a |
children | 439f0d76cff3 4bfc44ba0d19 |
rev | line source |
---|---|
0 | 1 /* |
17937
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17866
diff
changeset
|
2 * Copyright (c) 2000, 2014, 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:
1520
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1520
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:
1520
diff
changeset
|
21 * questions. |
0 | 22 * |
23 */ | |
24 | |
1972 | 25 #include "precompiled.hpp" |
26 #include "classfile/symbolTable.hpp" | |
27 #include "classfile/systemDictionary.hpp" | |
28 #include "classfile/vmSymbols.hpp" | |
29 #include "code/icBuffer.hpp" | |
30 #include "gc_implementation/shared/collectorCounters.hpp" | |
20190
0982ec23da03
8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents:
17937
diff
changeset
|
31 #include "gc_implementation/shared/gcTrace.hpp" |
10405 | 32 #include "gc_implementation/shared/gcTraceTime.hpp" |
1972 | 33 #include "gc_implementation/shared/vmGCOperations.hpp" |
34 #include "gc_interface/collectedHeap.inline.hpp" | |
35 #include "memory/filemap.hpp" | |
36 #include "memory/gcLocker.inline.hpp" | |
37 #include "memory/genCollectedHeap.hpp" | |
38 #include "memory/genOopClosures.inline.hpp" | |
39 #include "memory/generation.inline.hpp" | |
40 #include "memory/generationSpec.hpp" | |
41 #include "memory/resourceArea.hpp" | |
42 #include "memory/sharedHeap.hpp" | |
43 #include "memory/space.hpp" | |
44 #include "oops/oop.inline.hpp" | |
45 #include "oops/oop.inline2.hpp" | |
46 #include "runtime/biasedLocking.hpp" | |
47 #include "runtime/fprofiler.hpp" | |
48 #include "runtime/handles.hpp" | |
49 #include "runtime/handles.inline.hpp" | |
50 #include "runtime/java.hpp" | |
51 #include "runtime/vmThread.hpp" | |
52 #include "services/memoryService.hpp" | |
53 #include "utilities/vmError.hpp" | |
54 #include "utilities/workgroup.hpp" | |
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6865
diff
changeset
|
55 #include "utilities/macros.hpp" |
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6865
diff
changeset
|
56 #if INCLUDE_ALL_GCS |
1972 | 57 #include "gc_implementation/concurrentMarkSweep/concurrentMarkSweepThread.hpp" |
58 #include "gc_implementation/concurrentMarkSweep/vmCMSOperations.hpp" | |
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6865
diff
changeset
|
59 #endif // INCLUDE_ALL_GCS |
0 | 60 |
61 GenCollectedHeap* GenCollectedHeap::_gch; | |
62 NOT_PRODUCT(size_t GenCollectedHeap::_skip_header_HeapWords = 0;) | |
63 | |
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
64 // The set of potentially parallel tasks in root scanning. |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
65 enum GCH_strong_roots_tasks { |
0 | 66 // We probably want to parallelize both of these internally, but for now... |
67 GCH_PS_younger_gens, | |
68 // Leave this one last. | |
69 GCH_PS_NumElements | |
70 }; | |
71 | |
72 GenCollectedHeap::GenCollectedHeap(GenCollectorPolicy *policy) : | |
73 SharedHeap(policy), | |
74 _gen_policy(policy), | |
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
75 _gen_process_roots_tasks(new SubTasksDone(GCH_PS_NumElements)), |
0 | 76 _full_collections_completed(0) |
77 { | |
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
78 if (_gen_process_roots_tasks == NULL || |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
79 !_gen_process_roots_tasks->valid()) { |
0 | 80 vm_exit_during_initialization("Failed necessary allocation."); |
81 } | |
82 assert(policy != NULL, "Sanity check"); | |
83 } | |
84 | |
85 jint GenCollectedHeap::initialize() { | |
1166 | 86 CollectedHeap::pre_initialize(); |
87 | |
0 | 88 int i; |
89 _n_gens = gen_policy()->number_of_generations(); | |
90 | |
91 // While there are no constraints in the GC code that HeapWordSize | |
92 // be any particular value, there are multiple other areas in the | |
93 // system which believe this to be true (e.g. oop->object_size in some | |
94 // cases incorrectly returns the size in wordSize units rather than | |
95 // HeapWordSize). | |
96 guarantee(HeapWordSize == wordSize, "HeapWordSize must equal wordSize"); | |
97 | |
98 // The heap must be at least as aligned as generations. | |
12110
4c84d351cca9
8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents:
12063
diff
changeset
|
99 size_t gen_alignment = Generation::GenGrain; |
0 | 100 |
101 _gen_specs = gen_policy()->generations(); | |
102 | |
103 // Make sure the sizes are all aligned. | |
104 for (i = 0; i < _n_gens; i++) { | |
12110
4c84d351cca9
8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents:
12063
diff
changeset
|
105 _gen_specs[i]->align(gen_alignment); |
0 | 106 } |
107 | |
108 // Allocate space for the heap. | |
109 | |
110 char* heap_address; | |
111 size_t total_reserved = 0; | |
112 int n_covered_regions = 0; | |
12110
4c84d351cca9
8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents:
12063
diff
changeset
|
113 ReservedSpace heap_rs; |
0 | 114 |
13060
8f07aa079343
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
13059
diff
changeset
|
115 size_t heap_alignment = collector_policy()->heap_alignment(); |
12110
4c84d351cca9
8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents:
12063
diff
changeset
|
116 |
4c84d351cca9
8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents:
12063
diff
changeset
|
117 heap_address = allocate(heap_alignment, &total_reserved, |
0 | 118 &n_covered_regions, &heap_rs); |
119 | |
120 if (!heap_rs.is_reserved()) { | |
121 vm_shutdown_during_initialization( | |
122 "Could not reserve enough space for object heap"); | |
123 return JNI_ENOMEM; | |
124 } | |
125 | |
126 _reserved = MemRegion((HeapWord*)heap_rs.base(), | |
127 (HeapWord*)(heap_rs.base() + heap_rs.size())); | |
128 | |
129 // It is important to do this in a way such that concurrent readers can't | |
130 // temporarily think somethings in the heap. (Seen this happen in asserts.) | |
131 _reserved.set_word_size(0); | |
132 _reserved.set_start((HeapWord*)heap_rs.base()); | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6109
diff
changeset
|
133 size_t actual_heap_size = heap_rs.size(); |
0 | 134 _reserved.set_end((HeapWord*)(heap_rs.base() + actual_heap_size)); |
135 | |
136 _rem_set = collector_policy()->create_rem_set(_reserved, n_covered_regions); | |
137 set_barrier_set(rem_set()->bs()); | |
1166 | 138 |
0 | 139 _gch = this; |
140 | |
141 for (i = 0; i < _n_gens; i++) { | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6109
diff
changeset
|
142 ReservedSpace this_rs = heap_rs.first_part(_gen_specs[i]->max_size(), false, false); |
0 | 143 _gens[i] = _gen_specs[i]->init(this_rs, i, rem_set()); |
144 heap_rs = heap_rs.last_part(_gen_specs[i]->max_size()); | |
145 } | |
1888
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1833
diff
changeset
|
146 clear_incremental_collection_failed(); |
0 | 147 |
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6865
diff
changeset
|
148 #if INCLUDE_ALL_GCS |
0 | 149 // If we are running CMS, create the collector responsible |
150 // for collecting the CMS generations. | |
151 if (collector_policy()->is_concurrent_mark_sweep_policy()) { | |
152 bool success = create_cms_collector(); | |
153 if (!success) return JNI_ENOMEM; | |
154 } | |
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6865
diff
changeset
|
155 #endif // INCLUDE_ALL_GCS |
0 | 156 |
157 return JNI_OK; | |
158 } | |
159 | |
160 | |
161 char* GenCollectedHeap::allocate(size_t alignment, | |
162 size_t* _total_reserved, | |
163 int* _n_covered_regions, | |
164 ReservedSpace* heap_rs){ | |
165 const char overflow_msg[] = "The size of the object heap + VM data exceeds " | |
166 "the maximum representable size"; | |
167 | |
168 // Now figure out the total size. | |
169 size_t total_reserved = 0; | |
170 int n_covered_regions = 0; | |
171 const size_t pageSize = UseLargePages ? | |
172 os::large_page_size() : os::vm_page_size(); | |
173 | |
12110
4c84d351cca9
8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents:
12063
diff
changeset
|
174 assert(alignment % pageSize == 0, "Must be"); |
4c84d351cca9
8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents:
12063
diff
changeset
|
175 |
0 | 176 for (int i = 0; i < _n_gens; i++) { |
177 total_reserved += _gen_specs[i]->max_size(); | |
178 if (total_reserved < _gen_specs[i]->max_size()) { | |
179 vm_exit_during_initialization(overflow_msg); | |
180 } | |
181 n_covered_regions += _gen_specs[i]->n_covered_regions(); | |
182 } | |
12110
4c84d351cca9
8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents:
12063
diff
changeset
|
183 assert(total_reserved % alignment == 0, |
4c84d351cca9
8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents:
12063
diff
changeset
|
184 err_msg("Gen size; total_reserved=" SIZE_FORMAT ", alignment=" |
4c84d351cca9
8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents:
12063
diff
changeset
|
185 SIZE_FORMAT, total_reserved, alignment)); |
0 | 186 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6109
diff
changeset
|
187 // Needed until the cardtable is fixed to have the right number |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6109
diff
changeset
|
188 // of covered regions. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6109
diff
changeset
|
189 n_covered_regions += 2; |
0 | 190 |
12110
4c84d351cca9
8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents:
12063
diff
changeset
|
191 *_total_reserved = total_reserved; |
4c84d351cca9
8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents:
12063
diff
changeset
|
192 *_n_covered_regions = n_covered_regions; |
0 | 193 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6109
diff
changeset
|
194 *heap_rs = Universe::reserve_heap(total_reserved, alignment); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6109
diff
changeset
|
195 return heap_rs->base(); |
0 | 196 } |
197 | |
198 | |
199 void GenCollectedHeap::post_initialize() { | |
200 SharedHeap::post_initialize(); | |
201 TwoGenerationCollectorPolicy *policy = | |
202 (TwoGenerationCollectorPolicy *)collector_policy(); | |
203 guarantee(policy->is_two_generation_policy(), "Illegal policy type"); | |
204 DefNewGeneration* def_new_gen = (DefNewGeneration*) get_gen(0); | |
205 assert(def_new_gen->kind() == Generation::DefNew || | |
206 def_new_gen->kind() == Generation::ParNew || | |
207 def_new_gen->kind() == Generation::ASParNew, | |
208 "Wrong generation kind"); | |
209 | |
210 Generation* old_gen = get_gen(1); | |
211 assert(old_gen->kind() == Generation::ConcurrentMarkSweep || | |
212 old_gen->kind() == Generation::ASConcurrentMarkSweep || | |
213 old_gen->kind() == Generation::MarkSweepCompact, | |
214 "Wrong generation kind"); | |
215 | |
216 policy->initialize_size_policy(def_new_gen->eden()->capacity(), | |
217 old_gen->capacity(), | |
218 def_new_gen->from()->capacity()); | |
219 policy->initialize_gc_policy_counters(); | |
220 } | |
221 | |
222 void GenCollectedHeap::ref_processing_init() { | |
223 SharedHeap::ref_processing_init(); | |
224 for (int i = 0; i < _n_gens; i++) { | |
225 _gens[i]->ref_processor_init(); | |
226 } | |
227 } | |
228 | |
229 size_t GenCollectedHeap::capacity() const { | |
230 size_t res = 0; | |
231 for (int i = 0; i < _n_gens; i++) { | |
232 res += _gens[i]->capacity(); | |
233 } | |
234 return res; | |
235 } | |
236 | |
237 size_t GenCollectedHeap::used() const { | |
238 size_t res = 0; | |
239 for (int i = 0; i < _n_gens; i++) { | |
240 res += _gens[i]->used(); | |
241 } | |
242 return res; | |
243 } | |
244 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6109
diff
changeset
|
245 // Save the "used_region" for generations level and lower. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6109
diff
changeset
|
246 void GenCollectedHeap::save_used_regions(int level) { |
0 | 247 assert(level < _n_gens, "Illegal level parameter"); |
248 for (int i = level; i >= 0; i--) { | |
249 _gens[i]->save_used_region(); | |
250 } | |
251 } | |
252 | |
253 size_t GenCollectedHeap::max_capacity() const { | |
254 size_t res = 0; | |
255 for (int i = 0; i < _n_gens; i++) { | |
256 res += _gens[i]->max_capacity(); | |
257 } | |
258 return res; | |
259 } | |
260 | |
261 // Update the _full_collections_completed counter | |
262 // at the end of a stop-world full GC. | |
263 unsigned int GenCollectedHeap::update_full_collections_completed() { | |
264 MonitorLockerEx ml(FullGCCount_lock, Mutex::_no_safepoint_check_flag); | |
265 assert(_full_collections_completed <= _total_full_collections, | |
266 "Can't complete more collections than were started"); | |
267 _full_collections_completed = _total_full_collections; | |
268 ml.notify_all(); | |
269 return _full_collections_completed; | |
270 } | |
271 | |
272 // Update the _full_collections_completed counter, as appropriate, | |
273 // at the end of a concurrent GC cycle. Note the conditional update | |
274 // below to allow this method to be called by a concurrent collector | |
275 // without synchronizing in any manner with the VM thread (which | |
276 // may already have initiated a STW full collection "concurrently"). | |
277 unsigned int GenCollectedHeap::update_full_collections_completed(unsigned int count) { | |
278 MonitorLockerEx ml(FullGCCount_lock, Mutex::_no_safepoint_check_flag); | |
279 assert((_full_collections_completed <= _total_full_collections) && | |
280 (count <= _total_full_collections), | |
281 "Can't complete more collections than were started"); | |
282 if (count > _full_collections_completed) { | |
283 _full_collections_completed = count; | |
284 ml.notify_all(); | |
285 } | |
286 return _full_collections_completed; | |
287 } | |
288 | |
289 | |
290 #ifndef PRODUCT | |
291 // Override of memory state checking method in CollectedHeap: | |
292 // Some collectors (CMS for example) can't have badHeapWordVal written | |
293 // in the first two words of an object. (For instance , in the case of | |
294 // CMS these words hold state used to synchronize between certain | |
295 // (concurrent) GC steps and direct allocating mutators.) | |
296 // The skip_header_HeapWords() method below, allows us to skip | |
297 // over the requisite number of HeapWord's. Note that (for | |
298 // generational collectors) this means that those many words are | |
299 // skipped in each object, irrespective of the generation in which | |
300 // that object lives. The resultant loss of precision seems to be | |
301 // harmless and the pain of avoiding that imprecision appears somewhat | |
302 // higher than we are prepared to pay for such rudimentary debugging | |
303 // support. | |
304 void GenCollectedHeap::check_for_non_bad_heap_word_value(HeapWord* addr, | |
305 size_t size) { | |
306 if (CheckMemoryInitialization && ZapUnusedHeapArea) { | |
307 // We are asked to check a size in HeapWords, | |
308 // but the memory is mangled in juint words. | |
309 juint* start = (juint*) (addr + skip_header_HeapWords()); | |
310 juint* end = (juint*) (addr + size); | |
311 for (juint* slot = start; slot < end; slot += 1) { | |
312 assert(*slot == badHeapWordVal, | |
313 "Found non badHeapWordValue in pre-allocation check"); | |
314 } | |
315 } | |
316 } | |
317 #endif | |
318 | |
319 HeapWord* GenCollectedHeap::attempt_allocation(size_t size, | |
320 bool is_tlab, | |
321 bool first_only) { | |
322 HeapWord* res; | |
323 for (int i = 0; i < _n_gens; i++) { | |
324 if (_gens[i]->should_allocate(size, is_tlab)) { | |
325 res = _gens[i]->allocate(size, is_tlab); | |
326 if (res != NULL) return res; | |
327 else if (first_only) break; | |
328 } | |
329 } | |
330 // Otherwise... | |
331 return NULL; | |
332 } | |
333 | |
334 HeapWord* GenCollectedHeap::mem_allocate(size_t size, | |
335 bool* gc_overhead_limit_was_exceeded) { | |
336 return collector_policy()->mem_allocate_work(size, | |
3774
c9ca3f51cf41
6994322: Remove the is_tlab and is_noref / is_large_noref parameters from the CollectedHeap
tonyp
parents:
3772
diff
changeset
|
337 false /* is_tlab */, |
0 | 338 gc_overhead_limit_was_exceeded); |
339 } | |
340 | |
341 bool GenCollectedHeap::must_clear_all_soft_refs() { | |
342 return _gc_cause == GCCause::_last_ditch_collection; | |
343 } | |
344 | |
345 bool GenCollectedHeap::should_do_concurrent_full_gc(GCCause::Cause cause) { | |
1520
bb843ebc7c55
6919638: CMS: ExplicitGCInvokesConcurrent misinteracts with gc locker
ysr
parents:
1387
diff
changeset
|
346 return UseConcMarkSweepGC && |
bb843ebc7c55
6919638: CMS: ExplicitGCInvokesConcurrent misinteracts with gc locker
ysr
parents:
1387
diff
changeset
|
347 ((cause == GCCause::_gc_locker && GCLockerInvokesConcurrent) || |
bb843ebc7c55
6919638: CMS: ExplicitGCInvokesConcurrent misinteracts with gc locker
ysr
parents:
1387
diff
changeset
|
348 (cause == GCCause::_java_lang_system_gc && ExplicitGCInvokesConcurrent)); |
0 | 349 } |
350 | |
351 void GenCollectedHeap::do_collection(bool full, | |
352 bool clear_all_soft_refs, | |
353 size_t size, | |
354 bool is_tlab, | |
355 int max_level) { | |
356 bool prepared_for_verification = false; | |
357 ResourceMark rm; | |
358 DEBUG_ONLY(Thread* my_thread = Thread::current();) | |
359 | |
360 assert(SafepointSynchronize::is_at_safepoint(), "should be at safepoint"); | |
361 assert(my_thread->is_VM_thread() || | |
362 my_thread->is_ConcurrentGC_thread(), | |
363 "incorrect thread type capability"); | |
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1170
diff
changeset
|
364 assert(Heap_lock->is_locked(), |
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1170
diff
changeset
|
365 "the requesting thread should have the Heap_lock"); |
0 | 366 guarantee(!is_gc_active(), "collection is not reentrant"); |
367 assert(max_level < n_gens(), "sanity check"); | |
368 | |
369 if (GC_locker::check_active_before_gc()) { | |
370 return; // GC is disabled (e.g. JNI GetXXXCritical operation) | |
371 } | |
372 | |
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1170
diff
changeset
|
373 const bool do_clear_all_soft_refs = clear_all_soft_refs || |
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1170
diff
changeset
|
374 collector_policy()->should_clear_all_soft_refs(); |
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1170
diff
changeset
|
375 |
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1170
diff
changeset
|
376 ClearedAllSoftRefs casr(do_clear_all_soft_refs, collector_policy()); |
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1170
diff
changeset
|
377 |
17866
270d7cb38f40
8038934: Remove prefix allocated_ from methods and variables in Metaspace
ehelin
parents:
17727
diff
changeset
|
378 const size_t metadata_prev_used = MetaspaceAux::used_bytes(); |
0 | 379 |
4872
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4728
diff
changeset
|
380 print_heap_before_gc(); |
0 | 381 |
382 { | |
383 FlagSetting fl(_is_gc_active, true); | |
384 | |
385 bool complete = full && (max_level == (n_gens()-1)); | |
6064
9d679effd28c
7166894: Add gc cause to GC logging for all collectors
brutisso
parents:
6008
diff
changeset
|
386 const char* gc_cause_prefix = complete ? "Full GC" : "GC"; |
0 | 387 gclog_or_tty->date_stamp(PrintGC && PrintGCDateStamps); |
388 TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty); | |
20190
0982ec23da03
8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents:
17937
diff
changeset
|
389 // The PrintGCDetails logging starts before we have incremented the GC id. We will do that later |
0982ec23da03
8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents:
17937
diff
changeset
|
390 // so we can assume here that the next GC id is what we want. |
0982ec23da03
8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents:
17937
diff
changeset
|
391 GCTraceTime t(GCCauseString(gc_cause_prefix, gc_cause()), PrintGCDetails, false, NULL, GCId::peek()); |
0 | 392 |
393 gc_prologue(complete); | |
394 increment_total_collections(complete); | |
395 | |
396 size_t gch_prev_used = used(); | |
397 | |
398 int starting_level = 0; | |
399 if (full) { | |
400 // Search for the oldest generation which will collect all younger | |
401 // generations, and start collection loop there. | |
402 for (int i = max_level; i >= 0; i--) { | |
403 if (_gens[i]->full_collects_younger_generations()) { | |
404 starting_level = i; | |
405 break; | |
406 } | |
407 } | |
408 } | |
409 | |
410 bool must_restore_marks_for_biased_locking = false; | |
411 | |
412 int max_level_collected = starting_level; | |
413 for (int i = starting_level; i <= max_level; i++) { | |
414 if (_gens[i]->should_collect(full, size, is_tlab)) { | |
880
2b4230d1e589
6862295: JDWP threadid changes during debugging session (leading to ingored breakpoints)
dcubed
parents:
457
diff
changeset
|
415 if (i == n_gens() - 1) { // a major collection is to happen |
2b4230d1e589
6862295: JDWP threadid changes during debugging session (leading to ingored breakpoints)
dcubed
parents:
457
diff
changeset
|
416 if (!complete) { |
2b4230d1e589
6862295: JDWP threadid changes during debugging session (leading to ingored breakpoints)
dcubed
parents:
457
diff
changeset
|
417 // The full_collections increment was missed above. |
2b4230d1e589
6862295: JDWP threadid changes during debugging session (leading to ingored breakpoints)
dcubed
parents:
457
diff
changeset
|
418 increment_total_full_collections(); |
2b4230d1e589
6862295: JDWP threadid changes during debugging session (leading to ingored breakpoints)
dcubed
parents:
457
diff
changeset
|
419 } |
10405 | 420 pre_full_gc_dump(NULL); // do any pre full gc dumps |
880
2b4230d1e589
6862295: JDWP threadid changes during debugging session (leading to ingored breakpoints)
dcubed
parents:
457
diff
changeset
|
421 } |
0 | 422 // Timer for individual generations. Last argument is false: no CR |
10405 | 423 // FIXME: We should try to start the timing earlier to cover more of the GC pause |
20190
0982ec23da03
8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents:
17937
diff
changeset
|
424 // The PrintGCDetails logging starts before we have incremented the GC id. We will do that later |
0982ec23da03
8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents:
17937
diff
changeset
|
425 // so we can assume here that the next GC id is what we want. |
0982ec23da03
8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents:
17937
diff
changeset
|
426 GCTraceTime t1(_gens[i]->short_name(), PrintGCDetails, false, NULL, GCId::peek()); |
0 | 427 TraceCollectorStats tcs(_gens[i]->counters()); |
3356
78542e2b5e35
7036199: Adding a notification to the implementation of GarbageCollectorMXBeans
fparain
parents:
2426
diff
changeset
|
428 TraceMemoryManagerStats tmms(_gens[i]->kind(),gc_cause()); |
0 | 429 |
430 size_t prev_used = _gens[i]->used(); | |
431 _gens[i]->stat_record()->invocations++; | |
432 _gens[i]->stat_record()->accumulated_time.start(); | |
433 | |
263
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
434 // Must be done anew before each collection because |
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
435 // a previous collection will do mangling and will |
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
436 // change top of some spaces. |
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
437 record_gen_tops_before_GC(); |
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
438 |
0 | 439 if (PrintGC && Verbose) { |
440 gclog_or_tty->print("level=%d invoke=%d size=" SIZE_FORMAT, | |
441 i, | |
442 _gens[i]->stat_record()->invocations, | |
443 size*HeapWordSize); | |
444 } | |
445 | |
446 if (VerifyBeforeGC && i >= VerifyGCLevel && | |
447 total_collections() >= VerifyGCStartAt) { | |
448 HandleMark hm; // Discard invalid handles created during verification | |
449 if (!prepared_for_verification) { | |
450 prepare_for_verify(); | |
451 prepared_for_verification = true; | |
452 } | |
10186
b06ac540229e
8013132: Add a flag to turn off the output of the verbose verification code
stefank
parents:
10183
diff
changeset
|
453 Universe::verify(" VerifyBeforeGC:"); |
0 | 454 } |
455 COMPILER2_PRESENT(DerivedPointerTable::clear()); | |
456 | |
457 if (!must_restore_marks_for_biased_locking && | |
458 _gens[i]->performs_in_place_marking()) { | |
459 // We perform this mark word preservation work lazily | |
460 // because it's only at this point that we know whether we | |
461 // absolutely have to do it; we want to avoid doing it for | |
462 // scavenge-only collections where it's unnecessary | |
463 must_restore_marks_for_biased_locking = true; | |
464 BiasedLocking::preserve_marks(); | |
465 } | |
466 | |
467 // Do collection work | |
468 { | |
469 // Note on ref discovery: For what appear to be historical reasons, | |
470 // GCH enables and disabled (by enqueing) refs discovery. | |
471 // In the future this should be moved into the generation's | |
472 // collect method so that ref discovery and enqueueing concerns | |
473 // are local to a generation. The collect method could return | |
474 // an appropriate indication in the case that notification on | |
475 // the ref lock was needed. This will make the treatment of | |
476 // weak refs more uniform (and indeed remove such concerns | |
477 // from GCH). XXX | |
478 | |
479 HandleMark hm; // Discard invalid handles created during gc | |
480 save_marks(); // save marks for all gens | |
481 // We want to discover references, but not process them yet. | |
482 // This mode is disabled in process_discovered_references if the | |
483 // generation does some collection work, or in | |
484 // enqueue_discovered_references if the generation returns | |
485 // without doing any work. | |
486 ReferenceProcessor* rp = _gens[i]->ref_processor(); | |
487 // If the discovery of ("weak") refs in this generation is | |
488 // atomic wrt other collectors in this configuration, we | |
489 // are guaranteed to have empty discovered ref lists. | |
490 if (rp->discovery_is_atomic()) { | |
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3915
diff
changeset
|
491 rp->enable_discovery(true /*verify_disabled*/, true /*verify_no_refs*/); |
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1170
diff
changeset
|
492 rp->setup_policy(do_clear_all_soft_refs); |
0 | 493 } else { |
453
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
269
diff
changeset
|
494 // collect() below will enable discovery as appropriate |
0 | 495 } |
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1170
diff
changeset
|
496 _gens[i]->collect(full, do_clear_all_soft_refs, size, is_tlab); |
0 | 497 if (!rp->enqueuing_is_done()) { |
498 rp->enqueue_discovered_references(); | |
499 } else { | |
500 rp->set_enqueuing_is_done(false); | |
501 } | |
502 rp->verify_no_references_recorded(); | |
503 } | |
504 max_level_collected = i; | |
505 | |
506 // Determine if allocation request was met. | |
507 if (size > 0) { | |
508 if (!is_tlab || _gens[i]->supports_tlab_allocation()) { | |
509 if (size*HeapWordSize <= _gens[i]->unsafe_max_alloc_nogc()) { | |
510 size = 0; | |
511 } | |
512 } | |
513 } | |
514 | |
515 COMPILER2_PRESENT(DerivedPointerTable::update_pointers()); | |
516 | |
517 _gens[i]->stat_record()->accumulated_time.stop(); | |
518 | |
519 update_gc_stats(i, full); | |
520 | |
521 if (VerifyAfterGC && i >= VerifyGCLevel && | |
522 total_collections() >= VerifyGCStartAt) { | |
523 HandleMark hm; // Discard invalid handles created during verification | |
10186
b06ac540229e
8013132: Add a flag to turn off the output of the verbose verification code
stefank
parents:
10183
diff
changeset
|
524 Universe::verify(" VerifyAfterGC:"); |
0 | 525 } |
526 | |
527 if (PrintGCDetails) { | |
528 gclog_or_tty->print(":"); | |
529 _gens[i]->print_heap_change(prev_used); | |
530 } | |
531 } | |
532 } | |
533 | |
534 // Update "complete" boolean wrt what actually transpired -- | |
535 // for instance, a promotion failure could have led to | |
536 // a whole heap collection. | |
537 complete = complete || (max_level_collected == n_gens() - 1); | |
538 | |
615
c6c601a0f2d6
6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents:
546
diff
changeset
|
539 if (complete) { // We did a "major" collection |
10405 | 540 // FIXME: See comment at pre_full_gc_dump call |
541 post_full_gc_dump(NULL); // do any post full gc dumps | |
615
c6c601a0f2d6
6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents:
546
diff
changeset
|
542 } |
c6c601a0f2d6
6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents:
546
diff
changeset
|
543 |
0 | 544 if (PrintGCDetails) { |
545 print_heap_change(gch_prev_used); | |
546 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6109
diff
changeset
|
547 // Print metaspace info for full GC with PrintGCDetails flag. |
0 | 548 if (complete) { |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6109
diff
changeset
|
549 MetaspaceAux::print_metaspace_change(metadata_prev_used); |
0 | 550 } |
551 } | |
552 | |
553 for (int j = max_level_collected; j >= 0; j -= 1) { | |
554 // Adjust generation sizes. | |
555 _gens[j]->compute_new_size(); | |
556 } | |
557 | |
558 if (complete) { | |
8784
79af1312fc2c
8005602: NPG: classunloading does not happen while CMS GC with -XX:+CMSClassUnloadingEnabled is used
mgerdin
parents:
8001
diff
changeset
|
559 // Delete metaspaces for unloaded class loaders and clean up loader_data graph |
79af1312fc2c
8005602: NPG: classunloading does not happen while CMS GC with -XX:+CMSClassUnloadingEnabled is used
mgerdin
parents:
8001
diff
changeset
|
560 ClassLoaderDataGraph::purge(); |
10183
868d87ed63c8
8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions
jmasa
parents:
10179
diff
changeset
|
561 MetaspaceAux::verify_metrics(); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6109
diff
changeset
|
562 // Resize the metaspace capacity after full collections |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6109
diff
changeset
|
563 MetaspaceGC::compute_new_size(); |
0 | 564 update_full_collections_completed(); |
565 } | |
566 | |
567 // Track memory usage and detect low memory after GC finishes | |
568 MemoryService::track_memory_usage(); | |
569 | |
570 gc_epilogue(complete); | |
571 | |
572 if (must_restore_marks_for_biased_locking) { | |
573 BiasedLocking::restore_marks(); | |
574 } | |
575 } | |
576 | |
577 AdaptiveSizePolicy* sp = gen_policy()->size_policy(); | |
578 AdaptiveSizePolicyOutput(sp, total_collections()); | |
579 | |
4872
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4728
diff
changeset
|
580 print_heap_after_gc(); |
0 | 581 |
546
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
517
diff
changeset
|
582 #ifdef TRACESPINNING |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
517
diff
changeset
|
583 ParallelTaskTerminator::print_termination_counts(); |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
517
diff
changeset
|
584 #endif |
0 | 585 } |
586 | |
587 HeapWord* GenCollectedHeap::satisfy_failed_allocation(size_t size, bool is_tlab) { | |
588 return collector_policy()->satisfy_failed_allocation(size, is_tlab); | |
589 } | |
590 | |
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4712
diff
changeset
|
591 void GenCollectedHeap::set_par_threads(uint t) { |
0 | 592 SharedHeap::set_par_threads(t); |
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
593 _gen_process_roots_tasks->set_n_threads(t); |
0 | 594 } |
595 | |
596 void GenCollectedHeap:: | |
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
597 gen_process_roots(int level, |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
598 bool younger_gens_as_roots, |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
599 bool activate_scope, |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
600 SharedHeap::ScanningOption so, |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
601 OopsInGenClosure* not_older_gens, |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
602 OopsInGenClosure* weak_roots, |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
603 OopsInGenClosure* older_gens, |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
604 CLDClosure* cld_closure, |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
605 CLDClosure* weak_cld_closure, |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
606 CodeBlobClosure* code_closure) { |
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
881
diff
changeset
|
607 |
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
608 // General roots. |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
609 SharedHeap::process_roots(activate_scope, so, |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
610 not_older_gens, weak_roots, |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
611 cld_closure, weak_cld_closure, |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
612 code_closure); |
0 | 613 |
614 if (younger_gens_as_roots) { | |
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
615 if (!_gen_process_roots_tasks->is_task_claimed(GCH_PS_younger_gens)) { |
0 | 616 for (int i = 0; i < level; i++) { |
617 not_older_gens->set_generation(_gens[i]); | |
618 _gens[i]->oop_iterate(not_older_gens); | |
619 } | |
620 not_older_gens->reset_generation(); | |
621 } | |
622 } | |
623 // When collection is parallel, all threads get to cooperate to do | |
624 // older-gen scanning. | |
625 for (int i = level+1; i < _n_gens; i++) { | |
626 older_gens->set_generation(_gens[i]); | |
627 rem_set()->younger_refs_iterate(_gens[i], older_gens); | |
628 older_gens->reset_generation(); | |
629 } | |
630 | |
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
631 _gen_process_roots_tasks->all_tasks_completed(); |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
632 } |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
633 |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
634 void GenCollectedHeap:: |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
635 gen_process_roots(int level, |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
636 bool younger_gens_as_roots, |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
637 bool activate_scope, |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
638 SharedHeap::ScanningOption so, |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
639 bool only_strong_roots, |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
640 OopsInGenClosure* not_older_gens, |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
641 OopsInGenClosure* older_gens, |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
642 CLDClosure* cld_closure) { |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
643 |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
644 const bool is_adjust_phase = !only_strong_roots && !younger_gens_as_roots; |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
645 |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
646 bool is_moving_collection = false; |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
647 if (level == 0 || is_adjust_phase) { |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
648 // young collections are always moving |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
649 is_moving_collection = true; |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
650 } |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
651 |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
652 MarkingCodeBlobClosure mark_code_closure(not_older_gens, is_moving_collection); |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
653 CodeBlobClosure* code_closure = &mark_code_closure; |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
654 |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
655 gen_process_roots(level, |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
656 younger_gens_as_roots, |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
657 activate_scope, so, |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
658 not_older_gens, only_strong_roots ? NULL : not_older_gens, |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
659 older_gens, |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
660 cld_closure, only_strong_roots ? NULL : cld_closure, |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
661 code_closure); |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
662 |
0 | 663 } |
664 | |
20257
7426d8d76305
8034761: Remove the do_code_roots parameter from process_strong_roots
stefank
parents:
20254
diff
changeset
|
665 void GenCollectedHeap::gen_process_weak_roots(OopClosure* root_closure) { |
7426d8d76305
8034761: Remove the do_code_roots parameter from process_strong_roots
stefank
parents:
20254
diff
changeset
|
666 SharedHeap::process_weak_roots(root_closure); |
0 | 667 // "Local" "weak" refs |
668 for (int i = 0; i < _n_gens; i++) { | |
669 _gens[i]->ref_processor()->weak_oops_do(root_closure); | |
670 } | |
671 } | |
672 | |
673 #define GCH_SINCE_SAVE_MARKS_ITERATE_DEFN(OopClosureType, nv_suffix) \ | |
674 void GenCollectedHeap:: \ | |
675 oop_since_save_marks_iterate(int level, \ | |
676 OopClosureType* cur, \ | |
677 OopClosureType* older) { \ | |
678 _gens[level]->oop_since_save_marks_iterate##nv_suffix(cur); \ | |
679 for (int i = level+1; i < n_gens(); i++) { \ | |
680 _gens[i]->oop_since_save_marks_iterate##nv_suffix(older); \ | |
681 } \ | |
682 } | |
683 | |
684 ALL_SINCE_SAVE_MARKS_CLOSURES(GCH_SINCE_SAVE_MARKS_ITERATE_DEFN) | |
685 | |
686 #undef GCH_SINCE_SAVE_MARKS_ITERATE_DEFN | |
687 | |
688 bool GenCollectedHeap::no_allocs_since_save_marks(int level) { | |
689 for (int i = level; i < _n_gens; i++) { | |
690 if (!_gens[i]->no_allocs_since_save_marks()) return false; | |
691 } | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6109
diff
changeset
|
692 return true; |
0 | 693 } |
694 | |
695 bool GenCollectedHeap::supports_inline_contig_alloc() const { | |
696 return _gens[0]->supports_inline_contig_alloc(); | |
697 } | |
698 | |
699 HeapWord** GenCollectedHeap::top_addr() const { | |
700 return _gens[0]->top_addr(); | |
701 } | |
702 | |
703 HeapWord** GenCollectedHeap::end_addr() const { | |
704 return _gens[0]->end_addr(); | |
705 } | |
706 | |
707 size_t GenCollectedHeap::unsafe_max_alloc() { | |
708 return _gens[0]->unsafe_max_alloc_nogc(); | |
709 } | |
710 | |
711 // public collection interfaces | |
712 | |
713 void GenCollectedHeap::collect(GCCause::Cause cause) { | |
714 if (should_do_concurrent_full_gc(cause)) { | |
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6865
diff
changeset
|
715 #if INCLUDE_ALL_GCS |
0 | 716 // mostly concurrent full collection |
717 collect_mostly_concurrent(cause); | |
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6865
diff
changeset
|
718 #else // INCLUDE_ALL_GCS |
0 | 719 ShouldNotReachHere(); |
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6865
diff
changeset
|
720 #endif // INCLUDE_ALL_GCS |
0 | 721 } else { |
722 #ifdef ASSERT | |
723 if (cause == GCCause::_scavenge_alot) { | |
724 // minor collection only | |
725 collect(cause, 0); | |
726 } else { | |
727 // Stop-the-world full collection | |
728 collect(cause, n_gens() - 1); | |
729 } | |
730 #else | |
731 // Stop-the-world full collection | |
732 collect(cause, n_gens() - 1); | |
733 #endif | |
734 } | |
735 } | |
736 | |
737 void GenCollectedHeap::collect(GCCause::Cause cause, int max_level) { | |
738 // The caller doesn't have the Heap_lock | |
739 assert(!Heap_lock->owned_by_self(), "this thread should not own the Heap_lock"); | |
740 MutexLocker ml(Heap_lock); | |
741 collect_locked(cause, max_level); | |
742 } | |
743 | |
744 void GenCollectedHeap::collect_locked(GCCause::Cause cause) { | |
745 // The caller has the Heap_lock | |
746 assert(Heap_lock->owned_by_self(), "this thread should own the Heap_lock"); | |
747 collect_locked(cause, n_gens() - 1); | |
748 } | |
749 | |
750 // this is the private collection interface | |
751 // The Heap_lock is expected to be held on entry. | |
752 | |
753 void GenCollectedHeap::collect_locked(GCCause::Cause cause, int max_level) { | |
754 // Read the GC count while holding the Heap_lock | |
755 unsigned int gc_count_before = total_collections(); | |
756 unsigned int full_gc_count_before = total_full_collections(); | |
757 { | |
758 MutexUnlocker mu(Heap_lock); // give up heap lock, execute gets it back | |
759 VM_GenCollectFull op(gc_count_before, full_gc_count_before, | |
760 cause, max_level); | |
761 VMThread::execute(&op); | |
762 } | |
763 } | |
764 | |
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6865
diff
changeset
|
765 #if INCLUDE_ALL_GCS |
0 | 766 bool GenCollectedHeap::create_cms_collector() { |
767 | |
768 assert(((_gens[1]->kind() == Generation::ConcurrentMarkSweep) || | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6109
diff
changeset
|
769 (_gens[1]->kind() == Generation::ASConcurrentMarkSweep)), |
0 | 770 "Unexpected generation kinds"); |
771 // Skip two header words in the block content verification | |
772 NOT_PRODUCT(_skip_header_HeapWords = CMSCollector::skip_header_HeapWords();) | |
773 CMSCollector* collector = new CMSCollector( | |
774 (ConcurrentMarkSweepGeneration*)_gens[1], | |
775 _rem_set->as_CardTableRS(), | |
776 (ConcurrentMarkSweepPolicy*) collector_policy()); | |
777 | |
778 if (collector == NULL || !collector->completed_initialization()) { | |
779 if (collector) { | |
780 delete collector; // Be nice in embedded situation | |
781 } | |
782 vm_shutdown_during_initialization("Could not create CMS collector"); | |
783 return false; | |
784 } | |
785 return true; // success | |
786 } | |
787 | |
788 void GenCollectedHeap::collect_mostly_concurrent(GCCause::Cause cause) { | |
789 assert(!Heap_lock->owned_by_self(), "Should not own Heap_lock"); | |
790 | |
791 MutexLocker ml(Heap_lock); | |
792 // Read the GC counts while holding the Heap_lock | |
793 unsigned int full_gc_count_before = total_full_collections(); | |
794 unsigned int gc_count_before = total_collections(); | |
795 { | |
796 MutexUnlocker mu(Heap_lock); | |
797 VM_GenCollectFullConcurrent op(gc_count_before, full_gc_count_before, cause); | |
798 VMThread::execute(&op); | |
799 } | |
800 } | |
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6865
diff
changeset
|
801 #endif // INCLUDE_ALL_GCS |
0 | 802 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6109
diff
changeset
|
803 void GenCollectedHeap::do_full_collection(bool clear_all_soft_refs) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6109
diff
changeset
|
804 do_full_collection(clear_all_soft_refs, _n_gens - 1); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6109
diff
changeset
|
805 } |
0 | 806 |
807 void GenCollectedHeap::do_full_collection(bool clear_all_soft_refs, | |
808 int max_level) { | |
809 int local_max_level; | |
1994
6cd6d394f280
7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed())
ysr
parents:
1972
diff
changeset
|
810 if (!incremental_collection_will_fail(false /* don't consult_young */) && |
0 | 811 gc_cause() == GCCause::_gc_locker) { |
812 local_max_level = 0; | |
813 } else { | |
814 local_max_level = max_level; | |
815 } | |
816 | |
817 do_collection(true /* full */, | |
818 clear_all_soft_refs /* clear_all_soft_refs */, | |
819 0 /* size */, | |
820 false /* is_tlab */, | |
821 local_max_level /* max_level */); | |
822 // Hack XXX FIX ME !!! | |
823 // A scavenge may not have been attempted, or may have | |
824 // been attempted and failed, because the old gen was too full | |
825 if (local_max_level == 0 && gc_cause() == GCCause::_gc_locker && | |
1994
6cd6d394f280
7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed())
ysr
parents:
1972
diff
changeset
|
826 incremental_collection_will_fail(false /* don't consult_young */)) { |
0 | 827 if (PrintGCDetails) { |
828 gclog_or_tty->print_cr("GC locker: Trying a full collection " | |
829 "because scavenge failed"); | |
830 } | |
831 // This time allow the old gen to be collected as well | |
832 do_collection(true /* full */, | |
833 clear_all_soft_refs /* clear_all_soft_refs */, | |
834 0 /* size */, | |
835 false /* is_tlab */, | |
836 n_gens() - 1 /* max_level */); | |
837 } | |
838 } | |
839 | |
3377
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
840 bool GenCollectedHeap::is_in_young(oop p) { |
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
841 bool result = ((HeapWord*)p) < _gens[_n_gens - 1]->reserved().start(); |
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
842 assert(result == _gens[0]->is_in_reserved(p), |
17937
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17866
diff
changeset
|
843 err_msg("incorrect test - result=%d, p=" PTR_FORMAT, result, p2i((void*)p))); |
3377
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
844 return result; |
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
845 } |
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
846 |
4708 | 847 // Returns "TRUE" iff "p" points into the committed areas of the heap. |
0 | 848 bool GenCollectedHeap::is_in(const void* p) const { |
849 #ifndef ASSERT | |
9071
68fe50d4f1d5
8011343: Add new flag for verifying the heap during startup
johnc
parents:
8784
diff
changeset
|
850 guarantee(VerifyBeforeGC || |
68fe50d4f1d5
8011343: Add new flag for verifying the heap during startup
johnc
parents:
8784
diff
changeset
|
851 VerifyDuringGC || |
68fe50d4f1d5
8011343: Add new flag for verifying the heap during startup
johnc
parents:
8784
diff
changeset
|
852 VerifyBeforeExit || |
68fe50d4f1d5
8011343: Add new flag for verifying the heap during startup
johnc
parents:
8784
diff
changeset
|
853 VerifyDuringStartup || |
68fe50d4f1d5
8011343: Add new flag for verifying the heap during startup
johnc
parents:
8784
diff
changeset
|
854 PrintAssembly || |
68fe50d4f1d5
8011343: Add new flag for verifying the heap during startup
johnc
parents:
8784
diff
changeset
|
855 tty->count() != 0 || // already printing |
68fe50d4f1d5
8011343: Add new flag for verifying the heap during startup
johnc
parents:
8784
diff
changeset
|
856 VerifyAfterGC || |
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1626
diff
changeset
|
857 VMError::fatal_error_in_progress(), "too expensive"); |
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1626
diff
changeset
|
858 |
0 | 859 #endif |
860 // This might be sped up with a cache of the last generation that | |
861 // answered yes. | |
862 for (int i = 0; i < _n_gens; i++) { | |
863 if (_gens[i]->is_in(p)) return true; | |
864 } | |
865 // Otherwise... | |
866 return false; | |
867 } | |
868 | |
3377
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
869 #ifdef ASSERT |
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
870 // Don't implement this by using is_in_young(). This method is used |
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
871 // in some cases to check that is_in_young() is correct. |
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
872 bool GenCollectedHeap::is_in_partial_collection(const void* p) { |
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
873 assert(is_in_reserved(p) || p == NULL, |
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
874 "Does not work if address is non-null and outside of the heap"); |
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
875 return p < _gens[_n_gens - 2]->reserved().end() && p != NULL; |
0 | 876 } |
3377
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
877 #endif |
0 | 878 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6109
diff
changeset
|
879 void GenCollectedHeap::oop_iterate(ExtendedOopClosure* cl) { |
0 | 880 for (int i = 0; i < _n_gens; i++) { |
881 _gens[i]->oop_iterate(cl); | |
882 } | |
883 } | |
884 | |
885 void GenCollectedHeap::object_iterate(ObjectClosure* cl) { | |
886 for (int i = 0; i < _n_gens; i++) { | |
887 _gens[i]->object_iterate(cl); | |
888 } | |
889 } | |
890 | |
517
e9be0e04635a
6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents:
457
diff
changeset
|
891 void GenCollectedHeap::safe_object_iterate(ObjectClosure* cl) { |
e9be0e04635a
6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents:
457
diff
changeset
|
892 for (int i = 0; i < _n_gens; i++) { |
e9be0e04635a
6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents:
457
diff
changeset
|
893 _gens[i]->safe_object_iterate(cl); |
e9be0e04635a
6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents:
457
diff
changeset
|
894 } |
e9be0e04635a
6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents:
457
diff
changeset
|
895 } |
e9be0e04635a
6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents:
457
diff
changeset
|
896 |
0 | 897 Space* GenCollectedHeap::space_containing(const void* addr) const { |
898 for (int i = 0; i < _n_gens; i++) { | |
899 Space* res = _gens[i]->space_containing(addr); | |
900 if (res != NULL) return res; | |
901 } | |
902 // Otherwise... | |
903 assert(false, "Could not find containing space"); | |
904 return NULL; | |
905 } | |
906 | |
907 | |
908 HeapWord* GenCollectedHeap::block_start(const void* addr) const { | |
909 assert(is_in_reserved(addr), "block_start of address outside of heap"); | |
910 for (int i = 0; i < _n_gens; i++) { | |
911 if (_gens[i]->is_in_reserved(addr)) { | |
912 assert(_gens[i]->is_in(addr), | |
913 "addr should be in allocated part of generation"); | |
914 return _gens[i]->block_start(addr); | |
915 } | |
916 } | |
917 assert(false, "Some generation should contain the address"); | |
918 return NULL; | |
919 } | |
920 | |
921 size_t GenCollectedHeap::block_size(const HeapWord* addr) const { | |
922 assert(is_in_reserved(addr), "block_size of address outside of heap"); | |
923 for (int i = 0; i < _n_gens; i++) { | |
924 if (_gens[i]->is_in_reserved(addr)) { | |
925 assert(_gens[i]->is_in(addr), | |
926 "addr should be in allocated part of generation"); | |
927 return _gens[i]->block_size(addr); | |
928 } | |
929 } | |
930 assert(false, "Some generation should contain the address"); | |
931 return 0; | |
932 } | |
933 | |
934 bool GenCollectedHeap::block_is_obj(const HeapWord* addr) const { | |
935 assert(is_in_reserved(addr), "block_is_obj of address outside of heap"); | |
936 assert(block_start(addr) == addr, "addr must be a block start"); | |
937 for (int i = 0; i < _n_gens; i++) { | |
938 if (_gens[i]->is_in_reserved(addr)) { | |
939 return _gens[i]->block_is_obj(addr); | |
940 } | |
941 } | |
942 assert(false, "Some generation should contain the address"); | |
943 return false; | |
944 } | |
945 | |
946 bool GenCollectedHeap::supports_tlab_allocation() const { | |
947 for (int i = 0; i < _n_gens; i += 1) { | |
948 if (_gens[i]->supports_tlab_allocation()) { | |
949 return true; | |
950 } | |
951 } | |
952 return false; | |
953 } | |
954 | |
955 size_t GenCollectedHeap::tlab_capacity(Thread* thr) const { | |
956 size_t result = 0; | |
957 for (int i = 0; i < _n_gens; i += 1) { | |
958 if (_gens[i]->supports_tlab_allocation()) { | |
959 result += _gens[i]->tlab_capacity(); | |
960 } | |
961 } | |
962 return result; | |
963 } | |
964 | |
17727 | 965 size_t GenCollectedHeap::tlab_used(Thread* thr) const { |
966 size_t result = 0; | |
967 for (int i = 0; i < _n_gens; i += 1) { | |
968 if (_gens[i]->supports_tlab_allocation()) { | |
969 result += _gens[i]->tlab_used(); | |
970 } | |
971 } | |
972 return result; | |
973 } | |
974 | |
0 | 975 size_t GenCollectedHeap::unsafe_max_tlab_alloc(Thread* thr) const { |
976 size_t result = 0; | |
977 for (int i = 0; i < _n_gens; i += 1) { | |
978 if (_gens[i]->supports_tlab_allocation()) { | |
979 result += _gens[i]->unsafe_max_tlab_alloc(); | |
980 } | |
981 } | |
982 return result; | |
983 } | |
984 | |
985 HeapWord* GenCollectedHeap::allocate_new_tlab(size_t size) { | |
986 bool gc_overhead_limit_was_exceeded; | |
3774
c9ca3f51cf41
6994322: Remove the is_tlab and is_noref / is_large_noref parameters from the CollectedHeap
tonyp
parents:
3772
diff
changeset
|
987 return collector_policy()->mem_allocate_work(size /* size */, |
c9ca3f51cf41
6994322: Remove the is_tlab and is_noref / is_large_noref parameters from the CollectedHeap
tonyp
parents:
3772
diff
changeset
|
988 true /* is_tlab */, |
c9ca3f51cf41
6994322: Remove the is_tlab and is_noref / is_large_noref parameters from the CollectedHeap
tonyp
parents:
3772
diff
changeset
|
989 &gc_overhead_limit_was_exceeded); |
0 | 990 } |
991 | |
992 // Requires "*prev_ptr" to be non-NULL. Deletes and a block of minimal size | |
993 // from the list headed by "*prev_ptr". | |
994 static ScratchBlock *removeSmallestScratch(ScratchBlock **prev_ptr) { | |
995 bool first = true; | |
996 size_t min_size = 0; // "first" makes this conceptually infinite. | |
997 ScratchBlock **smallest_ptr, *smallest; | |
998 ScratchBlock *cur = *prev_ptr; | |
999 while (cur) { | |
1000 assert(*prev_ptr == cur, "just checking"); | |
1001 if (first || cur->num_words < min_size) { | |
1002 smallest_ptr = prev_ptr; | |
1003 smallest = cur; | |
1004 min_size = smallest->num_words; | |
1005 first = false; | |
1006 } | |
1007 prev_ptr = &cur->next; | |
1008 cur = cur->next; | |
1009 } | |
1010 smallest = *smallest_ptr; | |
1011 *smallest_ptr = smallest->next; | |
1012 return smallest; | |
1013 } | |
1014 | |
1015 // Sort the scratch block list headed by res into decreasing size order, | |
1016 // and set "res" to the result. | |
1017 static void sort_scratch_list(ScratchBlock*& list) { | |
1018 ScratchBlock* sorted = NULL; | |
1019 ScratchBlock* unsorted = list; | |
1020 while (unsorted) { | |
1021 ScratchBlock *smallest = removeSmallestScratch(&unsorted); | |
1022 smallest->next = sorted; | |
1023 sorted = smallest; | |
1024 } | |
1025 list = sorted; | |
1026 } | |
1027 | |
1028 ScratchBlock* GenCollectedHeap::gather_scratch(Generation* requestor, | |
1029 size_t max_alloc_words) { | |
1030 ScratchBlock* res = NULL; | |
1031 for (int i = 0; i < _n_gens; i++) { | |
1032 _gens[i]->contribute_scratch(res, requestor, max_alloc_words); | |
1033 } | |
1034 sort_scratch_list(res); | |
1035 return res; | |
1036 } | |
1037 | |
263
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
1038 void GenCollectedHeap::release_scratch() { |
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
1039 for (int i = 0; i < _n_gens; i++) { |
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
1040 _gens[i]->reset_scratch(); |
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
1041 } |
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
1042 } |
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
1043 |
0 | 1044 class GenPrepareForVerifyClosure: public GenCollectedHeap::GenClosure { |
1045 void do_generation(Generation* gen) { | |
1046 gen->prepare_for_verify(); | |
1047 } | |
1048 }; | |
1049 | |
1050 void GenCollectedHeap::prepare_for_verify() { | |
1051 ensure_parsability(false); // no need to retire TLABs | |
1052 GenPrepareForVerifyClosure blk; | |
1053 generation_iterate(&blk, false); | |
1054 } | |
1055 | |
1056 | |
1057 void GenCollectedHeap::generation_iterate(GenClosure* cl, | |
1058 bool old_to_young) { | |
1059 if (old_to_young) { | |
1060 for (int i = _n_gens-1; i >= 0; i--) { | |
1061 cl->do_generation(_gens[i]); | |
1062 } | |
1063 } else { | |
1064 for (int i = 0; i < _n_gens; i++) { | |
1065 cl->do_generation(_gens[i]); | |
1066 } | |
1067 } | |
1068 } | |
1069 | |
1070 void GenCollectedHeap::space_iterate(SpaceClosure* cl) { | |
1071 for (int i = 0; i < _n_gens; i++) { | |
1072 _gens[i]->space_iterate(cl, true); | |
1073 } | |
1074 } | |
1075 | |
1076 bool GenCollectedHeap::is_maximal_no_gc() const { | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6109
diff
changeset
|
1077 for (int i = 0; i < _n_gens; i++) { |
0 | 1078 if (!_gens[i]->is_maximal_no_gc()) { |
1079 return false; | |
1080 } | |
1081 } | |
1082 return true; | |
1083 } | |
1084 | |
1085 void GenCollectedHeap::save_marks() { | |
1086 for (int i = 0; i < _n_gens; i++) { | |
1087 _gens[i]->save_marks(); | |
1088 } | |
1089 } | |
1090 | |
1091 GenCollectedHeap* GenCollectedHeap::heap() { | |
1092 assert(_gch != NULL, "Uninitialized access to GenCollectedHeap::heap()"); | |
1093 assert(_gch->kind() == CollectedHeap::GenCollectedHeap, "not a generational heap"); | |
1094 return _gch; | |
1095 } | |
1096 | |
1097 | |
1098 void GenCollectedHeap::prepare_for_compaction() { | |
12030
330dfb0476f4
8022800: Use specific generations rather than generation iteration
brutisso
parents:
11096
diff
changeset
|
1099 guarantee(_n_gens = 2, "Wrong number of generations"); |
330dfb0476f4
8022800: Use specific generations rather than generation iteration
brutisso
parents:
11096
diff
changeset
|
1100 Generation* old_gen = _gens[1]; |
0 | 1101 // Start by compacting into same gen. |
20295
3f2894c5052e
8048112: G1 Full GC needs to support the case when the very first region is not available
tschatzl
parents:
20278
diff
changeset
|
1102 CompactPoint cp(old_gen); |
12030
330dfb0476f4
8022800: Use specific generations rather than generation iteration
brutisso
parents:
11096
diff
changeset
|
1103 old_gen->prepare_for_compaction(&cp); |
330dfb0476f4
8022800: Use specific generations rather than generation iteration
brutisso
parents:
11096
diff
changeset
|
1104 Generation* young_gen = _gens[0]; |
330dfb0476f4
8022800: Use specific generations rather than generation iteration
brutisso
parents:
11096
diff
changeset
|
1105 young_gen->prepare_for_compaction(&cp); |
0 | 1106 } |
1107 | |
1108 GCStats* GenCollectedHeap::gc_stats(int level) const { | |
1109 return _gens[level]->gc_stats(); | |
1110 } | |
1111 | |
6008 | 1112 void GenCollectedHeap::verify(bool silent, VerifyOption option /* ignored */) { |
0 | 1113 for (int i = _n_gens-1; i >= 0; i--) { |
1114 Generation* g = _gens[i]; | |
1115 if (!silent) { | |
17937
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17866
diff
changeset
|
1116 gclog_or_tty->print("%s", g->name()); |
0 | 1117 gclog_or_tty->print(" "); |
1118 } | |
6008 | 1119 g->verify(); |
0 | 1120 } |
1121 if (!silent) { | |
1122 gclog_or_tty->print("remset "); | |
1123 } | |
1124 rem_set()->verify(); | |
1125 } | |
1126 | |
1127 void GenCollectedHeap::print_on(outputStream* st) const { | |
1128 for (int i = 0; i < _n_gens; i++) { | |
1129 _gens[i]->print_on(st); | |
1130 } | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6109
diff
changeset
|
1131 MetaspaceAux::print_on(st); |
0 | 1132 } |
1133 | |
1134 void GenCollectedHeap::gc_threads_do(ThreadClosure* tc) const { | |
1135 if (workers() != NULL) { | |
1136 workers()->threads_do(tc); | |
1137 } | |
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6865
diff
changeset
|
1138 #if INCLUDE_ALL_GCS |
0 | 1139 if (UseConcMarkSweepGC) { |
1140 ConcurrentMarkSweepThread::threads_do(tc); | |
1141 } | |
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6865
diff
changeset
|
1142 #endif // INCLUDE_ALL_GCS |
0 | 1143 } |
1144 | |
1145 void GenCollectedHeap::print_gc_threads_on(outputStream* st) const { | |
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6865
diff
changeset
|
1146 #if INCLUDE_ALL_GCS |
0 | 1147 if (UseParNewGC) { |
1148 workers()->print_worker_threads_on(st); | |
1149 } | |
1150 if (UseConcMarkSweepGC) { | |
1151 ConcurrentMarkSweepThread::print_all_on(st); | |
1152 } | |
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6865
diff
changeset
|
1153 #endif // INCLUDE_ALL_GCS |
0 | 1154 } |
1155 | |
9076
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
9071
diff
changeset
|
1156 void GenCollectedHeap::print_on_error(outputStream* st) const { |
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
9071
diff
changeset
|
1157 this->CollectedHeap::print_on_error(st); |
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
9071
diff
changeset
|
1158 |
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
9071
diff
changeset
|
1159 #if INCLUDE_ALL_GCS |
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
9071
diff
changeset
|
1160 if (UseConcMarkSweepGC) { |
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
9071
diff
changeset
|
1161 st->cr(); |
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
9071
diff
changeset
|
1162 CMSCollector::print_on_error(st); |
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
9071
diff
changeset
|
1163 } |
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
9071
diff
changeset
|
1164 #endif // INCLUDE_ALL_GCS |
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
9071
diff
changeset
|
1165 } |
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
9071
diff
changeset
|
1166 |
0 | 1167 void GenCollectedHeap::print_tracing_info() const { |
1168 if (TraceGen0Time) { | |
1169 get_gen(0)->print_summary_info(); | |
1170 } | |
1171 if (TraceGen1Time) { | |
1172 get_gen(1)->print_summary_info(); | |
1173 } | |
1174 } | |
1175 | |
1176 void GenCollectedHeap::print_heap_change(size_t prev_used) const { | |
1177 if (PrintGCDetails && Verbose) { | |
1178 gclog_or_tty->print(" " SIZE_FORMAT | |
1179 "->" SIZE_FORMAT | |
1180 "(" SIZE_FORMAT ")", | |
1181 prev_used, used(), capacity()); | |
1182 } else { | |
1183 gclog_or_tty->print(" " SIZE_FORMAT "K" | |
1184 "->" SIZE_FORMAT "K" | |
1185 "(" SIZE_FORMAT "K)", | |
1186 prev_used / K, used() / K, capacity() / K); | |
1187 } | |
1188 } | |
1189 | |
1190 class GenGCPrologueClosure: public GenCollectedHeap::GenClosure { | |
1191 private: | |
1192 bool _full; | |
1193 public: | |
1194 void do_generation(Generation* gen) { | |
1195 gen->gc_prologue(_full); | |
1196 } | |
1197 GenGCPrologueClosure(bool full) : _full(full) {}; | |
1198 }; | |
1199 | |
1200 void GenCollectedHeap::gc_prologue(bool full) { | |
1201 assert(InlineCacheBuffer::is_empty(), "should have cleaned up ICBuffer"); | |
1202 | |
1203 always_do_update_barrier = false; | |
1204 // Fill TLAB's and such | |
1205 CollectedHeap::accumulate_statistics_all_tlabs(); | |
1206 ensure_parsability(true); // retire TLABs | |
1207 | |
1208 // Walk generations | |
1209 GenGCPrologueClosure blk(full); | |
1210 generation_iterate(&blk, false); // not old-to-young. | |
1211 }; | |
1212 | |
1213 class GenGCEpilogueClosure: public GenCollectedHeap::GenClosure { | |
1214 private: | |
1215 bool _full; | |
1216 public: | |
1217 void do_generation(Generation* gen) { | |
1218 gen->gc_epilogue(_full); | |
1219 } | |
1220 GenGCEpilogueClosure(bool full) : _full(full) {}; | |
1221 }; | |
1222 | |
1223 void GenCollectedHeap::gc_epilogue(bool full) { | |
1224 #ifdef COMPILER2 | |
1225 assert(DerivedPointerTable::is_empty(), "derived pointer present"); | |
1226 size_t actual_gap = pointer_delta((HeapWord*) (max_uintx-3), *(end_addr())); | |
1227 guarantee(actual_gap > (size_t)FastAllocateSizeLimit, "inline allocation wraps"); | |
1228 #endif /* COMPILER2 */ | |
1229 | |
1230 resize_all_tlabs(); | |
1231 | |
1232 GenGCEpilogueClosure blk(full); | |
1233 generation_iterate(&blk, false); // not old-to-young. | |
1234 | |
3799
48048b59a551
7061204: clean the chunk table synchronously in embedded builds
jcoomes
parents:
3774
diff
changeset
|
1235 if (!CleanChunkPoolAsync) { |
48048b59a551
7061204: clean the chunk table synchronously in embedded builds
jcoomes
parents:
3774
diff
changeset
|
1236 Chunk::clean_chunk_pool(); |
48048b59a551
7061204: clean the chunk table synchronously in embedded builds
jcoomes
parents:
3774
diff
changeset
|
1237 } |
48048b59a551
7061204: clean the chunk table synchronously in embedded builds
jcoomes
parents:
3774
diff
changeset
|
1238 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6109
diff
changeset
|
1239 MetaspaceCounters::update_performance_counters(); |
12063
1a8fb39bdbc4
8014659: NPG: performance counters for compressed klass space
ehelin
parents:
12030
diff
changeset
|
1240 CompressedClassSpaceCounters::update_performance_counters(); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6109
diff
changeset
|
1241 |
0 | 1242 always_do_update_barrier = UseConcMarkSweepGC; |
1243 }; | |
1244 | |
263
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
1245 #ifndef PRODUCT |
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
1246 class GenGCSaveTopsBeforeGCClosure: public GenCollectedHeap::GenClosure { |
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
1247 private: |
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
1248 public: |
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
1249 void do_generation(Generation* gen) { |
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
1250 gen->record_spaces_top(); |
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
1251 } |
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
1252 }; |
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
1253 |
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
1254 void GenCollectedHeap::record_gen_tops_before_GC() { |
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
1255 if (ZapUnusedHeapArea) { |
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
1256 GenGCSaveTopsBeforeGCClosure blk; |
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
1257 generation_iterate(&blk, false); // not old-to-young. |
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
1258 } |
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
1259 } |
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
1260 #endif // not PRODUCT |
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
1261 |
0 | 1262 class GenEnsureParsabilityClosure: public GenCollectedHeap::GenClosure { |
1263 public: | |
1264 void do_generation(Generation* gen) { | |
1265 gen->ensure_parsability(); | |
1266 } | |
1267 }; | |
1268 | |
1269 void GenCollectedHeap::ensure_parsability(bool retire_tlabs) { | |
1270 CollectedHeap::ensure_parsability(retire_tlabs); | |
1271 GenEnsureParsabilityClosure ep_cl; | |
1272 generation_iterate(&ep_cl, false); | |
1273 } | |
1274 | |
12030
330dfb0476f4
8022800: Use specific generations rather than generation iteration
brutisso
parents:
11096
diff
changeset
|
1275 oop GenCollectedHeap::handle_failed_promotion(Generation* old_gen, |
0 | 1276 oop obj, |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
1277 size_t obj_size) { |
12030
330dfb0476f4
8022800: Use specific generations rather than generation iteration
brutisso
parents:
11096
diff
changeset
|
1278 guarantee(old_gen->level() == 1, "We only get here with an old generation"); |
0 | 1279 assert(obj_size == (size_t)obj->size(), "bad obj_size passed in"); |
1280 HeapWord* result = NULL; | |
1281 | |
12030
330dfb0476f4
8022800: Use specific generations rather than generation iteration
brutisso
parents:
11096
diff
changeset
|
1282 result = old_gen->expand_and_allocate(obj_size, false); |
0 | 1283 |
1284 if (result != NULL) { | |
1285 Copy::aligned_disjoint_words((HeapWord*)obj, result, obj_size); | |
1286 } | |
1287 return oop(result); | |
1288 } | |
1289 | |
1290 class GenTimeOfLastGCClosure: public GenCollectedHeap::GenClosure { | |
1291 jlong _time; // in ms | |
1292 jlong _now; // in ms | |
1293 | |
1294 public: | |
1295 GenTimeOfLastGCClosure(jlong now) : _time(now), _now(now) { } | |
1296 | |
1297 jlong time() { return _time; } | |
1298 | |
1299 void do_generation(Generation* gen) { | |
1300 _time = MIN2(_time, gen->time_of_last_gc(_now)); | |
1301 } | |
1302 }; | |
1303 | |
1304 jlong GenCollectedHeap::millis_since_last_gc() { | |
4712
e7dead7e90af
7117303: VM uses non-monotonic time source and complains that it is non-monotonic
johnc
parents:
4708
diff
changeset
|
1305 // We need a monotonically non-deccreasing time in ms but |
e7dead7e90af
7117303: VM uses non-monotonic time source and complains that it is non-monotonic
johnc
parents:
4708
diff
changeset
|
1306 // os::javaTimeMillis() does not guarantee monotonicity. |
e7dead7e90af
7117303: VM uses non-monotonic time source and complains that it is non-monotonic
johnc
parents:
4708
diff
changeset
|
1307 jlong now = os::javaTimeNanos() / NANOSECS_PER_MILLISEC; |
0 | 1308 GenTimeOfLastGCClosure tolgc_cl(now); |
1309 // iterate over generations getting the oldest | |
1310 // time that a generation was collected | |
1311 generation_iterate(&tolgc_cl, false); | |
4712
e7dead7e90af
7117303: VM uses non-monotonic time source and complains that it is non-monotonic
johnc
parents:
4708
diff
changeset
|
1312 |
e7dead7e90af
7117303: VM uses non-monotonic time source and complains that it is non-monotonic
johnc
parents:
4708
diff
changeset
|
1313 // javaTimeNanos() is guaranteed to be monotonically non-decreasing |
e7dead7e90af
7117303: VM uses non-monotonic time source and complains that it is non-monotonic
johnc
parents:
4708
diff
changeset
|
1314 // provided the underlying platform provides such a time source |
e7dead7e90af
7117303: VM uses non-monotonic time source and complains that it is non-monotonic
johnc
parents:
4708
diff
changeset
|
1315 // (and it is bug free). So we still have to guard against getting |
e7dead7e90af
7117303: VM uses non-monotonic time source and complains that it is non-monotonic
johnc
parents:
4708
diff
changeset
|
1316 // back a time later than 'now'. |
0 | 1317 jlong retVal = now - tolgc_cl.time(); |
1318 if (retVal < 0) { | |
17937
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17866
diff
changeset
|
1319 NOT_PRODUCT(warning("time warp: "INT64_FORMAT, (int64_t) retVal);) |
0 | 1320 return 0; |
1321 } | |
1322 return retVal; | |
1323 } |