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