Mercurial > hg > truffle
annotate src/share/vm/gc_implementation/parallelScavenge/psOldGen.cpp @ 3285:49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
Summary: It introduces non-product cmd line parameter G1DummyRegionsPerGC which indicates how many "dummy" regions to allocate at the end of each GC. This allows the G1 heap to grow artificially and makes concurrent marking cycles more frequent irrespective of what the application that is running is doing. The dummy regions will be found totally empty during cleanup so this parameter can also be used to stress the concurrent cleanup operation.
Reviewed-by: brutisso, johnc
| author | tonyp |
|---|---|
| date | Tue, 19 Apr 2011 15:46:59 -0400 |
| parents | eda9eb483d29 |
| children | 567c87d484a0 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
3251
eda9eb483d29
6841742: par compact - remove unused/unsupported options
jcoomes
parents:
1972
diff
changeset
|
2 * Copyright (c) 2001, 2011, Oracle and/or its affiliates. All rights reserved. |
| 0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 18 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
579
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
579
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:
579
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #include "precompiled.hpp" |
| 26 #include "gc_implementation/parallelScavenge/parallelScavengeHeap.hpp" | |
| 27 #include "gc_implementation/parallelScavenge/psAdaptiveSizePolicy.hpp" | |
| 28 #include "gc_implementation/parallelScavenge/psMarkSweepDecorator.hpp" | |
| 29 #include "gc_implementation/parallelScavenge/psOldGen.hpp" | |
| 30 #include "gc_implementation/shared/spaceDecorator.hpp" | |
| 31 #include "memory/cardTableModRefBS.hpp" | |
| 32 #include "memory/gcLocker.inline.hpp" | |
| 33 #include "oops/oop.inline.hpp" | |
| 34 #include "runtime/java.hpp" | |
| 0 | 35 |
| 36 inline const char* PSOldGen::select_name() { | |
| 37 return UseParallelOldGC ? "ParOldGen" : "PSOldGen"; | |
| 38 } | |
| 39 | |
| 40 PSOldGen::PSOldGen(ReservedSpace rs, size_t alignment, | |
| 41 size_t initial_size, size_t min_size, size_t max_size, | |
| 42 const char* perf_data_name, int level): | |
| 43 _name(select_name()), _init_gen_size(initial_size), _min_gen_size(min_size), | |
| 44 _max_gen_size(max_size) | |
| 45 { | |
| 46 initialize(rs, alignment, perf_data_name, level); | |
| 47 } | |
| 48 | |
| 49 PSOldGen::PSOldGen(size_t initial_size, | |
| 50 size_t min_size, size_t max_size, | |
| 51 const char* perf_data_name, int level): | |
| 52 _name(select_name()), _init_gen_size(initial_size), _min_gen_size(min_size), | |
| 53 _max_gen_size(max_size) | |
| 54 {} | |
| 55 | |
| 56 void PSOldGen::initialize(ReservedSpace rs, size_t alignment, | |
| 57 const char* perf_data_name, int level) { | |
| 58 initialize_virtual_space(rs, alignment); | |
| 59 initialize_work(perf_data_name, level); | |
| 60 // The old gen can grow to gen_size_limit(). _reserve reflects only | |
| 61 // the current maximum that can be committed. | |
| 62 assert(_reserved.byte_size() <= gen_size_limit(), "Consistency check"); | |
| 63 } | |
| 64 | |
| 65 void PSOldGen::initialize_virtual_space(ReservedSpace rs, size_t alignment) { | |
| 66 | |
| 67 _virtual_space = new PSVirtualSpace(rs, alignment); | |
| 68 if (!_virtual_space->expand_by(_init_gen_size)) { | |
| 69 vm_exit_during_initialization("Could not reserve enough space for " | |
| 70 "object heap"); | |
| 71 } | |
| 72 } | |
| 73 | |
| 74 void PSOldGen::initialize_work(const char* perf_data_name, int level) { | |
| 75 // | |
| 76 // Basic memory initialization | |
| 77 // | |
| 78 | |
| 79 MemRegion limit_reserved((HeapWord*)virtual_space()->low_boundary(), | |
| 80 heap_word_size(_max_gen_size)); | |
| 81 assert(limit_reserved.byte_size() == _max_gen_size, | |
| 82 "word vs bytes confusion"); | |
| 83 // | |
| 84 // Object start stuff | |
| 85 // | |
| 86 | |
| 87 start_array()->initialize(limit_reserved); | |
| 88 | |
| 89 _reserved = MemRegion((HeapWord*)virtual_space()->low_boundary(), | |
| 90 (HeapWord*)virtual_space()->high_boundary()); | |
| 91 | |
| 92 // | |
| 93 // Card table stuff | |
| 94 // | |
| 95 | |
| 96 MemRegion cmr((HeapWord*)virtual_space()->low(), | |
| 97 (HeapWord*)virtual_space()->high()); | |
|
263
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
0
diff
changeset
|
98 if (ZapUnusedHeapArea) { |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
0
diff
changeset
|
99 // Mangle newly committed space immediately rather than |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
0
diff
changeset
|
100 // waiting for the initialization of the space even though |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
0
diff
changeset
|
101 // mangling is related to spaces. Doing it here eliminates |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
0
diff
changeset
|
102 // the need to carry along information that a complete mangling |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
0
diff
changeset
|
103 // (bottom to end) needs to be done. |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
0
diff
changeset
|
104 SpaceMangler::mangle_region(cmr); |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
0
diff
changeset
|
105 } |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
0
diff
changeset
|
106 |
| 0 | 107 Universe::heap()->barrier_set()->resize_covered_region(cmr); |
| 108 | |
| 109 CardTableModRefBS* _ct = (CardTableModRefBS*)Universe::heap()->barrier_set(); | |
| 110 assert (_ct->kind() == BarrierSet::CardTableModRef, "Sanity"); | |
| 111 | |
| 112 // Verify that the start and end of this generation is the start of a card. | |
| 113 // If this wasn't true, a single card could span more than one generation, | |
| 114 // which would cause problems when we commit/uncommit memory, and when we | |
| 115 // clear and dirty cards. | |
| 116 guarantee(_ct->is_card_aligned(_reserved.start()), "generation must be card aligned"); | |
| 117 if (_reserved.end() != Universe::heap()->reserved_region().end()) { | |
| 118 // Don't check at the very end of the heap as we'll assert that we're probing off | |
| 119 // the end if we try. | |
| 120 guarantee(_ct->is_card_aligned(_reserved.end()), "generation must be card aligned"); | |
| 121 } | |
| 122 | |
| 123 // | |
| 124 // ObjectSpace stuff | |
| 125 // | |
| 126 | |
|
535
4e400c36026f
6783381: NUMA allocator: don't pretouch eden space with UseNUMA
iveresov
parents:
380
diff
changeset
|
127 _object_space = new MutableSpace(virtual_space()->alignment()); |
| 0 | 128 |
| 129 if (_object_space == NULL) | |
| 130 vm_exit_during_initialization("Could not allocate an old gen space"); | |
| 131 | |
|
263
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
0
diff
changeset
|
132 object_space()->initialize(cmr, |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
0
diff
changeset
|
133 SpaceDecorator::Clear, |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
0
diff
changeset
|
134 SpaceDecorator::Mangle); |
| 0 | 135 |
| 136 _object_mark_sweep = new PSMarkSweepDecorator(_object_space, start_array(), MarkSweepDeadRatio); | |
| 137 | |
| 138 if (_object_mark_sweep == NULL) | |
| 139 vm_exit_during_initialization("Could not complete allocation of old generation"); | |
| 140 | |
| 141 // Update the start_array | |
| 142 start_array()->set_covered_region(cmr); | |
| 143 | |
| 144 // Generation Counters, generation 'level', 1 subspace | |
| 145 _gen_counters = new PSGenerationCounters(perf_data_name, level, 1, | |
| 146 virtual_space()); | |
| 147 _space_counters = new SpaceCounters(perf_data_name, 0, | |
| 148 virtual_space()->reserved_size(), | |
| 149 _object_space, _gen_counters); | |
| 150 } | |
| 151 | |
| 152 // Assume that the generation has been allocated if its | |
| 153 // reserved size is not 0. | |
| 154 bool PSOldGen::is_allocated() { | |
| 155 return virtual_space()->reserved_size() != 0; | |
| 156 } | |
| 157 | |
| 158 void PSOldGen::precompact() { | |
| 159 ParallelScavengeHeap* heap = (ParallelScavengeHeap*)Universe::heap(); | |
| 160 assert(heap->kind() == CollectedHeap::ParallelScavengeHeap, "Sanity"); | |
| 161 | |
| 162 // Reset start array first. | |
| 163 start_array()->reset(); | |
| 164 | |
| 165 object_mark_sweep()->precompact(); | |
| 166 | |
| 167 // Now compact the young gen | |
| 168 heap->young_gen()->precompact(); | |
| 169 } | |
| 170 | |
| 171 void PSOldGen::adjust_pointers() { | |
| 172 object_mark_sweep()->adjust_pointers(); | |
| 173 } | |
| 174 | |
| 175 void PSOldGen::compact() { | |
| 176 object_mark_sweep()->compact(ZapUnusedHeapArea); | |
| 177 } | |
| 178 | |
| 179 size_t PSOldGen::contiguous_available() const { | |
| 180 return object_space()->free_in_bytes() + virtual_space()->uncommitted_size(); | |
| 181 } | |
| 182 | |
| 183 // Allocation. We report all successful allocations to the size policy | |
| 184 // Note that the perm gen does not use this method, and should not! | |
| 185 HeapWord* PSOldGen::allocate(size_t word_size, bool is_tlab) { | |
| 186 assert_locked_or_safepoint(Heap_lock); | |
| 187 HeapWord* res = allocate_noexpand(word_size, is_tlab); | |
| 188 | |
| 189 if (res == NULL) { | |
| 190 res = expand_and_allocate(word_size, is_tlab); | |
| 191 } | |
| 192 | |
| 193 // Allocations in the old generation need to be reported | |
| 194 if (res != NULL) { | |
| 195 ParallelScavengeHeap* heap = (ParallelScavengeHeap*)Universe::heap(); | |
| 196 heap->size_policy()->tenured_allocation(word_size); | |
| 197 } | |
| 198 | |
| 199 return res; | |
| 200 } | |
| 201 | |
| 202 HeapWord* PSOldGen::expand_and_allocate(size_t word_size, bool is_tlab) { | |
| 203 assert(!is_tlab, "TLAB's are not supported in PSOldGen"); | |
| 204 expand(word_size*HeapWordSize); | |
| 205 if (GCExpandToAllocateDelayMillis > 0) { | |
| 206 os::sleep(Thread::current(), GCExpandToAllocateDelayMillis, false); | |
| 207 } | |
| 208 return allocate_noexpand(word_size, is_tlab); | |
| 209 } | |
| 210 | |
| 211 HeapWord* PSOldGen::expand_and_cas_allocate(size_t word_size) { | |
| 212 expand(word_size*HeapWordSize); | |
| 213 if (GCExpandToAllocateDelayMillis > 0) { | |
| 214 os::sleep(Thread::current(), GCExpandToAllocateDelayMillis, false); | |
| 215 } | |
| 216 return cas_allocate_noexpand(word_size); | |
| 217 } | |
| 218 | |
| 219 void PSOldGen::expand(size_t bytes) { | |
|
271
818a18cd69a8
6730514: assertion failure in mangling code when expanding by 0 bytes
jmasa
parents:
263
diff
changeset
|
220 if (bytes == 0) { |
|
818a18cd69a8
6730514: assertion failure in mangling code when expanding by 0 bytes
jmasa
parents:
263
diff
changeset
|
221 return; |
|
818a18cd69a8
6730514: assertion failure in mangling code when expanding by 0 bytes
jmasa
parents:
263
diff
changeset
|
222 } |
| 0 | 223 MutexLocker x(ExpandHeap_lock); |
| 224 const size_t alignment = virtual_space()->alignment(); | |
| 225 size_t aligned_bytes = align_size_up(bytes, alignment); | |
| 226 size_t aligned_expand_bytes = align_size_up(MinHeapDeltaBytes, alignment); | |
|
271
818a18cd69a8
6730514: assertion failure in mangling code when expanding by 0 bytes
jmasa
parents:
263
diff
changeset
|
227 if (aligned_bytes == 0){ |
|
818a18cd69a8
6730514: assertion failure in mangling code when expanding by 0 bytes
jmasa
parents:
263
diff
changeset
|
228 // The alignment caused the number of bytes to wrap. An expand_by(0) will |
|
818a18cd69a8
6730514: assertion failure in mangling code when expanding by 0 bytes
jmasa
parents:
263
diff
changeset
|
229 // return true with the implication that and expansion was done when it |
|
818a18cd69a8
6730514: assertion failure in mangling code when expanding by 0 bytes
jmasa
parents:
263
diff
changeset
|
230 // was not. A call to expand implies a best effort to expand by "bytes" |
|
818a18cd69a8
6730514: assertion failure in mangling code when expanding by 0 bytes
jmasa
parents:
263
diff
changeset
|
231 // but not a guarantee. Align down to give a best effort. This is likely |
|
818a18cd69a8
6730514: assertion failure in mangling code when expanding by 0 bytes
jmasa
parents:
263
diff
changeset
|
232 // the most that the generation can expand since it has some capacity to |
|
818a18cd69a8
6730514: assertion failure in mangling code when expanding by 0 bytes
jmasa
parents:
263
diff
changeset
|
233 // start with. |
|
818a18cd69a8
6730514: assertion failure in mangling code when expanding by 0 bytes
jmasa
parents:
263
diff
changeset
|
234 aligned_bytes = align_size_down(bytes, alignment); |
|
818a18cd69a8
6730514: assertion failure in mangling code when expanding by 0 bytes
jmasa
parents:
263
diff
changeset
|
235 } |
| 0 | 236 |
| 237 bool success = false; | |
| 238 if (aligned_expand_bytes > aligned_bytes) { | |
| 239 success = expand_by(aligned_expand_bytes); | |
| 240 } | |
| 241 if (!success) { | |
| 242 success = expand_by(aligned_bytes); | |
| 243 } | |
| 244 if (!success) { | |
| 245 success = expand_to_reserved(); | |
| 246 } | |
| 247 | |
|
271
818a18cd69a8
6730514: assertion failure in mangling code when expanding by 0 bytes
jmasa
parents:
263
diff
changeset
|
248 if (PrintGC && Verbose) { |
|
818a18cd69a8
6730514: assertion failure in mangling code when expanding by 0 bytes
jmasa
parents:
263
diff
changeset
|
249 if (success && GC_locker::is_active()) { |
| 0 | 250 gclog_or_tty->print_cr("Garbage collection disabled, expanded heap instead"); |
| 251 } | |
| 252 } | |
| 253 } | |
| 254 | |
| 255 bool PSOldGen::expand_by(size_t bytes) { | |
| 256 assert_lock_strong(ExpandHeap_lock); | |
| 257 assert_locked_or_safepoint(Heap_lock); | |
|
271
818a18cd69a8
6730514: assertion failure in mangling code when expanding by 0 bytes
jmasa
parents:
263
diff
changeset
|
258 if (bytes == 0) { |
|
818a18cd69a8
6730514: assertion failure in mangling code when expanding by 0 bytes
jmasa
parents:
263
diff
changeset
|
259 return true; // That's what virtual_space()->expand_by(0) would return |
|
818a18cd69a8
6730514: assertion failure in mangling code when expanding by 0 bytes
jmasa
parents:
263
diff
changeset
|
260 } |
| 0 | 261 bool result = virtual_space()->expand_by(bytes); |
| 262 if (result) { | |
|
263
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
0
diff
changeset
|
263 if (ZapUnusedHeapArea) { |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
0
diff
changeset
|
264 // We need to mangle the newly expanded area. The memregion spans |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
0
diff
changeset
|
265 // end -> new_end, we assume that top -> end is already mangled. |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
0
diff
changeset
|
266 // Do the mangling before post_resize() is called because |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
0
diff
changeset
|
267 // the space is available for allocation after post_resize(); |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
0
diff
changeset
|
268 HeapWord* const virtual_space_high = (HeapWord*) virtual_space()->high(); |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
0
diff
changeset
|
269 assert(object_space()->end() < virtual_space_high, |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
0
diff
changeset
|
270 "Should be true before post_resize()"); |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
0
diff
changeset
|
271 MemRegion mangle_region(object_space()->end(), virtual_space_high); |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
0
diff
changeset
|
272 // Note that the object space has not yet been updated to |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
0
diff
changeset
|
273 // coincede with the new underlying virtual space. |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
0
diff
changeset
|
274 SpaceMangler::mangle_region(mangle_region); |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
0
diff
changeset
|
275 } |
| 0 | 276 post_resize(); |
| 277 if (UsePerfData) { | |
| 278 _space_counters->update_capacity(); | |
| 279 _gen_counters->update_all(); | |
| 280 } | |
| 281 } | |
| 282 | |
| 283 if (result && Verbose && PrintGC) { | |
| 284 size_t new_mem_size = virtual_space()->committed_size(); | |
| 285 size_t old_mem_size = new_mem_size - bytes; | |
| 286 gclog_or_tty->print_cr("Expanding %s from " SIZE_FORMAT "K by " | |
| 287 SIZE_FORMAT "K to " | |
| 288 SIZE_FORMAT "K", | |
| 289 name(), old_mem_size/K, bytes/K, new_mem_size/K); | |
| 290 } | |
| 291 | |
| 292 return result; | |
| 293 } | |
| 294 | |
| 295 bool PSOldGen::expand_to_reserved() { | |
| 296 assert_lock_strong(ExpandHeap_lock); | |
| 297 assert_locked_or_safepoint(Heap_lock); | |
| 298 | |
| 299 bool result = true; | |
| 300 const size_t remaining_bytes = virtual_space()->uncommitted_size(); | |
| 301 if (remaining_bytes > 0) { | |
| 302 result = expand_by(remaining_bytes); | |
| 303 DEBUG_ONLY(if (!result) warning("grow to reserve failed")); | |
| 304 } | |
| 305 return result; | |
| 306 } | |
| 307 | |
| 308 void PSOldGen::shrink(size_t bytes) { | |
| 309 assert_lock_strong(ExpandHeap_lock); | |
| 310 assert_locked_or_safepoint(Heap_lock); | |
| 311 | |
| 312 size_t size = align_size_down(bytes, virtual_space()->alignment()); | |
| 313 if (size > 0) { | |
| 314 assert_lock_strong(ExpandHeap_lock); | |
| 315 virtual_space()->shrink_by(bytes); | |
| 316 post_resize(); | |
| 317 | |
| 318 if (Verbose && PrintGC) { | |
| 319 size_t new_mem_size = virtual_space()->committed_size(); | |
| 320 size_t old_mem_size = new_mem_size + bytes; | |
| 321 gclog_or_tty->print_cr("Shrinking %s from " SIZE_FORMAT "K by " | |
| 322 SIZE_FORMAT "K to " | |
| 323 SIZE_FORMAT "K", | |
| 324 name(), old_mem_size/K, bytes/K, new_mem_size/K); | |
| 325 } | |
| 326 } | |
| 327 } | |
| 328 | |
| 329 void PSOldGen::resize(size_t desired_free_space) { | |
| 330 const size_t alignment = virtual_space()->alignment(); | |
| 331 const size_t size_before = virtual_space()->committed_size(); | |
| 332 size_t new_size = used_in_bytes() + desired_free_space; | |
| 333 if (new_size < used_in_bytes()) { | |
| 334 // Overflowed the addition. | |
| 335 new_size = gen_size_limit(); | |
| 336 } | |
| 337 // Adjust according to our min and max | |
| 338 new_size = MAX2(MIN2(new_size, gen_size_limit()), min_gen_size()); | |
| 339 | |
| 340 assert(gen_size_limit() >= reserved().byte_size(), "max new size problem?"); | |
| 341 new_size = align_size_up(new_size, alignment); | |
| 342 | |
| 343 const size_t current_size = capacity_in_bytes(); | |
| 344 | |
| 345 if (PrintAdaptiveSizePolicy && Verbose) { | |
| 346 gclog_or_tty->print_cr("AdaptiveSizePolicy::old generation size: " | |
| 347 "desired free: " SIZE_FORMAT " used: " SIZE_FORMAT | |
| 348 " new size: " SIZE_FORMAT " current size " SIZE_FORMAT | |
| 349 " gen limits: " SIZE_FORMAT " / " SIZE_FORMAT, | |
| 350 desired_free_space, used_in_bytes(), new_size, current_size, | |
| 351 gen_size_limit(), min_gen_size()); | |
| 352 } | |
| 353 | |
| 354 if (new_size == current_size) { | |
| 355 // No change requested | |
| 356 return; | |
| 357 } | |
| 358 if (new_size > current_size) { | |
| 359 size_t change_bytes = new_size - current_size; | |
| 360 expand(change_bytes); | |
| 361 } else { | |
| 362 size_t change_bytes = current_size - new_size; | |
| 363 // shrink doesn't grab this lock, expand does. Is that right? | |
| 364 MutexLocker x(ExpandHeap_lock); | |
| 365 shrink(change_bytes); | |
| 366 } | |
| 367 | |
| 368 if (PrintAdaptiveSizePolicy) { | |
| 369 ParallelScavengeHeap* heap = (ParallelScavengeHeap*)Universe::heap(); | |
| 370 assert(heap->kind() == CollectedHeap::ParallelScavengeHeap, "Sanity"); | |
| 371 gclog_or_tty->print_cr("AdaptiveSizePolicy::old generation size: " | |
| 372 "collection: %d " | |
| 373 "(" SIZE_FORMAT ") -> (" SIZE_FORMAT ") ", | |
| 374 heap->total_collections(), | |
| 375 size_before, virtual_space()->committed_size()); | |
| 376 } | |
| 377 } | |
| 378 | |
| 379 // NOTE! We need to be careful about resizing. During a GC, multiple | |
| 380 // allocators may be active during heap expansion. If we allow the | |
| 381 // heap resizing to become visible before we have correctly resized | |
| 382 // all heap related data structures, we may cause program failures. | |
| 383 void PSOldGen::post_resize() { | |
| 384 // First construct a memregion representing the new size | |
| 385 MemRegion new_memregion((HeapWord*)virtual_space()->low(), | |
| 386 (HeapWord*)virtual_space()->high()); | |
| 387 size_t new_word_size = new_memregion.word_size(); | |
| 388 | |
| 389 start_array()->set_covered_region(new_memregion); | |
| 390 Universe::heap()->barrier_set()->resize_covered_region(new_memregion); | |
| 391 | |
| 392 // ALWAYS do this last!! | |
|
535
4e400c36026f
6783381: NUMA allocator: don't pretouch eden space with UseNUMA
iveresov
parents:
380
diff
changeset
|
393 object_space()->initialize(new_memregion, |
|
4e400c36026f
6783381: NUMA allocator: don't pretouch eden space with UseNUMA
iveresov
parents:
380
diff
changeset
|
394 SpaceDecorator::DontClear, |
|
4e400c36026f
6783381: NUMA allocator: don't pretouch eden space with UseNUMA
iveresov
parents:
380
diff
changeset
|
395 SpaceDecorator::DontMangle); |
| 0 | 396 |
| 397 assert(new_word_size == heap_word_size(object_space()->capacity_in_bytes()), | |
| 398 "Sanity"); | |
| 399 } | |
| 400 | |
| 401 size_t PSOldGen::gen_size_limit() { | |
| 402 return _max_gen_size; | |
| 403 } | |
| 404 | |
| 405 void PSOldGen::reset_after_change() { | |
| 406 ShouldNotReachHere(); | |
| 407 return; | |
| 408 } | |
| 409 | |
| 410 size_t PSOldGen::available_for_expansion() { | |
| 411 ShouldNotReachHere(); | |
| 412 return 0; | |
| 413 } | |
| 414 | |
| 415 size_t PSOldGen::available_for_contraction() { | |
| 416 ShouldNotReachHere(); | |
| 417 return 0; | |
| 418 } | |
| 419 | |
| 420 void PSOldGen::print() const { print_on(tty);} | |
| 421 void PSOldGen::print_on(outputStream* st) const { | |
| 422 st->print(" %-15s", name()); | |
| 423 if (PrintGCDetails && Verbose) { | |
| 424 st->print(" total " SIZE_FORMAT ", used " SIZE_FORMAT, | |
| 425 capacity_in_bytes(), used_in_bytes()); | |
| 426 } else { | |
| 427 st->print(" total " SIZE_FORMAT "K, used " SIZE_FORMAT "K", | |
| 428 capacity_in_bytes()/K, used_in_bytes()/K); | |
| 429 } | |
| 430 st->print_cr(" [" INTPTR_FORMAT ", " INTPTR_FORMAT ", " INTPTR_FORMAT ")", | |
| 431 virtual_space()->low_boundary(), | |
| 432 virtual_space()->high(), | |
| 433 virtual_space()->high_boundary()); | |
| 434 | |
| 435 st->print(" object"); object_space()->print_on(st); | |
| 436 } | |
| 437 | |
| 438 void PSOldGen::print_used_change(size_t prev_used) const { | |
| 439 gclog_or_tty->print(" [%s:", name()); | |
| 440 gclog_or_tty->print(" " SIZE_FORMAT "K" | |
| 441 "->" SIZE_FORMAT "K" | |
| 442 "(" SIZE_FORMAT "K)", | |
| 443 prev_used / K, used_in_bytes() / K, | |
| 444 capacity_in_bytes() / K); | |
| 445 gclog_or_tty->print("]"); | |
| 446 } | |
| 447 | |
| 448 void PSOldGen::update_counters() { | |
| 449 if (UsePerfData) { | |
| 450 _space_counters->update_all(); | |
| 451 _gen_counters->update_all(); | |
| 452 } | |
| 453 } | |
| 454 | |
| 455 #ifndef PRODUCT | |
| 456 | |
| 457 void PSOldGen::space_invariants() { | |
| 458 assert(object_space()->end() == (HeapWord*) virtual_space()->high(), | |
| 459 "Space invariant"); | |
| 460 assert(object_space()->bottom() == (HeapWord*) virtual_space()->low(), | |
| 461 "Space invariant"); | |
| 462 assert(virtual_space()->low_boundary() <= virtual_space()->low(), | |
| 463 "Space invariant"); | |
| 464 assert(virtual_space()->high_boundary() >= virtual_space()->high(), | |
| 465 "Space invariant"); | |
| 466 assert(virtual_space()->low_boundary() == (char*) _reserved.start(), | |
| 467 "Space invariant"); | |
| 468 assert(virtual_space()->high_boundary() == (char*) _reserved.end(), | |
| 469 "Space invariant"); | |
| 470 assert(virtual_space()->committed_size() <= virtual_space()->reserved_size(), | |
| 471 "Space invariant"); | |
| 472 } | |
| 473 #endif | |
| 474 | |
| 475 void PSOldGen::verify(bool allow_dirty) { | |
| 476 object_space()->verify(allow_dirty); | |
| 477 } | |
| 478 class VerifyObjectStartArrayClosure : public ObjectClosure { | |
| 479 PSOldGen* _gen; | |
| 480 ObjectStartArray* _start_array; | |
| 481 | |
| 482 public: | |
| 483 VerifyObjectStartArrayClosure(PSOldGen* gen, ObjectStartArray* start_array) : | |
| 484 _gen(gen), _start_array(start_array) { } | |
| 485 | |
| 486 virtual void do_object(oop obj) { | |
| 487 HeapWord* test_addr = (HeapWord*)obj + 1; | |
| 488 guarantee(_start_array->object_start(test_addr) == (HeapWord*)obj, "ObjectStartArray cannot find start of object"); | |
| 489 guarantee(_start_array->is_block_allocated((HeapWord*)obj), "ObjectStartArray missing block allocation"); | |
| 490 } | |
| 491 }; | |
| 492 | |
| 493 void PSOldGen::verify_object_start_array() { | |
| 494 VerifyObjectStartArrayClosure check( this, &_start_array ); | |
| 495 object_iterate(&check); | |
| 496 } | |
|
263
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
0
diff
changeset
|
497 |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
0
diff
changeset
|
498 #ifndef PRODUCT |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
0
diff
changeset
|
499 void PSOldGen::record_spaces_top() { |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
0
diff
changeset
|
500 assert(ZapUnusedHeapArea, "Not mangling unused space"); |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
0
diff
changeset
|
501 object_space()->set_top_for_allocations(); |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
0
diff
changeset
|
502 } |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
0
diff
changeset
|
503 #endif |