Mercurial > hg > truffle
annotate src/share/vm/memory/genCollectedHeap.cpp @ 20543:e7d0505c8a30
8059758: Footprint regressions with JDK-8038423
Summary: Changes in JDK-8038423 always initialize (zero out) virtual memory used for auxiliary data structures. This causes a footprint regression for G1 in startup benchmarks. This is because they do not touch that memory at all, so the operating system does not actually commit these pages. The fix is to, if the initialization value of the data structures matches the default value of just committed memory (=0), do not do anything.
Reviewed-by: jwilhelm, brutisso
| author | tschatzl |
|---|---|
| date | Fri, 10 Oct 2014 15:51:58 +0200 |
| parents | 4d3a43351904 |
| children | 7848fc12602b |
| 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 // public collection interfaces | |
| 708 | |
| 709 void GenCollectedHeap::collect(GCCause::Cause cause) { | |
| 710 if (should_do_concurrent_full_gc(cause)) { | |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6865
diff
changeset
|
711 #if INCLUDE_ALL_GCS |
| 0 | 712 // mostly concurrent full collection |
| 713 collect_mostly_concurrent(cause); | |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6865
diff
changeset
|
714 #else // INCLUDE_ALL_GCS |
| 0 | 715 ShouldNotReachHere(); |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6865
diff
changeset
|
716 #endif // INCLUDE_ALL_GCS |
|
20357
4bfc44ba0d19
8055098: WB API should be extended to provide information about size and age of object.
tschatzl
parents:
20295
diff
changeset
|
717 } else if (cause == GCCause::_wb_young_gc) { |
|
4bfc44ba0d19
8055098: WB API should be extended to provide information about size and age of object.
tschatzl
parents:
20295
diff
changeset
|
718 // minor collection for WhiteBox API |
|
4bfc44ba0d19
8055098: WB API should be extended to provide information about size and age of object.
tschatzl
parents:
20295
diff
changeset
|
719 collect(cause, 0); |
| 0 | 720 } else { |
| 721 #ifdef ASSERT | |
|
20357
4bfc44ba0d19
8055098: WB API should be extended to provide information about size and age of object.
tschatzl
parents:
20295
diff
changeset
|
722 if (cause == GCCause::_scavenge_alot) { |
|
4bfc44ba0d19
8055098: WB API should be extended to provide information about size and age of object.
tschatzl
parents:
20295
diff
changeset
|
723 // minor collection only |
|
4bfc44ba0d19
8055098: WB API should be extended to provide information about size and age of object.
tschatzl
parents:
20295
diff
changeset
|
724 collect(cause, 0); |
|
4bfc44ba0d19
8055098: WB API should be extended to provide information about size and age of object.
tschatzl
parents:
20295
diff
changeset
|
725 } else { |
|
4bfc44ba0d19
8055098: WB API should be extended to provide information about size and age of object.
tschatzl
parents:
20295
diff
changeset
|
726 // Stop-the-world full collection |
|
4bfc44ba0d19
8055098: WB API should be extended to provide information about size and age of object.
tschatzl
parents:
20295
diff
changeset
|
727 collect(cause, n_gens() - 1); |
|
4bfc44ba0d19
8055098: WB API should be extended to provide information about size and age of object.
tschatzl
parents:
20295
diff
changeset
|
728 } |
| 0 | 729 #else |
| 730 // Stop-the-world full collection | |
| 731 collect(cause, n_gens() - 1); | |
| 732 #endif | |
| 733 } | |
| 734 } | |
| 735 | |
| 736 void GenCollectedHeap::collect(GCCause::Cause cause, int max_level) { | |
| 737 // The caller doesn't have the Heap_lock | |
| 738 assert(!Heap_lock->owned_by_self(), "this thread should not own the Heap_lock"); | |
| 739 MutexLocker ml(Heap_lock); | |
| 740 collect_locked(cause, max_level); | |
| 741 } | |
| 742 | |
| 743 void GenCollectedHeap::collect_locked(GCCause::Cause cause) { | |
| 744 // The caller has the Heap_lock | |
| 745 assert(Heap_lock->owned_by_self(), "this thread should own the Heap_lock"); | |
| 746 collect_locked(cause, n_gens() - 1); | |
| 747 } | |
| 748 | |
| 749 // this is the private collection interface | |
| 750 // The Heap_lock is expected to be held on entry. | |
| 751 | |
| 752 void GenCollectedHeap::collect_locked(GCCause::Cause cause, int max_level) { | |
| 753 // Read the GC count while holding the Heap_lock | |
| 754 unsigned int gc_count_before = total_collections(); | |
| 755 unsigned int full_gc_count_before = total_full_collections(); | |
| 756 { | |
| 757 MutexUnlocker mu(Heap_lock); // give up heap lock, execute gets it back | |
| 758 VM_GenCollectFull op(gc_count_before, full_gc_count_before, | |
| 759 cause, max_level); | |
| 760 VMThread::execute(&op); | |
| 761 } | |
| 762 } | |
| 763 | |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6865
diff
changeset
|
764 #if INCLUDE_ALL_GCS |
| 0 | 765 bool GenCollectedHeap::create_cms_collector() { |
| 766 | |
| 767 assert(((_gens[1]->kind() == Generation::ConcurrentMarkSweep) || | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6109
diff
changeset
|
768 (_gens[1]->kind() == Generation::ASConcurrentMarkSweep)), |
| 0 | 769 "Unexpected generation kinds"); |
| 770 // Skip two header words in the block content verification | |
| 771 NOT_PRODUCT(_skip_header_HeapWords = CMSCollector::skip_header_HeapWords();) | |
| 772 CMSCollector* collector = new CMSCollector( | |
| 773 (ConcurrentMarkSweepGeneration*)_gens[1], | |
| 774 _rem_set->as_CardTableRS(), | |
| 775 (ConcurrentMarkSweepPolicy*) collector_policy()); | |
| 776 | |
| 777 if (collector == NULL || !collector->completed_initialization()) { | |
| 778 if (collector) { | |
| 779 delete collector; // Be nice in embedded situation | |
| 780 } | |
| 781 vm_shutdown_during_initialization("Could not create CMS collector"); | |
| 782 return false; | |
| 783 } | |
| 784 return true; // success | |
| 785 } | |
| 786 | |
| 787 void GenCollectedHeap::collect_mostly_concurrent(GCCause::Cause cause) { | |
| 788 assert(!Heap_lock->owned_by_self(), "Should not own Heap_lock"); | |
| 789 | |
| 790 MutexLocker ml(Heap_lock); | |
| 791 // Read the GC counts while holding the Heap_lock | |
| 792 unsigned int full_gc_count_before = total_full_collections(); | |
| 793 unsigned int gc_count_before = total_collections(); | |
| 794 { | |
| 795 MutexUnlocker mu(Heap_lock); | |
| 796 VM_GenCollectFullConcurrent op(gc_count_before, full_gc_count_before, cause); | |
| 797 VMThread::execute(&op); | |
| 798 } | |
| 799 } | |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6865
diff
changeset
|
800 #endif // INCLUDE_ALL_GCS |
| 0 | 801 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6109
diff
changeset
|
802 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
|
803 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
|
804 } |
| 0 | 805 |
| 806 void GenCollectedHeap::do_full_collection(bool clear_all_soft_refs, | |
| 807 int max_level) { | |
| 808 int local_max_level; | |
|
1994
6cd6d394f280
7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed())
ysr
parents:
1972
diff
changeset
|
809 if (!incremental_collection_will_fail(false /* don't consult_young */) && |
| 0 | 810 gc_cause() == GCCause::_gc_locker) { |
| 811 local_max_level = 0; | |
| 812 } else { | |
| 813 local_max_level = max_level; | |
| 814 } | |
| 815 | |
| 816 do_collection(true /* full */, | |
| 817 clear_all_soft_refs /* clear_all_soft_refs */, | |
| 818 0 /* size */, | |
| 819 false /* is_tlab */, | |
| 820 local_max_level /* max_level */); | |
| 821 // Hack XXX FIX ME !!! | |
| 822 // A scavenge may not have been attempted, or may have | |
| 823 // been attempted and failed, because the old gen was too full | |
| 824 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
|
825 incremental_collection_will_fail(false /* don't consult_young */)) { |
| 0 | 826 if (PrintGCDetails) { |
| 827 gclog_or_tty->print_cr("GC locker: Trying a full collection " | |
| 828 "because scavenge failed"); | |
| 829 } | |
| 830 // This time allow the old gen to be collected as well | |
| 831 do_collection(true /* full */, | |
| 832 clear_all_soft_refs /* clear_all_soft_refs */, | |
| 833 0 /* size */, | |
| 834 false /* is_tlab */, | |
| 835 n_gens() - 1 /* max_level */); | |
| 836 } | |
| 837 } | |
| 838 | |
|
3377
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
839 bool GenCollectedHeap::is_in_young(oop p) { |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
840 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
|
841 assert(result == _gens[0]->is_in_reserved(p), |
|
17937
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17866
diff
changeset
|
842 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
|
843 return result; |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
844 } |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
845 |
| 4708 | 846 // Returns "TRUE" iff "p" points into the committed areas of the heap. |
| 0 | 847 bool GenCollectedHeap::is_in(const void* p) const { |
| 848 #ifndef ASSERT | |
|
9071
68fe50d4f1d5
8011343: Add new flag for verifying the heap during startup
johnc
parents:
8784
diff
changeset
|
849 guarantee(VerifyBeforeGC || |
|
68fe50d4f1d5
8011343: Add new flag for verifying the heap during startup
johnc
parents:
8784
diff
changeset
|
850 VerifyDuringGC || |
|
68fe50d4f1d5
8011343: Add new flag for verifying the heap during startup
johnc
parents:
8784
diff
changeset
|
851 VerifyBeforeExit || |
|
68fe50d4f1d5
8011343: Add new flag for verifying the heap during startup
johnc
parents:
8784
diff
changeset
|
852 VerifyDuringStartup || |
|
68fe50d4f1d5
8011343: Add new flag for verifying the heap during startup
johnc
parents:
8784
diff
changeset
|
853 PrintAssembly || |
|
68fe50d4f1d5
8011343: Add new flag for verifying the heap during startup
johnc
parents:
8784
diff
changeset
|
854 tty->count() != 0 || // already printing |
|
68fe50d4f1d5
8011343: Add new flag for verifying the heap during startup
johnc
parents:
8784
diff
changeset
|
855 VerifyAfterGC || |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1626
diff
changeset
|
856 VMError::fatal_error_in_progress(), "too expensive"); |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1626
diff
changeset
|
857 |
| 0 | 858 #endif |
| 859 // This might be sped up with a cache of the last generation that | |
| 860 // answered yes. | |
| 861 for (int i = 0; i < _n_gens; i++) { | |
| 862 if (_gens[i]->is_in(p)) return true; | |
| 863 } | |
| 864 // Otherwise... | |
| 865 return false; | |
| 866 } | |
| 867 | |
|
3377
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
868 #ifdef ASSERT |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
869 // 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
|
870 // 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
|
871 bool GenCollectedHeap::is_in_partial_collection(const void* p) { |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
872 assert(is_in_reserved(p) || p == NULL, |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
873 "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
|
874 return p < _gens[_n_gens - 2]->reserved().end() && p != NULL; |
| 0 | 875 } |
|
3377
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
876 #endif |
| 0 | 877 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6109
diff
changeset
|
878 void GenCollectedHeap::oop_iterate(ExtendedOopClosure* cl) { |
| 0 | 879 for (int i = 0; i < _n_gens; i++) { |
| 880 _gens[i]->oop_iterate(cl); | |
| 881 } | |
| 882 } | |
| 883 | |
| 884 void GenCollectedHeap::object_iterate(ObjectClosure* cl) { | |
| 885 for (int i = 0; i < _n_gens; i++) { | |
| 886 _gens[i]->object_iterate(cl); | |
| 887 } | |
| 888 } | |
| 889 | |
|
517
e9be0e04635a
6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents:
457
diff
changeset
|
890 void GenCollectedHeap::safe_object_iterate(ObjectClosure* cl) { |
|
e9be0e04635a
6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents:
457
diff
changeset
|
891 for (int i = 0; i < _n_gens; i++) { |
|
e9be0e04635a
6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents:
457
diff
changeset
|
892 _gens[i]->safe_object_iterate(cl); |
|
e9be0e04635a
6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents:
457
diff
changeset
|
893 } |
|
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 |
| 0 | 896 Space* GenCollectedHeap::space_containing(const void* addr) const { |
| 897 for (int i = 0; i < _n_gens; i++) { | |
| 898 Space* res = _gens[i]->space_containing(addr); | |
| 899 if (res != NULL) return res; | |
| 900 } | |
| 901 // Otherwise... | |
| 902 assert(false, "Could not find containing space"); | |
| 903 return NULL; | |
| 904 } | |
| 905 | |
| 906 | |
| 907 HeapWord* GenCollectedHeap::block_start(const void* addr) const { | |
| 908 assert(is_in_reserved(addr), "block_start of address outside of heap"); | |
| 909 for (int i = 0; i < _n_gens; i++) { | |
| 910 if (_gens[i]->is_in_reserved(addr)) { | |
| 911 assert(_gens[i]->is_in(addr), | |
| 912 "addr should be in allocated part of generation"); | |
| 913 return _gens[i]->block_start(addr); | |
| 914 } | |
| 915 } | |
| 916 assert(false, "Some generation should contain the address"); | |
| 917 return NULL; | |
| 918 } | |
| 919 | |
| 920 size_t GenCollectedHeap::block_size(const HeapWord* addr) const { | |
| 921 assert(is_in_reserved(addr), "block_size of address outside of heap"); | |
| 922 for (int i = 0; i < _n_gens; i++) { | |
| 923 if (_gens[i]->is_in_reserved(addr)) { | |
| 924 assert(_gens[i]->is_in(addr), | |
| 925 "addr should be in allocated part of generation"); | |
| 926 return _gens[i]->block_size(addr); | |
| 927 } | |
| 928 } | |
| 929 assert(false, "Some generation should contain the address"); | |
| 930 return 0; | |
| 931 } | |
| 932 | |
| 933 bool GenCollectedHeap::block_is_obj(const HeapWord* addr) const { | |
| 934 assert(is_in_reserved(addr), "block_is_obj of address outside of heap"); | |
| 935 assert(block_start(addr) == addr, "addr must be a block start"); | |
| 936 for (int i = 0; i < _n_gens; i++) { | |
| 937 if (_gens[i]->is_in_reserved(addr)) { | |
| 938 return _gens[i]->block_is_obj(addr); | |
| 939 } | |
| 940 } | |
| 941 assert(false, "Some generation should contain the address"); | |
| 942 return false; | |
| 943 } | |
| 944 | |
| 945 bool GenCollectedHeap::supports_tlab_allocation() const { | |
| 946 for (int i = 0; i < _n_gens; i += 1) { | |
| 947 if (_gens[i]->supports_tlab_allocation()) { | |
| 948 return true; | |
| 949 } | |
| 950 } | |
| 951 return false; | |
| 952 } | |
| 953 | |
| 954 size_t GenCollectedHeap::tlab_capacity(Thread* thr) const { | |
| 955 size_t result = 0; | |
| 956 for (int i = 0; i < _n_gens; i += 1) { | |
| 957 if (_gens[i]->supports_tlab_allocation()) { | |
| 958 result += _gens[i]->tlab_capacity(); | |
| 959 } | |
| 960 } | |
| 961 return result; | |
| 962 } | |
| 963 | |
| 17727 | 964 size_t GenCollectedHeap::tlab_used(Thread* thr) const { |
| 965 size_t result = 0; | |
| 966 for (int i = 0; i < _n_gens; i += 1) { | |
| 967 if (_gens[i]->supports_tlab_allocation()) { | |
| 968 result += _gens[i]->tlab_used(); | |
| 969 } | |
| 970 } | |
| 971 return result; | |
| 972 } | |
| 973 | |
| 0 | 974 size_t GenCollectedHeap::unsafe_max_tlab_alloc(Thread* thr) const { |
| 975 size_t result = 0; | |
| 976 for (int i = 0; i < _n_gens; i += 1) { | |
| 977 if (_gens[i]->supports_tlab_allocation()) { | |
| 978 result += _gens[i]->unsafe_max_tlab_alloc(); | |
| 979 } | |
| 980 } | |
| 981 return result; | |
| 982 } | |
| 983 | |
| 984 HeapWord* GenCollectedHeap::allocate_new_tlab(size_t size) { | |
| 985 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
|
986 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
|
987 true /* is_tlab */, |
|
c9ca3f51cf41
6994322: Remove the is_tlab and is_noref / is_large_noref parameters from the CollectedHeap
tonyp
parents:
3772
diff
changeset
|
988 &gc_overhead_limit_was_exceeded); |
| 0 | 989 } |
| 990 | |
| 991 // Requires "*prev_ptr" to be non-NULL. Deletes and a block of minimal size | |
| 992 // from the list headed by "*prev_ptr". | |
| 993 static ScratchBlock *removeSmallestScratch(ScratchBlock **prev_ptr) { | |
| 994 bool first = true; | |
| 995 size_t min_size = 0; // "first" makes this conceptually infinite. | |
| 996 ScratchBlock **smallest_ptr, *smallest; | |
| 997 ScratchBlock *cur = *prev_ptr; | |
| 998 while (cur) { | |
| 999 assert(*prev_ptr == cur, "just checking"); | |
| 1000 if (first || cur->num_words < min_size) { | |
| 1001 smallest_ptr = prev_ptr; | |
| 1002 smallest = cur; | |
| 1003 min_size = smallest->num_words; | |
| 1004 first = false; | |
| 1005 } | |
| 1006 prev_ptr = &cur->next; | |
| 1007 cur = cur->next; | |
| 1008 } | |
| 1009 smallest = *smallest_ptr; | |
| 1010 *smallest_ptr = smallest->next; | |
| 1011 return smallest; | |
| 1012 } | |
| 1013 | |
| 1014 // Sort the scratch block list headed by res into decreasing size order, | |
| 1015 // and set "res" to the result. | |
| 1016 static void sort_scratch_list(ScratchBlock*& list) { | |
| 1017 ScratchBlock* sorted = NULL; | |
| 1018 ScratchBlock* unsorted = list; | |
| 1019 while (unsorted) { | |
| 1020 ScratchBlock *smallest = removeSmallestScratch(&unsorted); | |
| 1021 smallest->next = sorted; | |
| 1022 sorted = smallest; | |
| 1023 } | |
| 1024 list = sorted; | |
| 1025 } | |
| 1026 | |
| 1027 ScratchBlock* GenCollectedHeap::gather_scratch(Generation* requestor, | |
| 1028 size_t max_alloc_words) { | |
| 1029 ScratchBlock* res = NULL; | |
| 1030 for (int i = 0; i < _n_gens; i++) { | |
| 1031 _gens[i]->contribute_scratch(res, requestor, max_alloc_words); | |
| 1032 } | |
| 1033 sort_scratch_list(res); | |
| 1034 return res; | |
| 1035 } | |
| 1036 | |
|
263
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
1037 void GenCollectedHeap::release_scratch() { |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
1038 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
|
1039 _gens[i]->reset_scratch(); |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
1040 } |
|
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 |
| 0 | 1043 class GenPrepareForVerifyClosure: public GenCollectedHeap::GenClosure { |
| 1044 void do_generation(Generation* gen) { | |
| 1045 gen->prepare_for_verify(); | |
| 1046 } | |
| 1047 }; | |
| 1048 | |
| 1049 void GenCollectedHeap::prepare_for_verify() { | |
| 1050 ensure_parsability(false); // no need to retire TLABs | |
| 1051 GenPrepareForVerifyClosure blk; | |
| 1052 generation_iterate(&blk, false); | |
| 1053 } | |
| 1054 | |
| 1055 | |
| 1056 void GenCollectedHeap::generation_iterate(GenClosure* cl, | |
| 1057 bool old_to_young) { | |
| 1058 if (old_to_young) { | |
| 1059 for (int i = _n_gens-1; i >= 0; i--) { | |
| 1060 cl->do_generation(_gens[i]); | |
| 1061 } | |
| 1062 } else { | |
| 1063 for (int i = 0; i < _n_gens; i++) { | |
| 1064 cl->do_generation(_gens[i]); | |
| 1065 } | |
| 1066 } | |
| 1067 } | |
| 1068 | |
| 1069 void GenCollectedHeap::space_iterate(SpaceClosure* cl) { | |
| 1070 for (int i = 0; i < _n_gens; i++) { | |
| 1071 _gens[i]->space_iterate(cl, true); | |
| 1072 } | |
| 1073 } | |
| 1074 | |
| 1075 bool GenCollectedHeap::is_maximal_no_gc() const { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6109
diff
changeset
|
1076 for (int i = 0; i < _n_gens; i++) { |
| 0 | 1077 if (!_gens[i]->is_maximal_no_gc()) { |
| 1078 return false; | |
| 1079 } | |
| 1080 } | |
| 1081 return true; | |
| 1082 } | |
| 1083 | |
| 1084 void GenCollectedHeap::save_marks() { | |
| 1085 for (int i = 0; i < _n_gens; i++) { | |
| 1086 _gens[i]->save_marks(); | |
| 1087 } | |
| 1088 } | |
| 1089 | |
| 1090 GenCollectedHeap* GenCollectedHeap::heap() { | |
| 1091 assert(_gch != NULL, "Uninitialized access to GenCollectedHeap::heap()"); | |
| 1092 assert(_gch->kind() == CollectedHeap::GenCollectedHeap, "not a generational heap"); | |
| 1093 return _gch; | |
| 1094 } | |
| 1095 | |
| 1096 | |
| 1097 void GenCollectedHeap::prepare_for_compaction() { | |
|
12030
330dfb0476f4
8022800: Use specific generations rather than generation iteration
brutisso
parents:
11096
diff
changeset
|
1098 guarantee(_n_gens = 2, "Wrong number of generations"); |
|
330dfb0476f4
8022800: Use specific generations rather than generation iteration
brutisso
parents:
11096
diff
changeset
|
1099 Generation* old_gen = _gens[1]; |
| 0 | 1100 // 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
|
1101 CompactPoint cp(old_gen); |
|
12030
330dfb0476f4
8022800: Use specific generations rather than generation iteration
brutisso
parents:
11096
diff
changeset
|
1102 old_gen->prepare_for_compaction(&cp); |
|
330dfb0476f4
8022800: Use specific generations rather than generation iteration
brutisso
parents:
11096
diff
changeset
|
1103 Generation* young_gen = _gens[0]; |
|
330dfb0476f4
8022800: Use specific generations rather than generation iteration
brutisso
parents:
11096
diff
changeset
|
1104 young_gen->prepare_for_compaction(&cp); |
| 0 | 1105 } |
| 1106 | |
| 1107 GCStats* GenCollectedHeap::gc_stats(int level) const { | |
| 1108 return _gens[level]->gc_stats(); | |
| 1109 } | |
| 1110 | |
| 6008 | 1111 void GenCollectedHeap::verify(bool silent, VerifyOption option /* ignored */) { |
| 0 | 1112 for (int i = _n_gens-1; i >= 0; i--) { |
| 1113 Generation* g = _gens[i]; | |
| 1114 if (!silent) { | |
|
17937
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17866
diff
changeset
|
1115 gclog_or_tty->print("%s", g->name()); |
| 0 | 1116 gclog_or_tty->print(" "); |
| 1117 } | |
| 6008 | 1118 g->verify(); |
| 0 | 1119 } |
| 1120 if (!silent) { | |
| 1121 gclog_or_tty->print("remset "); | |
| 1122 } | |
| 1123 rem_set()->verify(); | |
| 1124 } | |
| 1125 | |
| 1126 void GenCollectedHeap::print_on(outputStream* st) const { | |
| 1127 for (int i = 0; i < _n_gens; i++) { | |
| 1128 _gens[i]->print_on(st); | |
| 1129 } | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6109
diff
changeset
|
1130 MetaspaceAux::print_on(st); |
| 0 | 1131 } |
| 1132 | |
| 1133 void GenCollectedHeap::gc_threads_do(ThreadClosure* tc) const { | |
| 1134 if (workers() != NULL) { | |
| 1135 workers()->threads_do(tc); | |
| 1136 } | |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6865
diff
changeset
|
1137 #if INCLUDE_ALL_GCS |
| 0 | 1138 if (UseConcMarkSweepGC) { |
| 1139 ConcurrentMarkSweepThread::threads_do(tc); | |
| 1140 } | |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6865
diff
changeset
|
1141 #endif // INCLUDE_ALL_GCS |
| 0 | 1142 } |
| 1143 | |
| 1144 void GenCollectedHeap::print_gc_threads_on(outputStream* st) const { | |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6865
diff
changeset
|
1145 #if INCLUDE_ALL_GCS |
| 0 | 1146 if (UseParNewGC) { |
| 1147 workers()->print_worker_threads_on(st); | |
| 1148 } | |
| 1149 if (UseConcMarkSweepGC) { | |
| 1150 ConcurrentMarkSweepThread::print_all_on(st); | |
| 1151 } | |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6865
diff
changeset
|
1152 #endif // INCLUDE_ALL_GCS |
| 0 | 1153 } |
| 1154 | |
|
9076
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
9071
diff
changeset
|
1155 void GenCollectedHeap::print_on_error(outputStream* st) const { |
|
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
9071
diff
changeset
|
1156 this->CollectedHeap::print_on_error(st); |
|
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
9071
diff
changeset
|
1157 |
|
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
9071
diff
changeset
|
1158 #if INCLUDE_ALL_GCS |
|
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
9071
diff
changeset
|
1159 if (UseConcMarkSweepGC) { |
|
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
9071
diff
changeset
|
1160 st->cr(); |
|
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
9071
diff
changeset
|
1161 CMSCollector::print_on_error(st); |
|
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
9071
diff
changeset
|
1162 } |
|
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
9071
diff
changeset
|
1163 #endif // INCLUDE_ALL_GCS |
|
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
9071
diff
changeset
|
1164 } |
|
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
9071
diff
changeset
|
1165 |
| 0 | 1166 void GenCollectedHeap::print_tracing_info() const { |
| 1167 if (TraceGen0Time) { | |
| 1168 get_gen(0)->print_summary_info(); | |
| 1169 } | |
| 1170 if (TraceGen1Time) { | |
| 1171 get_gen(1)->print_summary_info(); | |
| 1172 } | |
| 1173 } | |
| 1174 | |
| 1175 void GenCollectedHeap::print_heap_change(size_t prev_used) const { | |
| 1176 if (PrintGCDetails && Verbose) { | |
| 1177 gclog_or_tty->print(" " SIZE_FORMAT | |
| 1178 "->" SIZE_FORMAT | |
| 1179 "(" SIZE_FORMAT ")", | |
| 1180 prev_used, used(), capacity()); | |
| 1181 } else { | |
| 1182 gclog_or_tty->print(" " SIZE_FORMAT "K" | |
| 1183 "->" SIZE_FORMAT "K" | |
| 1184 "(" SIZE_FORMAT "K)", | |
| 1185 prev_used / K, used() / K, capacity() / K); | |
| 1186 } | |
| 1187 } | |
| 1188 | |
| 1189 class GenGCPrologueClosure: public GenCollectedHeap::GenClosure { | |
| 1190 private: | |
| 1191 bool _full; | |
| 1192 public: | |
| 1193 void do_generation(Generation* gen) { | |
| 1194 gen->gc_prologue(_full); | |
| 1195 } | |
| 1196 GenGCPrologueClosure(bool full) : _full(full) {}; | |
| 1197 }; | |
| 1198 | |
| 1199 void GenCollectedHeap::gc_prologue(bool full) { | |
| 1200 assert(InlineCacheBuffer::is_empty(), "should have cleaned up ICBuffer"); | |
| 1201 | |
| 1202 always_do_update_barrier = false; | |
| 1203 // Fill TLAB's and such | |
| 1204 CollectedHeap::accumulate_statistics_all_tlabs(); | |
| 1205 ensure_parsability(true); // retire TLABs | |
| 1206 | |
| 1207 // Walk generations | |
| 1208 GenGCPrologueClosure blk(full); | |
| 1209 generation_iterate(&blk, false); // not old-to-young. | |
| 1210 }; | |
| 1211 | |
| 1212 class GenGCEpilogueClosure: public GenCollectedHeap::GenClosure { | |
| 1213 private: | |
| 1214 bool _full; | |
| 1215 public: | |
| 1216 void do_generation(Generation* gen) { | |
| 1217 gen->gc_epilogue(_full); | |
| 1218 } | |
| 1219 GenGCEpilogueClosure(bool full) : _full(full) {}; | |
| 1220 }; | |
| 1221 | |
| 1222 void GenCollectedHeap::gc_epilogue(bool full) { | |
| 1223 #ifdef COMPILER2 | |
| 1224 assert(DerivedPointerTable::is_empty(), "derived pointer present"); | |
| 1225 size_t actual_gap = pointer_delta((HeapWord*) (max_uintx-3), *(end_addr())); | |
| 1226 guarantee(actual_gap > (size_t)FastAllocateSizeLimit, "inline allocation wraps"); | |
| 1227 #endif /* COMPILER2 */ | |
| 1228 | |
| 1229 resize_all_tlabs(); | |
| 1230 | |
| 1231 GenGCEpilogueClosure blk(full); | |
| 1232 generation_iterate(&blk, false); // not old-to-young. | |
| 1233 | |
|
3799
48048b59a551
7061204: clean the chunk table synchronously in embedded builds
jcoomes
parents:
3774
diff
changeset
|
1234 if (!CleanChunkPoolAsync) { |
|
48048b59a551
7061204: clean the chunk table synchronously in embedded builds
jcoomes
parents:
3774
diff
changeset
|
1235 Chunk::clean_chunk_pool(); |
|
48048b59a551
7061204: clean the chunk table synchronously in embedded builds
jcoomes
parents:
3774
diff
changeset
|
1236 } |
|
48048b59a551
7061204: clean the chunk table synchronously in embedded builds
jcoomes
parents:
3774
diff
changeset
|
1237 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6109
diff
changeset
|
1238 MetaspaceCounters::update_performance_counters(); |
|
12063
1a8fb39bdbc4
8014659: NPG: performance counters for compressed klass space
ehelin
parents:
12030
diff
changeset
|
1239 CompressedClassSpaceCounters::update_performance_counters(); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6109
diff
changeset
|
1240 |
| 0 | 1241 always_do_update_barrier = UseConcMarkSweepGC; |
| 1242 }; | |
| 1243 | |
|
263
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
1244 #ifndef PRODUCT |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
1245 class GenGCSaveTopsBeforeGCClosure: public GenCollectedHeap::GenClosure { |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
1246 private: |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
1247 public: |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
1248 void do_generation(Generation* gen) { |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
1249 gen->record_spaces_top(); |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
1250 } |
|
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 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
|
1254 if (ZapUnusedHeapArea) { |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
1255 GenGCSaveTopsBeforeGCClosure blk; |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
1256 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
|
1257 } |
|
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 #endif // not PRODUCT |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
1260 |
| 0 | 1261 class GenEnsureParsabilityClosure: public GenCollectedHeap::GenClosure { |
| 1262 public: | |
| 1263 void do_generation(Generation* gen) { | |
| 1264 gen->ensure_parsability(); | |
| 1265 } | |
| 1266 }; | |
| 1267 | |
| 1268 void GenCollectedHeap::ensure_parsability(bool retire_tlabs) { | |
| 1269 CollectedHeap::ensure_parsability(retire_tlabs); | |
| 1270 GenEnsureParsabilityClosure ep_cl; | |
| 1271 generation_iterate(&ep_cl, false); | |
| 1272 } | |
| 1273 | |
|
12030
330dfb0476f4
8022800: Use specific generations rather than generation iteration
brutisso
parents:
11096
diff
changeset
|
1274 oop GenCollectedHeap::handle_failed_promotion(Generation* old_gen, |
| 0 | 1275 oop obj, |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
1276 size_t obj_size) { |
|
12030
330dfb0476f4
8022800: Use specific generations rather than generation iteration
brutisso
parents:
11096
diff
changeset
|
1277 guarantee(old_gen->level() == 1, "We only get here with an old generation"); |
| 0 | 1278 assert(obj_size == (size_t)obj->size(), "bad obj_size passed in"); |
| 1279 HeapWord* result = NULL; | |
| 1280 | |
|
12030
330dfb0476f4
8022800: Use specific generations rather than generation iteration
brutisso
parents:
11096
diff
changeset
|
1281 result = old_gen->expand_and_allocate(obj_size, false); |
| 0 | 1282 |
| 1283 if (result != NULL) { | |
| 1284 Copy::aligned_disjoint_words((HeapWord*)obj, result, obj_size); | |
| 1285 } | |
| 1286 return oop(result); | |
| 1287 } | |
| 1288 | |
| 1289 class GenTimeOfLastGCClosure: public GenCollectedHeap::GenClosure { | |
| 1290 jlong _time; // in ms | |
| 1291 jlong _now; // in ms | |
| 1292 | |
| 1293 public: | |
| 1294 GenTimeOfLastGCClosure(jlong now) : _time(now), _now(now) { } | |
| 1295 | |
| 1296 jlong time() { return _time; } | |
| 1297 | |
| 1298 void do_generation(Generation* gen) { | |
| 1299 _time = MIN2(_time, gen->time_of_last_gc(_now)); | |
| 1300 } | |
| 1301 }; | |
| 1302 | |
| 1303 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
|
1304 // 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
|
1305 // 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
|
1306 jlong now = os::javaTimeNanos() / NANOSECS_PER_MILLISEC; |
| 0 | 1307 GenTimeOfLastGCClosure tolgc_cl(now); |
| 1308 // iterate over generations getting the oldest | |
| 1309 // time that a generation was collected | |
| 1310 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
|
1311 |
|
e7dead7e90af
7117303: VM uses non-monotonic time source and complains that it is non-monotonic
johnc
parents:
4708
diff
changeset
|
1312 // 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
|
1313 // 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
|
1314 // (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
|
1315 // back a time later than 'now'. |
| 0 | 1316 jlong retVal = now - tolgc_cl.time(); |
| 1317 if (retVal < 0) { | |
|
17937
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17866
diff
changeset
|
1318 NOT_PRODUCT(warning("time warp: "INT64_FORMAT, (int64_t) retVal);) |
| 0 | 1319 return 0; |
| 1320 } | |
| 1321 return retVal; | |
| 1322 } |