| File: | jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp |
| Warning: | line 1117, column 27 Value stored to 'top_cp' during its initialization is never read |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
| 1 | /* |
| 2 | * Copyright (c) 2005, 2021, Oracle and/or its affiliates. All rights reserved. |
| 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 | * |
| 19 | * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| 20 | * or visit www.oracle.com if you need additional information or have any |
| 21 | * questions. |
| 22 | * |
| 23 | */ |
| 24 | |
| 25 | #include "precompiled.hpp" |
| 26 | #include "classfile/classLoaderDataGraph.hpp" |
| 27 | #include "classfile/javaClasses.inline.hpp" |
| 28 | #include "classfile/stringTable.hpp" |
| 29 | #include "classfile/symbolTable.hpp" |
| 30 | #include "classfile/systemDictionary.hpp" |
| 31 | #include "code/codeCache.hpp" |
| 32 | #include "compiler/oopMap.hpp" |
| 33 | #include "gc/parallel/parallelArguments.hpp" |
| 34 | #include "gc/parallel/parallelScavengeHeap.inline.hpp" |
| 35 | #include "gc/parallel/parMarkBitMap.inline.hpp" |
| 36 | #include "gc/parallel/psAdaptiveSizePolicy.hpp" |
| 37 | #include "gc/parallel/psCompactionManager.inline.hpp" |
| 38 | #include "gc/parallel/psOldGen.hpp" |
| 39 | #include "gc/parallel/psParallelCompact.inline.hpp" |
| 40 | #include "gc/parallel/psPromotionManager.inline.hpp" |
| 41 | #include "gc/parallel/psRootType.hpp" |
| 42 | #include "gc/parallel/psScavenge.hpp" |
| 43 | #include "gc/parallel/psStringDedup.hpp" |
| 44 | #include "gc/parallel/psYoungGen.hpp" |
| 45 | #include "gc/shared/gcCause.hpp" |
| 46 | #include "gc/shared/gcHeapSummary.hpp" |
| 47 | #include "gc/shared/gcId.hpp" |
| 48 | #include "gc/shared/gcLocker.hpp" |
| 49 | #include "gc/shared/gcTimer.hpp" |
| 50 | #include "gc/shared/gcTrace.hpp" |
| 51 | #include "gc/shared/gcTraceTime.inline.hpp" |
| 52 | #include "gc/shared/isGCActiveMark.hpp" |
| 53 | #include "gc/shared/oopStorage.inline.hpp" |
| 54 | #include "gc/shared/oopStorageSet.inline.hpp" |
| 55 | #include "gc/shared/oopStorageSetParState.inline.hpp" |
| 56 | #include "gc/shared/referencePolicy.hpp" |
| 57 | #include "gc/shared/referenceProcessor.hpp" |
| 58 | #include "gc/shared/referenceProcessorPhaseTimes.hpp" |
| 59 | #include "gc/shared/spaceDecorator.inline.hpp" |
| 60 | #include "gc/shared/taskTerminator.hpp" |
| 61 | #include "gc/shared/weakProcessor.inline.hpp" |
| 62 | #include "gc/shared/workerPolicy.hpp" |
| 63 | #include "gc/shared/workerThread.hpp" |
| 64 | #include "gc/shared/workerUtils.hpp" |
| 65 | #include "logging/log.hpp" |
| 66 | #include "memory/iterator.inline.hpp" |
| 67 | #include "memory/metaspaceUtils.hpp" |
| 68 | #include "memory/resourceArea.hpp" |
| 69 | #include "memory/universe.hpp" |
| 70 | #include "oops/access.inline.hpp" |
| 71 | #include "oops/instanceClassLoaderKlass.inline.hpp" |
| 72 | #include "oops/instanceKlass.inline.hpp" |
| 73 | #include "oops/instanceMirrorKlass.inline.hpp" |
| 74 | #include "oops/methodData.hpp" |
| 75 | #include "oops/objArrayKlass.inline.hpp" |
| 76 | #include "oops/oop.inline.hpp" |
| 77 | #include "runtime/atomic.hpp" |
| 78 | #include "runtime/handles.inline.hpp" |
| 79 | #include "runtime/java.hpp" |
| 80 | #include "runtime/safepoint.hpp" |
| 81 | #include "runtime/vmThread.hpp" |
| 82 | #include "services/memTracker.hpp" |
| 83 | #include "services/memoryService.hpp" |
| 84 | #include "utilities/align.hpp" |
| 85 | #include "utilities/debug.hpp" |
| 86 | #include "utilities/events.hpp" |
| 87 | #include "utilities/formatBuffer.hpp" |
| 88 | #include "utilities/macros.hpp" |
| 89 | #include "utilities/stack.inline.hpp" |
| 90 | #if INCLUDE_JVMCI1 |
| 91 | #include "jvmci/jvmci.hpp" |
| 92 | #endif |
| 93 | |
| 94 | #include <math.h> |
| 95 | |
| 96 | // All sizes are in HeapWords. |
| 97 | const size_t ParallelCompactData::Log2RegionSize = 16; // 64K words |
| 98 | const size_t ParallelCompactData::RegionSize = (size_t)1 << Log2RegionSize; |
| 99 | const size_t ParallelCompactData::RegionSizeBytes = |
| 100 | RegionSize << LogHeapWordSize; |
| 101 | const size_t ParallelCompactData::RegionSizeOffsetMask = RegionSize - 1; |
| 102 | const size_t ParallelCompactData::RegionAddrOffsetMask = RegionSizeBytes - 1; |
| 103 | const size_t ParallelCompactData::RegionAddrMask = ~RegionAddrOffsetMask; |
| 104 | |
| 105 | const size_t ParallelCompactData::Log2BlockSize = 7; // 128 words |
| 106 | const size_t ParallelCompactData::BlockSize = (size_t)1 << Log2BlockSize; |
| 107 | const size_t ParallelCompactData::BlockSizeBytes = |
| 108 | BlockSize << LogHeapWordSize; |
| 109 | const size_t ParallelCompactData::BlockSizeOffsetMask = BlockSize - 1; |
| 110 | const size_t ParallelCompactData::BlockAddrOffsetMask = BlockSizeBytes - 1; |
| 111 | const size_t ParallelCompactData::BlockAddrMask = ~BlockAddrOffsetMask; |
| 112 | |
| 113 | const size_t ParallelCompactData::BlocksPerRegion = RegionSize / BlockSize; |
| 114 | const size_t ParallelCompactData::Log2BlocksPerRegion = |
| 115 | Log2RegionSize - Log2BlockSize; |
| 116 | |
| 117 | const ParallelCompactData::RegionData::region_sz_t |
| 118 | ParallelCompactData::RegionData::dc_shift = 27; |
| 119 | |
| 120 | const ParallelCompactData::RegionData::region_sz_t |
| 121 | ParallelCompactData::RegionData::dc_mask = ~0U << dc_shift; |
| 122 | |
| 123 | const ParallelCompactData::RegionData::region_sz_t |
| 124 | ParallelCompactData::RegionData::dc_one = 0x1U << dc_shift; |
| 125 | |
| 126 | const ParallelCompactData::RegionData::region_sz_t |
| 127 | ParallelCompactData::RegionData::los_mask = ~dc_mask; |
| 128 | |
| 129 | const ParallelCompactData::RegionData::region_sz_t |
| 130 | ParallelCompactData::RegionData::dc_claimed = 0x8U << dc_shift; |
| 131 | |
| 132 | const ParallelCompactData::RegionData::region_sz_t |
| 133 | ParallelCompactData::RegionData::dc_completed = 0xcU << dc_shift; |
| 134 | |
| 135 | SpaceInfo PSParallelCompact::_space_info[PSParallelCompact::last_space_id]; |
| 136 | |
| 137 | SpanSubjectToDiscoveryClosure PSParallelCompact::_span_based_discoverer; |
| 138 | ReferenceProcessor* PSParallelCompact::_ref_processor = NULL__null; |
| 139 | |
| 140 | double PSParallelCompact::_dwl_mean; |
| 141 | double PSParallelCompact::_dwl_std_dev; |
| 142 | double PSParallelCompact::_dwl_first_term; |
| 143 | double PSParallelCompact::_dwl_adjustment; |
| 144 | #ifdef ASSERT1 |
| 145 | bool PSParallelCompact::_dwl_initialized = false; |
| 146 | #endif // #ifdef ASSERT |
| 147 | |
| 148 | void SplitInfo::record(size_t src_region_idx, size_t partial_obj_size, |
| 149 | HeapWord* destination) |
| 150 | { |
| 151 | assert(src_region_idx != 0, "invalid src_region_idx")do { if (!(src_region_idx != 0)) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 151, "assert(" "src_region_idx != 0" ") failed", "invalid src_region_idx" ); ::breakpoint(); } } while (0); |
| 152 | assert(partial_obj_size != 0, "invalid partial_obj_size argument")do { if (!(partial_obj_size != 0)) { (*g_assert_poison) = 'X' ;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 152, "assert(" "partial_obj_size != 0" ") failed", "invalid partial_obj_size argument" ); ::breakpoint(); } } while (0); |
| 153 | assert(destination != NULL, "invalid destination argument")do { if (!(destination != __null)) { (*g_assert_poison) = 'X' ;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 153, "assert(" "destination != __null" ") failed", "invalid destination argument" ); ::breakpoint(); } } while (0); |
| 154 | |
| 155 | _src_region_idx = src_region_idx; |
| 156 | _partial_obj_size = partial_obj_size; |
| 157 | _destination = destination; |
| 158 | |
| 159 | // These fields may not be updated below, so make sure they're clear. |
| 160 | assert(_dest_region_addr == NULL, "should have been cleared")do { if (!(_dest_region_addr == __null)) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 160, "assert(" "_dest_region_addr == __null" ") failed", "should have been cleared" ); ::breakpoint(); } } while (0); |
| 161 | assert(_first_src_addr == NULL, "should have been cleared")do { if (!(_first_src_addr == __null)) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 161, "assert(" "_first_src_addr == __null" ") failed", "should have been cleared" ); ::breakpoint(); } } while (0); |
| 162 | |
| 163 | // Determine the number of destination regions for the partial object. |
| 164 | HeapWord* const last_word = destination + partial_obj_size - 1; |
| 165 | const ParallelCompactData& sd = PSParallelCompact::summary_data(); |
| 166 | HeapWord* const beg_region_addr = sd.region_align_down(destination); |
| 167 | HeapWord* const end_region_addr = sd.region_align_down(last_word); |
| 168 | |
| 169 | if (beg_region_addr == end_region_addr) { |
| 170 | // One destination region. |
| 171 | _destination_count = 1; |
| 172 | if (end_region_addr == destination) { |
| 173 | // The destination falls on a region boundary, thus the first word of the |
| 174 | // partial object will be the first word copied to the destination region. |
| 175 | _dest_region_addr = end_region_addr; |
| 176 | _first_src_addr = sd.region_to_addr(src_region_idx); |
| 177 | } |
| 178 | } else { |
| 179 | // Two destination regions. When copied, the partial object will cross a |
| 180 | // destination region boundary, so a word somewhere within the partial |
| 181 | // object will be the first word copied to the second destination region. |
| 182 | _destination_count = 2; |
| 183 | _dest_region_addr = end_region_addr; |
| 184 | const size_t ofs = pointer_delta(end_region_addr, destination); |
| 185 | assert(ofs < _partial_obj_size, "sanity")do { if (!(ofs < _partial_obj_size)) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 185, "assert(" "ofs < _partial_obj_size" ") failed", "sanity" ); ::breakpoint(); } } while (0); |
| 186 | _first_src_addr = sd.region_to_addr(src_region_idx) + ofs; |
| 187 | } |
| 188 | } |
| 189 | |
| 190 | void SplitInfo::clear() |
| 191 | { |
| 192 | _src_region_idx = 0; |
| 193 | _partial_obj_size = 0; |
| 194 | _destination = NULL__null; |
| 195 | _destination_count = 0; |
| 196 | _dest_region_addr = NULL__null; |
| 197 | _first_src_addr = NULL__null; |
| 198 | assert(!is_valid(), "sanity")do { if (!(!is_valid())) { (*g_assert_poison) = 'X';; report_vm_error ("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 198, "assert(" "!is_valid()" ") failed", "sanity"); ::breakpoint (); } } while (0); |
| 199 | } |
| 200 | |
| 201 | #ifdef ASSERT1 |
| 202 | void SplitInfo::verify_clear() |
| 203 | { |
| 204 | assert(_src_region_idx == 0, "not clear")do { if (!(_src_region_idx == 0)) { (*g_assert_poison) = 'X'; ; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 204, "assert(" "_src_region_idx == 0" ") failed", "not clear" ); ::breakpoint(); } } while (0); |
| 205 | assert(_partial_obj_size == 0, "not clear")do { if (!(_partial_obj_size == 0)) { (*g_assert_poison) = 'X' ;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 205, "assert(" "_partial_obj_size == 0" ") failed", "not clear" ); ::breakpoint(); } } while (0); |
| 206 | assert(_destination == NULL, "not clear")do { if (!(_destination == __null)) { (*g_assert_poison) = 'X' ;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 206, "assert(" "_destination == __null" ") failed", "not clear" ); ::breakpoint(); } } while (0); |
| 207 | assert(_destination_count == 0, "not clear")do { if (!(_destination_count == 0)) { (*g_assert_poison) = 'X' ;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 207, "assert(" "_destination_count == 0" ") failed", "not clear" ); ::breakpoint(); } } while (0); |
| 208 | assert(_dest_region_addr == NULL, "not clear")do { if (!(_dest_region_addr == __null)) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 208, "assert(" "_dest_region_addr == __null" ") failed", "not clear" ); ::breakpoint(); } } while (0); |
| 209 | assert(_first_src_addr == NULL, "not clear")do { if (!(_first_src_addr == __null)) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 209, "assert(" "_first_src_addr == __null" ") failed", "not clear" ); ::breakpoint(); } } while (0); |
| 210 | } |
| 211 | #endif // #ifdef ASSERT |
| 212 | |
| 213 | |
| 214 | void PSParallelCompact::print_on_error(outputStream* st) { |
| 215 | _mark_bitmap.print_on_error(st); |
| 216 | } |
| 217 | |
| 218 | #ifndef PRODUCT |
| 219 | const char* PSParallelCompact::space_names[] = { |
| 220 | "old ", "eden", "from", "to " |
| 221 | }; |
| 222 | |
| 223 | void PSParallelCompact::print_region_ranges() { |
| 224 | if (!log_develop_is_enabled(Trace, gc, compaction)(LogImpl<(LogTag::_gc), (LogTag::_compaction), (LogTag::__NO_TAG ), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG) >::is_level(LogLevel::Trace))) { |
| 225 | return; |
| 226 | } |
| 227 | Log(gc, compaction)LogImpl<(LogTag::_gc), (LogTag::_compaction), (LogTag::__NO_TAG ), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG) > log; |
| 228 | ResourceMark rm; |
| 229 | LogStream ls(log.trace()); |
| 230 | Universe::print_on(&ls); |
| 231 | log.trace("space bottom top end new_top"); |
| 232 | log.trace("------ ---------- ---------- ---------- ----------"); |
| 233 | |
| 234 | for (unsigned int id = 0; id < last_space_id; ++id) { |
| 235 | const MutableSpace* space = _space_info[id].space(); |
| 236 | log.trace("%u %s " |
| 237 | SIZE_FORMAT_W(10)"%" "10" "l" "u" " " SIZE_FORMAT_W(10)"%" "10" "l" "u" " " |
| 238 | SIZE_FORMAT_W(10)"%" "10" "l" "u" " " SIZE_FORMAT_W(10)"%" "10" "l" "u" " ", |
| 239 | id, space_names[id], |
| 240 | summary_data().addr_to_region_idx(space->bottom()), |
| 241 | summary_data().addr_to_region_idx(space->top()), |
| 242 | summary_data().addr_to_region_idx(space->end()), |
| 243 | summary_data().addr_to_region_idx(_space_info[id].new_top())); |
| 244 | } |
| 245 | } |
| 246 | |
| 247 | void |
| 248 | print_generic_summary_region(size_t i, const ParallelCompactData::RegionData* c) |
| 249 | { |
| 250 | #define REGION_IDX_FORMAT SIZE_FORMAT_W(7)"%" "7" "l" "u" |
| 251 | #define REGION_DATA_FORMAT SIZE_FORMAT_W(5)"%" "5" "l" "u" |
| 252 | |
| 253 | ParallelCompactData& sd = PSParallelCompact::summary_data(); |
| 254 | size_t dci = c->destination() ? sd.addr_to_region_idx(c->destination()) : 0; |
| 255 | log_develop_trace(gc, compaction)(!(LogImpl<(LogTag::_gc), (LogTag::_compaction), (LogTag:: __NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG )>::is_level(LogLevel::Trace))) ? (void)0 : LogImpl<(LogTag ::_gc), (LogTag::_compaction), (LogTag::__NO_TAG), (LogTag::__NO_TAG ), (LogTag::__NO_TAG), (LogTag::__NO_TAG)>::write<LogLevel ::Trace>( |
| 256 | REGION_IDX_FORMAT " " PTR_FORMAT"0x%016" "l" "x" " " |
| 257 | REGION_IDX_FORMAT " " PTR_FORMAT"0x%016" "l" "x" " " |
| 258 | REGION_DATA_FORMAT " " REGION_DATA_FORMAT " " |
| 259 | REGION_DATA_FORMAT " " REGION_IDX_FORMAT " %d", |
| 260 | i, p2i(c->data_location()), dci, p2i(c->destination()), |
| 261 | c->partial_obj_size(), c->live_obj_size(), |
| 262 | c->data_size(), c->source_region(), c->destination_count()); |
| 263 | |
| 264 | #undef REGION_IDX_FORMAT |
| 265 | #undef REGION_DATA_FORMAT |
| 266 | } |
| 267 | |
| 268 | void |
| 269 | print_generic_summary_data(ParallelCompactData& summary_data, |
| 270 | HeapWord* const beg_addr, |
| 271 | HeapWord* const end_addr) |
| 272 | { |
| 273 | size_t total_words = 0; |
| 274 | size_t i = summary_data.addr_to_region_idx(beg_addr); |
| 275 | const size_t last = summary_data.addr_to_region_idx(end_addr); |
| 276 | HeapWord* pdest = 0; |
| 277 | |
| 278 | while (i < last) { |
| 279 | ParallelCompactData::RegionData* c = summary_data.region(i); |
| 280 | if (c->data_size() != 0 || c->destination() != pdest) { |
| 281 | print_generic_summary_region(i, c); |
| 282 | total_words += c->data_size(); |
| 283 | pdest = c->destination(); |
| 284 | } |
| 285 | ++i; |
| 286 | } |
| 287 | |
| 288 | log_develop_trace(gc, compaction)(!(LogImpl<(LogTag::_gc), (LogTag::_compaction), (LogTag:: __NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG )>::is_level(LogLevel::Trace))) ? (void)0 : LogImpl<(LogTag ::_gc), (LogTag::_compaction), (LogTag::__NO_TAG), (LogTag::__NO_TAG ), (LogTag::__NO_TAG), (LogTag::__NO_TAG)>::write<LogLevel ::Trace>("summary_data_bytes=" SIZE_FORMAT"%" "l" "u", total_words * HeapWordSize); |
| 289 | } |
| 290 | |
| 291 | void |
| 292 | PSParallelCompact::print_generic_summary_data(ParallelCompactData& summary_data, |
| 293 | HeapWord* const beg_addr, |
| 294 | HeapWord* const end_addr) { |
| 295 | ::print_generic_summary_data(summary_data,beg_addr, end_addr); |
| 296 | } |
| 297 | |
| 298 | void |
| 299 | print_generic_summary_data(ParallelCompactData& summary_data, |
| 300 | SpaceInfo* space_info) |
| 301 | { |
| 302 | if (!log_develop_is_enabled(Trace, gc, compaction)(LogImpl<(LogTag::_gc), (LogTag::_compaction), (LogTag::__NO_TAG ), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG) >::is_level(LogLevel::Trace))) { |
| 303 | return; |
| 304 | } |
| 305 | |
| 306 | for (unsigned int id = 0; id < PSParallelCompact::last_space_id; ++id) { |
| 307 | const MutableSpace* space = space_info[id].space(); |
| 308 | print_generic_summary_data(summary_data, space->bottom(), |
| 309 | MAX2(space->top(), space_info[id].new_top())); |
| 310 | } |
| 311 | } |
| 312 | |
| 313 | void |
| 314 | print_initial_summary_data(ParallelCompactData& summary_data, |
| 315 | const MutableSpace* space) { |
| 316 | if (space->top() == space->bottom()) { |
| 317 | return; |
| 318 | } |
| 319 | |
| 320 | const size_t region_size = ParallelCompactData::RegionSize; |
| 321 | typedef ParallelCompactData::RegionData RegionData; |
| 322 | HeapWord* const top_aligned_up = summary_data.region_align_up(space->top()); |
| 323 | const size_t end_region = summary_data.addr_to_region_idx(top_aligned_up); |
| 324 | const RegionData* c = summary_data.region(end_region - 1); |
| 325 | HeapWord* end_addr = c->destination() + c->data_size(); |
| 326 | const size_t live_in_space = pointer_delta(end_addr, space->bottom()); |
| 327 | |
| 328 | // Print (and count) the full regions at the beginning of the space. |
| 329 | size_t full_region_count = 0; |
| 330 | size_t i = summary_data.addr_to_region_idx(space->bottom()); |
| 331 | while (i < end_region && summary_data.region(i)->data_size() == region_size) { |
| 332 | ParallelCompactData::RegionData* c = summary_data.region(i); |
| 333 | log_develop_trace(gc, compaction)(!(LogImpl<(LogTag::_gc), (LogTag::_compaction), (LogTag:: __NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG )>::is_level(LogLevel::Trace))) ? (void)0 : LogImpl<(LogTag ::_gc), (LogTag::_compaction), (LogTag::__NO_TAG), (LogTag::__NO_TAG ), (LogTag::__NO_TAG), (LogTag::__NO_TAG)>::write<LogLevel ::Trace>( |
| 334 | SIZE_FORMAT_W(5)"%" "5" "l" "u" " " PTR_FORMAT"0x%016" "l" "x" " " SIZE_FORMAT_W(5)"%" "5" "l" "u" " " SIZE_FORMAT_W(5)"%" "5" "l" "u" " " SIZE_FORMAT_W(5)"%" "5" "l" "u" " " SIZE_FORMAT_W(5)"%" "5" "l" "u" " %d", |
| 335 | i, p2i(c->destination()), |
| 336 | c->partial_obj_size(), c->live_obj_size(), |
| 337 | c->data_size(), c->source_region(), c->destination_count()); |
| 338 | ++full_region_count; |
| 339 | ++i; |
| 340 | } |
| 341 | |
| 342 | size_t live_to_right = live_in_space - full_region_count * region_size; |
| 343 | |
| 344 | double max_reclaimed_ratio = 0.0; |
| 345 | size_t max_reclaimed_ratio_region = 0; |
| 346 | size_t max_dead_to_right = 0; |
| 347 | size_t max_live_to_right = 0; |
| 348 | |
| 349 | // Print the 'reclaimed ratio' for regions while there is something live in |
| 350 | // the region or to the right of it. The remaining regions are empty (and |
| 351 | // uninteresting), and computing the ratio will result in division by 0. |
| 352 | while (i < end_region && live_to_right > 0) { |
| 353 | c = summary_data.region(i); |
| 354 | HeapWord* const region_addr = summary_data.region_to_addr(i); |
| 355 | const size_t used_to_right = pointer_delta(space->top(), region_addr); |
| 356 | const size_t dead_to_right = used_to_right - live_to_right; |
| 357 | const double reclaimed_ratio = double(dead_to_right) / live_to_right; |
| 358 | |
| 359 | if (reclaimed_ratio > max_reclaimed_ratio) { |
| 360 | max_reclaimed_ratio = reclaimed_ratio; |
| 361 | max_reclaimed_ratio_region = i; |
| 362 | max_dead_to_right = dead_to_right; |
| 363 | max_live_to_right = live_to_right; |
| 364 | } |
| 365 | |
| 366 | ParallelCompactData::RegionData* c = summary_data.region(i); |
| 367 | log_develop_trace(gc, compaction)(!(LogImpl<(LogTag::_gc), (LogTag::_compaction), (LogTag:: __NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG )>::is_level(LogLevel::Trace))) ? (void)0 : LogImpl<(LogTag ::_gc), (LogTag::_compaction), (LogTag::__NO_TAG), (LogTag::__NO_TAG ), (LogTag::__NO_TAG), (LogTag::__NO_TAG)>::write<LogLevel ::Trace>( |
| 368 | SIZE_FORMAT_W(5)"%" "5" "l" "u" " " PTR_FORMAT"0x%016" "l" "x" " " SIZE_FORMAT_W(5)"%" "5" "l" "u" " " SIZE_FORMAT_W(5)"%" "5" "l" "u" " " SIZE_FORMAT_W(5)"%" "5" "l" "u" " " SIZE_FORMAT_W(5)"%" "5" "l" "u" " %d" |
| 369 | "%12.10f " SIZE_FORMAT_W(10)"%" "10" "l" "u" " " SIZE_FORMAT_W(10)"%" "10" "l" "u", |
| 370 | i, p2i(c->destination()), |
| 371 | c->partial_obj_size(), c->live_obj_size(), |
| 372 | c->data_size(), c->source_region(), c->destination_count(), |
| 373 | reclaimed_ratio, dead_to_right, live_to_right); |
| 374 | |
| 375 | |
| 376 | live_to_right -= c->data_size(); |
| 377 | ++i; |
| 378 | } |
| 379 | |
| 380 | // Any remaining regions are empty. Print one more if there is one. |
| 381 | if (i < end_region) { |
| 382 | ParallelCompactData::RegionData* c = summary_data.region(i); |
| 383 | log_develop_trace(gc, compaction)(!(LogImpl<(LogTag::_gc), (LogTag::_compaction), (LogTag:: __NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG )>::is_level(LogLevel::Trace))) ? (void)0 : LogImpl<(LogTag ::_gc), (LogTag::_compaction), (LogTag::__NO_TAG), (LogTag::__NO_TAG ), (LogTag::__NO_TAG), (LogTag::__NO_TAG)>::write<LogLevel ::Trace>( |
| 384 | SIZE_FORMAT_W(5)"%" "5" "l" "u" " " PTR_FORMAT"0x%016" "l" "x" " " SIZE_FORMAT_W(5)"%" "5" "l" "u" " " SIZE_FORMAT_W(5)"%" "5" "l" "u" " " SIZE_FORMAT_W(5)"%" "5" "l" "u" " " SIZE_FORMAT_W(5)"%" "5" "l" "u" " %d", |
| 385 | i, p2i(c->destination()), |
| 386 | c->partial_obj_size(), c->live_obj_size(), |
| 387 | c->data_size(), c->source_region(), c->destination_count()); |
| 388 | } |
| 389 | |
| 390 | log_develop_trace(gc, compaction)(!(LogImpl<(LogTag::_gc), (LogTag::_compaction), (LogTag:: __NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG )>::is_level(LogLevel::Trace))) ? (void)0 : LogImpl<(LogTag ::_gc), (LogTag::_compaction), (LogTag::__NO_TAG), (LogTag::__NO_TAG ), (LogTag::__NO_TAG), (LogTag::__NO_TAG)>::write<LogLevel ::Trace>("max: " SIZE_FORMAT_W(4)"%" "4" "l" "u" " d2r=" SIZE_FORMAT_W(10)"%" "10" "l" "u" " l2r=" SIZE_FORMAT_W(10)"%" "10" "l" "u" " max_ratio=%14.12f", |
| 391 | max_reclaimed_ratio_region, max_dead_to_right, max_live_to_right, max_reclaimed_ratio); |
| 392 | } |
| 393 | |
| 394 | void |
| 395 | print_initial_summary_data(ParallelCompactData& summary_data, |
| 396 | SpaceInfo* space_info) { |
| 397 | if (!log_develop_is_enabled(Trace, gc, compaction)(LogImpl<(LogTag::_gc), (LogTag::_compaction), (LogTag::__NO_TAG ), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG) >::is_level(LogLevel::Trace))) { |
| 398 | return; |
| 399 | } |
| 400 | |
| 401 | unsigned int id = PSParallelCompact::old_space_id; |
| 402 | const MutableSpace* space; |
| 403 | do { |
| 404 | space = space_info[id].space(); |
| 405 | print_initial_summary_data(summary_data, space); |
| 406 | } while (++id < PSParallelCompact::eden_space_id); |
| 407 | |
| 408 | do { |
| 409 | space = space_info[id].space(); |
| 410 | print_generic_summary_data(summary_data, space->bottom(), space->top()); |
| 411 | } while (++id < PSParallelCompact::last_space_id); |
| 412 | } |
| 413 | #endif // #ifndef PRODUCT |
| 414 | |
| 415 | ParallelCompactData::ParallelCompactData() : |
| 416 | _region_start(NULL__null), |
| 417 | DEBUG_ONLY(_region_end(NULL) COMMA)_region_end(__null) , |
| 418 | _region_vspace(NULL__null), |
| 419 | _reserved_byte_size(0), |
| 420 | _region_data(NULL__null), |
| 421 | _region_count(0), |
| 422 | _block_vspace(NULL__null), |
| 423 | _block_data(NULL__null), |
| 424 | _block_count(0) {} |
| 425 | |
| 426 | bool ParallelCompactData::initialize(MemRegion covered_region) |
| 427 | { |
| 428 | _region_start = covered_region.start(); |
| 429 | const size_t region_size = covered_region.word_size(); |
| 430 | DEBUG_ONLY(_region_end = _region_start + region_size;)_region_end = _region_start + region_size; |
| 431 | |
| 432 | assert(region_align_down(_region_start) == _region_start,do { if (!(region_align_down(_region_start) == _region_start) ) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 433, "assert(" "region_align_down(_region_start) == _region_start" ") failed", "region start not aligned"); ::breakpoint(); } } while (0) |
| 433 | "region start not aligned")do { if (!(region_align_down(_region_start) == _region_start) ) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 433, "assert(" "region_align_down(_region_start) == _region_start" ") failed", "region start not aligned"); ::breakpoint(); } } while (0); |
| 434 | assert((region_size & RegionSizeOffsetMask) == 0,do { if (!((region_size & RegionSizeOffsetMask) == 0)) { ( *g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 435, "assert(" "(region_size & RegionSizeOffsetMask) == 0" ") failed", "region size not a multiple of RegionSize"); ::breakpoint (); } } while (0) |
| 435 | "region size not a multiple of RegionSize")do { if (!((region_size & RegionSizeOffsetMask) == 0)) { ( *g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 435, "assert(" "(region_size & RegionSizeOffsetMask) == 0" ") failed", "region size not a multiple of RegionSize"); ::breakpoint (); } } while (0); |
| 436 | |
| 437 | bool result = initialize_region_data(region_size) && initialize_block_data(); |
| 438 | return result; |
| 439 | } |
| 440 | |
| 441 | PSVirtualSpace* |
| 442 | ParallelCompactData::create_vspace(size_t count, size_t element_size) |
| 443 | { |
| 444 | const size_t raw_bytes = count * element_size; |
| 445 | const size_t page_sz = os::page_size_for_region_aligned(raw_bytes, 10); |
| 446 | const size_t granularity = os::vm_allocation_granularity(); |
| 447 | _reserved_byte_size = align_up(raw_bytes, MAX2(page_sz, granularity)); |
| 448 | |
| 449 | const size_t rs_align = page_sz == (size_t) os::vm_page_size() ? 0 : |
| 450 | MAX2(page_sz, granularity); |
| 451 | ReservedSpace rs(_reserved_byte_size, rs_align, page_sz); |
| 452 | os::trace_page_sizes("Parallel Compact Data", raw_bytes, raw_bytes, page_sz, rs.base(), |
| 453 | rs.size()); |
| 454 | |
| 455 | MemTracker::record_virtual_memory_type((address)rs.base(), mtGC); |
| 456 | |
| 457 | PSVirtualSpace* vspace = new PSVirtualSpace(rs, page_sz); |
| 458 | if (vspace != 0) { |
| 459 | if (vspace->expand_by(_reserved_byte_size)) { |
| 460 | return vspace; |
| 461 | } |
| 462 | delete vspace; |
| 463 | // Release memory reserved in the space. |
| 464 | rs.release(); |
| 465 | } |
| 466 | |
| 467 | return 0; |
| 468 | } |
| 469 | |
| 470 | bool ParallelCompactData::initialize_region_data(size_t region_size) |
| 471 | { |
| 472 | const size_t count = (region_size + RegionSizeOffsetMask) >> Log2RegionSize; |
| 473 | _region_vspace = create_vspace(count, sizeof(RegionData)); |
| 474 | if (_region_vspace != 0) { |
| 475 | _region_data = (RegionData*)_region_vspace->reserved_low_addr(); |
| 476 | _region_count = count; |
| 477 | return true; |
| 478 | } |
| 479 | return false; |
| 480 | } |
| 481 | |
| 482 | bool ParallelCompactData::initialize_block_data() |
| 483 | { |
| 484 | assert(_region_count != 0, "region data must be initialized first")do { if (!(_region_count != 0)) { (*g_assert_poison) = 'X';; report_vm_error ("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 484, "assert(" "_region_count != 0" ") failed", "region data must be initialized first" ); ::breakpoint(); } } while (0); |
| 485 | const size_t count = _region_count << Log2BlocksPerRegion; |
| 486 | _block_vspace = create_vspace(count, sizeof(BlockData)); |
| 487 | if (_block_vspace != 0) { |
| 488 | _block_data = (BlockData*)_block_vspace->reserved_low_addr(); |
| 489 | _block_count = count; |
| 490 | return true; |
| 491 | } |
| 492 | return false; |
| 493 | } |
| 494 | |
| 495 | void ParallelCompactData::clear() |
| 496 | { |
| 497 | memset(_region_data, 0, _region_vspace->committed_size()); |
| 498 | memset(_block_data, 0, _block_vspace->committed_size()); |
| 499 | } |
| 500 | |
| 501 | void ParallelCompactData::clear_range(size_t beg_region, size_t end_region) { |
| 502 | assert(beg_region <= _region_count, "beg_region out of range")do { if (!(beg_region <= _region_count)) { (*g_assert_poison ) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 502, "assert(" "beg_region <= _region_count" ") failed", "beg_region out of range"); ::breakpoint(); } } while (0); |
| 503 | assert(end_region <= _region_count, "end_region out of range")do { if (!(end_region <= _region_count)) { (*g_assert_poison ) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 503, "assert(" "end_region <= _region_count" ") failed", "end_region out of range"); ::breakpoint(); } } while (0); |
| 504 | assert(RegionSize % BlockSize == 0, "RegionSize not a multiple of BlockSize")do { if (!(RegionSize % BlockSize == 0)) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 504, "assert(" "RegionSize % BlockSize == 0" ") failed", "RegionSize not a multiple of BlockSize" ); ::breakpoint(); } } while (0); |
| 505 | |
| 506 | const size_t region_cnt = end_region - beg_region; |
| 507 | memset(_region_data + beg_region, 0, region_cnt * sizeof(RegionData)); |
| 508 | |
| 509 | const size_t beg_block = beg_region * BlocksPerRegion; |
| 510 | const size_t block_cnt = region_cnt * BlocksPerRegion; |
| 511 | memset(_block_data + beg_block, 0, block_cnt * sizeof(BlockData)); |
| 512 | } |
| 513 | |
| 514 | HeapWord* ParallelCompactData::partial_obj_end(size_t region_idx) const |
| 515 | { |
| 516 | const RegionData* cur_cp = region(region_idx); |
| 517 | const RegionData* const end_cp = region(region_count() - 1); |
| 518 | |
| 519 | HeapWord* result = region_to_addr(region_idx); |
| 520 | if (cur_cp < end_cp) { |
| 521 | do { |
| 522 | result += cur_cp->partial_obj_size(); |
| 523 | } while (cur_cp->partial_obj_size() == RegionSize && ++cur_cp < end_cp); |
| 524 | } |
| 525 | return result; |
| 526 | } |
| 527 | |
| 528 | void ParallelCompactData::add_obj(HeapWord* addr, size_t len) |
| 529 | { |
| 530 | const size_t obj_ofs = pointer_delta(addr, _region_start); |
| 531 | const size_t beg_region = obj_ofs >> Log2RegionSize; |
| 532 | // end_region is inclusive |
| 533 | const size_t end_region = (obj_ofs + len - 1) >> Log2RegionSize; |
| 534 | |
| 535 | if (beg_region == end_region) { |
| 536 | // All in one region. |
| 537 | _region_data[beg_region].add_live_obj(len); |
| 538 | return; |
| 539 | } |
| 540 | |
| 541 | // First region. |
| 542 | const size_t beg_ofs = region_offset(addr); |
| 543 | _region_data[beg_region].add_live_obj(RegionSize - beg_ofs); |
| 544 | |
| 545 | // Middle regions--completely spanned by this object. |
| 546 | for (size_t region = beg_region + 1; region < end_region; ++region) { |
| 547 | _region_data[region].set_partial_obj_size(RegionSize); |
| 548 | _region_data[region].set_partial_obj_addr(addr); |
| 549 | } |
| 550 | |
| 551 | // Last region. |
| 552 | const size_t end_ofs = region_offset(addr + len - 1); |
| 553 | _region_data[end_region].set_partial_obj_size(end_ofs + 1); |
| 554 | _region_data[end_region].set_partial_obj_addr(addr); |
| 555 | } |
| 556 | |
| 557 | void |
| 558 | ParallelCompactData::summarize_dense_prefix(HeapWord* beg, HeapWord* end) |
| 559 | { |
| 560 | assert(is_region_aligned(beg), "not RegionSize aligned")do { if (!(is_region_aligned(beg))) { (*g_assert_poison) = 'X' ;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 560, "assert(" "is_region_aligned(beg)" ") failed", "not RegionSize aligned" ); ::breakpoint(); } } while (0); |
| 561 | assert(is_region_aligned(end), "not RegionSize aligned")do { if (!(is_region_aligned(end))) { (*g_assert_poison) = 'X' ;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 561, "assert(" "is_region_aligned(end)" ") failed", "not RegionSize aligned" ); ::breakpoint(); } } while (0); |
| 562 | |
| 563 | size_t cur_region = addr_to_region_idx(beg); |
| 564 | const size_t end_region = addr_to_region_idx(end); |
| 565 | HeapWord* addr = beg; |
| 566 | while (cur_region < end_region) { |
| 567 | _region_data[cur_region].set_destination(addr); |
| 568 | _region_data[cur_region].set_destination_count(0); |
| 569 | _region_data[cur_region].set_source_region(cur_region); |
| 570 | _region_data[cur_region].set_data_location(addr); |
| 571 | |
| 572 | // Update live_obj_size so the region appears completely full. |
| 573 | size_t live_size = RegionSize - _region_data[cur_region].partial_obj_size(); |
| 574 | _region_data[cur_region].set_live_obj_size(live_size); |
| 575 | |
| 576 | ++cur_region; |
| 577 | addr += RegionSize; |
| 578 | } |
| 579 | } |
| 580 | |
| 581 | // Find the point at which a space can be split and, if necessary, record the |
| 582 | // split point. |
| 583 | // |
| 584 | // If the current src region (which overflowed the destination space) doesn't |
| 585 | // have a partial object, the split point is at the beginning of the current src |
| 586 | // region (an "easy" split, no extra bookkeeping required). |
| 587 | // |
| 588 | // If the current src region has a partial object, the split point is in the |
| 589 | // region where that partial object starts (call it the split_region). If |
| 590 | // split_region has a partial object, then the split point is just after that |
| 591 | // partial object (a "hard" split where we have to record the split data and |
| 592 | // zero the partial_obj_size field). With a "hard" split, we know that the |
| 593 | // partial_obj ends within split_region because the partial object that caused |
| 594 | // the overflow starts in split_region. If split_region doesn't have a partial |
| 595 | // obj, then the split is at the beginning of split_region (another "easy" |
| 596 | // split). |
| 597 | HeapWord* |
| 598 | ParallelCompactData::summarize_split_space(size_t src_region, |
| 599 | SplitInfo& split_info, |
| 600 | HeapWord* destination, |
| 601 | HeapWord* target_end, |
| 602 | HeapWord** target_next) |
| 603 | { |
| 604 | assert(destination <= target_end, "sanity")do { if (!(destination <= target_end)) { (*g_assert_poison ) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 604, "assert(" "destination <= target_end" ") failed", "sanity" ); ::breakpoint(); } } while (0); |
| 605 | assert(destination + _region_data[src_region].data_size() > target_end,do { if (!(destination + _region_data[src_region].data_size() > target_end)) { (*g_assert_poison) = 'X';; report_vm_error ("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 606, "assert(" "destination + _region_data[src_region].data_size() > target_end" ") failed", "region should not fit into target space"); ::breakpoint (); } } while (0) |
| 606 | "region should not fit into target space")do { if (!(destination + _region_data[src_region].data_size() > target_end)) { (*g_assert_poison) = 'X';; report_vm_error ("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 606, "assert(" "destination + _region_data[src_region].data_size() > target_end" ") failed", "region should not fit into target space"); ::breakpoint (); } } while (0); |
| 607 | assert(is_region_aligned(target_end), "sanity")do { if (!(is_region_aligned(target_end))) { (*g_assert_poison ) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 607, "assert(" "is_region_aligned(target_end)" ") failed", "sanity" ); ::breakpoint(); } } while (0); |
| 608 | |
| 609 | size_t split_region = src_region; |
| 610 | HeapWord* split_destination = destination; |
| 611 | size_t partial_obj_size = _region_data[src_region].partial_obj_size(); |
| 612 | |
| 613 | if (destination + partial_obj_size > target_end) { |
| 614 | // The split point is just after the partial object (if any) in the |
| 615 | // src_region that contains the start of the object that overflowed the |
| 616 | // destination space. |
| 617 | // |
| 618 | // Find the start of the "overflow" object and set split_region to the |
| 619 | // region containing it. |
| 620 | HeapWord* const overflow_obj = _region_data[src_region].partial_obj_addr(); |
| 621 | split_region = addr_to_region_idx(overflow_obj); |
| 622 | |
| 623 | // Clear the source_region field of all destination regions whose first word |
| 624 | // came from data after the split point (a non-null source_region field |
| 625 | // implies a region must be filled). |
| 626 | // |
| 627 | // An alternative to the simple loop below: clear during post_compact(), |
| 628 | // which uses memcpy instead of individual stores, and is easy to |
| 629 | // parallelize. (The downside is that it clears the entire RegionData |
| 630 | // object as opposed to just one field.) |
| 631 | // |
| 632 | // post_compact() would have to clear the summary data up to the highest |
| 633 | // address that was written during the summary phase, which would be |
| 634 | // |
| 635 | // max(top, max(new_top, clear_top)) |
| 636 | // |
| 637 | // where clear_top is a new field in SpaceInfo. Would have to set clear_top |
| 638 | // to target_end. |
| 639 | const RegionData* const sr = region(split_region); |
| 640 | const size_t beg_idx = |
| 641 | addr_to_region_idx(region_align_up(sr->destination() + |
| 642 | sr->partial_obj_size())); |
| 643 | const size_t end_idx = addr_to_region_idx(target_end); |
| 644 | |
| 645 | log_develop_trace(gc, compaction)(!(LogImpl<(LogTag::_gc), (LogTag::_compaction), (LogTag:: __NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG )>::is_level(LogLevel::Trace))) ? (void)0 : LogImpl<(LogTag ::_gc), (LogTag::_compaction), (LogTag::__NO_TAG), (LogTag::__NO_TAG ), (LogTag::__NO_TAG), (LogTag::__NO_TAG)>::write<LogLevel ::Trace>("split: clearing source_region field in [" SIZE_FORMAT"%" "l" "u" ", " SIZE_FORMAT"%" "l" "u" ")", beg_idx, end_idx); |
| 646 | for (size_t idx = beg_idx; idx < end_idx; ++idx) { |
| 647 | _region_data[idx].set_source_region(0); |
| 648 | } |
| 649 | |
| 650 | // Set split_destination and partial_obj_size to reflect the split region. |
| 651 | split_destination = sr->destination(); |
| 652 | partial_obj_size = sr->partial_obj_size(); |
| 653 | } |
| 654 | |
| 655 | // The split is recorded only if a partial object extends onto the region. |
| 656 | if (partial_obj_size != 0) { |
| 657 | _region_data[split_region].set_partial_obj_size(0); |
| 658 | split_info.record(split_region, partial_obj_size, split_destination); |
| 659 | } |
| 660 | |
| 661 | // Setup the continuation addresses. |
| 662 | *target_next = split_destination + partial_obj_size; |
| 663 | HeapWord* const source_next = region_to_addr(split_region) + partial_obj_size; |
| 664 | |
| 665 | if (log_develop_is_enabled(Trace, gc, compaction)(LogImpl<(LogTag::_gc), (LogTag::_compaction), (LogTag::__NO_TAG ), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG) >::is_level(LogLevel::Trace))) { |
| 666 | const char * split_type = partial_obj_size == 0 ? "easy" : "hard"; |
| 667 | log_develop_trace(gc, compaction)(!(LogImpl<(LogTag::_gc), (LogTag::_compaction), (LogTag:: __NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG )>::is_level(LogLevel::Trace))) ? (void)0 : LogImpl<(LogTag ::_gc), (LogTag::_compaction), (LogTag::__NO_TAG), (LogTag::__NO_TAG ), (LogTag::__NO_TAG), (LogTag::__NO_TAG)>::write<LogLevel ::Trace>("%s split: src=" PTR_FORMAT"0x%016" "l" "x" " src_c=" SIZE_FORMAT"%" "l" "u" " pos=" SIZE_FORMAT"%" "l" "u", |
| 668 | split_type, p2i(source_next), split_region, partial_obj_size); |
| 669 | log_develop_trace(gc, compaction)(!(LogImpl<(LogTag::_gc), (LogTag::_compaction), (LogTag:: __NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG )>::is_level(LogLevel::Trace))) ? (void)0 : LogImpl<(LogTag ::_gc), (LogTag::_compaction), (LogTag::__NO_TAG), (LogTag::__NO_TAG ), (LogTag::__NO_TAG), (LogTag::__NO_TAG)>::write<LogLevel ::Trace>("%s split: dst=" PTR_FORMAT"0x%016" "l" "x" " dst_c=" SIZE_FORMAT"%" "l" "u" " tn=" PTR_FORMAT"0x%016" "l" "x", |
| 670 | split_type, p2i(split_destination), |
| 671 | addr_to_region_idx(split_destination), |
| 672 | p2i(*target_next)); |
| 673 | |
| 674 | if (partial_obj_size != 0) { |
| 675 | HeapWord* const po_beg = split_info.destination(); |
| 676 | HeapWord* const po_end = po_beg + split_info.partial_obj_size(); |
| 677 | log_develop_trace(gc, compaction)(!(LogImpl<(LogTag::_gc), (LogTag::_compaction), (LogTag:: __NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG )>::is_level(LogLevel::Trace))) ? (void)0 : LogImpl<(LogTag ::_gc), (LogTag::_compaction), (LogTag::__NO_TAG), (LogTag::__NO_TAG ), (LogTag::__NO_TAG), (LogTag::__NO_TAG)>::write<LogLevel ::Trace>("%s split: po_beg=" PTR_FORMAT"0x%016" "l" "x" " " SIZE_FORMAT"%" "l" "u" " po_end=" PTR_FORMAT"0x%016" "l" "x" " " SIZE_FORMAT"%" "l" "u", |
| 678 | split_type, |
| 679 | p2i(po_beg), addr_to_region_idx(po_beg), |
| 680 | p2i(po_end), addr_to_region_idx(po_end)); |
| 681 | } |
| 682 | } |
| 683 | |
| 684 | return source_next; |
| 685 | } |
| 686 | |
| 687 | bool ParallelCompactData::summarize(SplitInfo& split_info, |
| 688 | HeapWord* source_beg, HeapWord* source_end, |
| 689 | HeapWord** source_next, |
| 690 | HeapWord* target_beg, HeapWord* target_end, |
| 691 | HeapWord** target_next) |
| 692 | { |
| 693 | HeapWord* const source_next_val = source_next == NULL__null ? NULL__null : *source_next; |
| 694 | log_develop_trace(gc, compaction)(!(LogImpl<(LogTag::_gc), (LogTag::_compaction), (LogTag:: __NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG )>::is_level(LogLevel::Trace))) ? (void)0 : LogImpl<(LogTag ::_gc), (LogTag::_compaction), (LogTag::__NO_TAG), (LogTag::__NO_TAG ), (LogTag::__NO_TAG), (LogTag::__NO_TAG)>::write<LogLevel ::Trace>( |
| 695 | "sb=" PTR_FORMAT"0x%016" "l" "x" " se=" PTR_FORMAT"0x%016" "l" "x" " sn=" PTR_FORMAT"0x%016" "l" "x" |
| 696 | "tb=" PTR_FORMAT"0x%016" "l" "x" " te=" PTR_FORMAT"0x%016" "l" "x" " tn=" PTR_FORMAT"0x%016" "l" "x", |
| 697 | p2i(source_beg), p2i(source_end), p2i(source_next_val), |
| 698 | p2i(target_beg), p2i(target_end), p2i(*target_next)); |
| 699 | |
| 700 | size_t cur_region = addr_to_region_idx(source_beg); |
| 701 | const size_t end_region = addr_to_region_idx(region_align_up(source_end)); |
| 702 | |
| 703 | HeapWord *dest_addr = target_beg; |
| 704 | while (cur_region < end_region) { |
| 705 | // The destination must be set even if the region has no data. |
| 706 | _region_data[cur_region].set_destination(dest_addr); |
| 707 | |
| 708 | size_t words = _region_data[cur_region].data_size(); |
| 709 | if (words > 0) { |
| 710 | // If cur_region does not fit entirely into the target space, find a point |
| 711 | // at which the source space can be 'split' so that part is copied to the |
| 712 | // target space and the rest is copied elsewhere. |
| 713 | if (dest_addr + words > target_end) { |
| 714 | assert(source_next != NULL, "source_next is NULL when splitting")do { if (!(source_next != __null)) { (*g_assert_poison) = 'X' ;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 714, "assert(" "source_next != __null" ") failed", "source_next is NULL when splitting" ); ::breakpoint(); } } while (0); |
| 715 | *source_next = summarize_split_space(cur_region, split_info, dest_addr, |
| 716 | target_end, target_next); |
| 717 | return false; |
| 718 | } |
| 719 | |
| 720 | // Compute the destination_count for cur_region, and if necessary, update |
| 721 | // source_region for a destination region. The source_region field is |
| 722 | // updated if cur_region is the first (left-most) region to be copied to a |
| 723 | // destination region. |
| 724 | // |
| 725 | // The destination_count calculation is a bit subtle. A region that has |
| 726 | // data that compacts into itself does not count itself as a destination. |
| 727 | // This maintains the invariant that a zero count means the region is |
| 728 | // available and can be claimed and then filled. |
| 729 | uint destination_count = 0; |
| 730 | if (split_info.is_split(cur_region)) { |
| 731 | // The current region has been split: the partial object will be copied |
| 732 | // to one destination space and the remaining data will be copied to |
| 733 | // another destination space. Adjust the initial destination_count and, |
| 734 | // if necessary, set the source_region field if the partial object will |
| 735 | // cross a destination region boundary. |
| 736 | destination_count = split_info.destination_count(); |
| 737 | if (destination_count == 2) { |
| 738 | size_t dest_idx = addr_to_region_idx(split_info.dest_region_addr()); |
| 739 | _region_data[dest_idx].set_source_region(cur_region); |
| 740 | } |
| 741 | } |
| 742 | |
| 743 | HeapWord* const last_addr = dest_addr + words - 1; |
| 744 | const size_t dest_region_1 = addr_to_region_idx(dest_addr); |
| 745 | const size_t dest_region_2 = addr_to_region_idx(last_addr); |
| 746 | |
| 747 | // Initially assume that the destination regions will be the same and |
| 748 | // adjust the value below if necessary. Under this assumption, if |
| 749 | // cur_region == dest_region_2, then cur_region will be compacted |
| 750 | // completely into itself. |
| 751 | destination_count += cur_region == dest_region_2 ? 0 : 1; |
| 752 | if (dest_region_1 != dest_region_2) { |
| 753 | // Destination regions differ; adjust destination_count. |
| 754 | destination_count += 1; |
| 755 | // Data from cur_region will be copied to the start of dest_region_2. |
| 756 | _region_data[dest_region_2].set_source_region(cur_region); |
| 757 | } else if (is_region_aligned(dest_addr)) { |
| 758 | // Data from cur_region will be copied to the start of the destination |
| 759 | // region. |
| 760 | _region_data[dest_region_1].set_source_region(cur_region); |
| 761 | } |
| 762 | |
| 763 | _region_data[cur_region].set_destination_count(destination_count); |
| 764 | _region_data[cur_region].set_data_location(region_to_addr(cur_region)); |
| 765 | dest_addr += words; |
| 766 | } |
| 767 | |
| 768 | ++cur_region; |
| 769 | } |
| 770 | |
| 771 | *target_next = dest_addr; |
| 772 | return true; |
| 773 | } |
| 774 | |
| 775 | HeapWord* ParallelCompactData::calc_new_pointer(HeapWord* addr, ParCompactionManager* cm) const { |
| 776 | assert(addr != NULL, "Should detect NULL oop earlier")do { if (!(addr != __null)) { (*g_assert_poison) = 'X';; report_vm_error ("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 776, "assert(" "addr != __null" ") failed", "Should detect NULL oop earlier" ); ::breakpoint(); } } while (0); |
| 777 | assert(ParallelScavengeHeap::heap()->is_in(addr), "not in heap")do { if (!(ParallelScavengeHeap::heap()->is_in(addr))) { ( *g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 777, "assert(" "ParallelScavengeHeap::heap()->is_in(addr)" ") failed", "not in heap"); ::breakpoint(); } } while (0); |
| 778 | assert(PSParallelCompact::mark_bitmap()->is_marked(addr), "not marked")do { if (!(PSParallelCompact::mark_bitmap()->is_marked(addr ))) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 778, "assert(" "PSParallelCompact::mark_bitmap()->is_marked(addr)" ") failed", "not marked"); ::breakpoint(); } } while (0); |
| 779 | |
| 780 | // Region covering the object. |
| 781 | RegionData* const region_ptr = addr_to_region_ptr(addr); |
| 782 | HeapWord* result = region_ptr->destination(); |
| 783 | |
| 784 | // If the entire Region is live, the new location is region->destination + the |
| 785 | // offset of the object within in the Region. |
| 786 | |
| 787 | // Run some performance tests to determine if this special case pays off. It |
| 788 | // is worth it for pointers into the dense prefix. If the optimization to |
| 789 | // avoid pointer updates in regions that only point to the dense prefix is |
| 790 | // ever implemented, this should be revisited. |
| 791 | if (region_ptr->data_size() == RegionSize) { |
| 792 | result += region_offset(addr); |
| 793 | return result; |
| 794 | } |
| 795 | |
| 796 | // Otherwise, the new location is region->destination + block offset + the |
| 797 | // number of live words in the Block that are (a) to the left of addr and (b) |
| 798 | // due to objects that start in the Block. |
| 799 | |
| 800 | // Fill in the block table if necessary. This is unsynchronized, so multiple |
| 801 | // threads may fill the block table for a region (harmless, since it is |
| 802 | // idempotent). |
| 803 | if (!region_ptr->blocks_filled()) { |
| 804 | PSParallelCompact::fill_blocks(addr_to_region_idx(addr)); |
| 805 | region_ptr->set_blocks_filled(); |
| 806 | } |
| 807 | |
| 808 | HeapWord* const search_start = block_align_down(addr); |
| 809 | const size_t block_offset = addr_to_block_ptr(addr)->offset(); |
| 810 | |
| 811 | const ParMarkBitMap* bitmap = PSParallelCompact::mark_bitmap(); |
| 812 | const size_t live = bitmap->live_words_in_range(cm, search_start, cast_to_oop(addr)); |
| 813 | result += block_offset + live; |
| 814 | DEBUG_ONLY(PSParallelCompact::check_new_location(addr, result))PSParallelCompact::check_new_location(addr, result); |
| 815 | return result; |
| 816 | } |
| 817 | |
| 818 | #ifdef ASSERT1 |
| 819 | void ParallelCompactData::verify_clear(const PSVirtualSpace* vspace) |
| 820 | { |
| 821 | const size_t* const beg = (const size_t*)vspace->committed_low_addr(); |
| 822 | const size_t* const end = (const size_t*)vspace->committed_high_addr(); |
| 823 | for (const size_t* p = beg; p < end; ++p) { |
| 824 | assert(*p == 0, "not zero")do { if (!(*p == 0)) { (*g_assert_poison) = 'X';; report_vm_error ("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 824, "assert(" "*p == 0" ") failed", "not zero"); ::breakpoint (); } } while (0); |
| 825 | } |
| 826 | } |
| 827 | |
| 828 | void ParallelCompactData::verify_clear() |
| 829 | { |
| 830 | verify_clear(_region_vspace); |
| 831 | verify_clear(_block_vspace); |
| 832 | } |
| 833 | #endif // #ifdef ASSERT |
| 834 | |
| 835 | STWGCTimer PSParallelCompact::_gc_timer; |
| 836 | ParallelOldTracer PSParallelCompact::_gc_tracer; |
| 837 | elapsedTimer PSParallelCompact::_accumulated_time; |
| 838 | unsigned int PSParallelCompact::_total_invocations = 0; |
| 839 | unsigned int PSParallelCompact::_maximum_compaction_gc_num = 0; |
| 840 | CollectorCounters* PSParallelCompact::_counters = NULL__null; |
| 841 | ParMarkBitMap PSParallelCompact::_mark_bitmap; |
| 842 | ParallelCompactData PSParallelCompact::_summary_data; |
| 843 | |
| 844 | PSParallelCompact::IsAliveClosure PSParallelCompact::_is_alive_closure; |
| 845 | |
| 846 | bool PSParallelCompact::IsAliveClosure::do_object_b(oop p) { return mark_bitmap()->is_marked(p); } |
| 847 | |
| 848 | class PCReferenceProcessor: public ReferenceProcessor { |
| 849 | public: |
| 850 | PCReferenceProcessor( |
| 851 | BoolObjectClosure* is_subject_to_discovery, |
| 852 | BoolObjectClosure* is_alive_non_header) : |
| 853 | ReferenceProcessor(is_subject_to_discovery, |
| 854 | ParallelGCThreads, // mt processing degree |
| 855 | ParallelGCThreads, // mt discovery degree |
| 856 | true, // atomic_discovery |
| 857 | is_alive_non_header) { |
| 858 | } |
| 859 | |
| 860 | template<typename T> bool discover(oop obj, ReferenceType type) { |
| 861 | T* referent_addr = (T*) java_lang_ref_Reference::referent_addr_raw(obj); |
| 862 | T heap_oop = RawAccess<>::oop_load(referent_addr); |
| 863 | oop referent = CompressedOops::decode_not_null(heap_oop); |
| 864 | return PSParallelCompact::mark_bitmap()->is_unmarked(referent) |
| 865 | && ReferenceProcessor::discover_reference(obj, type); |
| 866 | } |
| 867 | virtual bool discover_reference(oop obj, ReferenceType type) { |
| 868 | if (UseCompressedOops) { |
| 869 | return discover<narrowOop>(obj, type); |
| 870 | } else { |
| 871 | return discover<oop>(obj, type); |
| 872 | } |
| 873 | } |
| 874 | }; |
| 875 | |
| 876 | void PSParallelCompact::post_initialize() { |
| 877 | ParallelScavengeHeap* heap = ParallelScavengeHeap::heap(); |
| 878 | _span_based_discoverer.set_span(heap->reserved_region()); |
| 879 | _ref_processor = |
| 880 | new PCReferenceProcessor(&_span_based_discoverer, |
| 881 | &_is_alive_closure); // non-header is alive closure |
| 882 | |
| 883 | _counters = new CollectorCounters("Parallel full collection pauses", 1); |
| 884 | |
| 885 | // Initialize static fields in ParCompactionManager. |
| 886 | ParCompactionManager::initialize(mark_bitmap()); |
| 887 | } |
| 888 | |
| 889 | bool PSParallelCompact::initialize() { |
| 890 | ParallelScavengeHeap* heap = ParallelScavengeHeap::heap(); |
| 891 | MemRegion mr = heap->reserved_region(); |
| 892 | |
| 893 | // Was the old gen get allocated successfully? |
| 894 | if (!heap->old_gen()->is_allocated()) { |
| 895 | return false; |
| 896 | } |
| 897 | |
| 898 | initialize_space_info(); |
| 899 | initialize_dead_wood_limiter(); |
| 900 | |
| 901 | if (!_mark_bitmap.initialize(mr)) { |
| 902 | vm_shutdown_during_initialization( |
| 903 | err_msg("Unable to allocate " SIZE_FORMAT"%" "l" "u" "KB bitmaps for parallel " |
| 904 | "garbage collection for the requested " SIZE_FORMAT"%" "l" "u" "KB heap.", |
| 905 | _mark_bitmap.reserved_byte_size()/K, mr.byte_size()/K)); |
| 906 | return false; |
| 907 | } |
| 908 | |
| 909 | if (!_summary_data.initialize(mr)) { |
| 910 | vm_shutdown_during_initialization( |
| 911 | err_msg("Unable to allocate " SIZE_FORMAT"%" "l" "u" "KB card tables for parallel " |
| 912 | "garbage collection for the requested " SIZE_FORMAT"%" "l" "u" "KB heap.", |
| 913 | _summary_data.reserved_byte_size()/K, mr.byte_size()/K)); |
| 914 | return false; |
| 915 | } |
| 916 | |
| 917 | return true; |
| 918 | } |
| 919 | |
| 920 | void PSParallelCompact::initialize_space_info() |
| 921 | { |
| 922 | memset(&_space_info, 0, sizeof(_space_info)); |
| 923 | |
| 924 | ParallelScavengeHeap* heap = ParallelScavengeHeap::heap(); |
| 925 | PSYoungGen* young_gen = heap->young_gen(); |
| 926 | |
| 927 | _space_info[old_space_id].set_space(heap->old_gen()->object_space()); |
| 928 | _space_info[eden_space_id].set_space(young_gen->eden_space()); |
| 929 | _space_info[from_space_id].set_space(young_gen->from_space()); |
| 930 | _space_info[to_space_id].set_space(young_gen->to_space()); |
| 931 | |
| 932 | _space_info[old_space_id].set_start_array(heap->old_gen()->start_array()); |
| 933 | } |
| 934 | |
| 935 | void PSParallelCompact::initialize_dead_wood_limiter() |
| 936 | { |
| 937 | const size_t max = 100; |
| 938 | _dwl_mean = double(MIN2(ParallelOldDeadWoodLimiterMean, max)) / 100.0; |
| 939 | _dwl_std_dev = double(MIN2(ParallelOldDeadWoodLimiterStdDev, max)) / 100.0; |
| 940 | _dwl_first_term = 1.0 / (sqrt(2.0 * M_PI3.14159265358979323846) * _dwl_std_dev); |
| 941 | DEBUG_ONLY(_dwl_initialized = true;)_dwl_initialized = true; |
| 942 | _dwl_adjustment = normal_distribution(1.0); |
| 943 | } |
| 944 | |
| 945 | void |
| 946 | PSParallelCompact::clear_data_covering_space(SpaceId id) |
| 947 | { |
| 948 | // At this point, top is the value before GC, new_top() is the value that will |
| 949 | // be set at the end of GC. The marking bitmap is cleared to top; nothing |
| 950 | // should be marked above top. The summary data is cleared to the larger of |
| 951 | // top & new_top. |
| 952 | MutableSpace* const space = _space_info[id].space(); |
| 953 | HeapWord* const bot = space->bottom(); |
| 954 | HeapWord* const top = space->top(); |
| 955 | HeapWord* const max_top = MAX2(top, _space_info[id].new_top()); |
| 956 | |
| 957 | const idx_t beg_bit = _mark_bitmap.addr_to_bit(bot); |
| 958 | const idx_t end_bit = _mark_bitmap.align_range_end(_mark_bitmap.addr_to_bit(top)); |
| 959 | _mark_bitmap.clear_range(beg_bit, end_bit); |
| 960 | |
| 961 | const size_t beg_region = _summary_data.addr_to_region_idx(bot); |
| 962 | const size_t end_region = |
| 963 | _summary_data.addr_to_region_idx(_summary_data.region_align_up(max_top)); |
| 964 | _summary_data.clear_range(beg_region, end_region); |
| 965 | |
| 966 | // Clear the data used to 'split' regions. |
| 967 | SplitInfo& split_info = _space_info[id].split_info(); |
| 968 | if (split_info.is_valid()) { |
| 969 | split_info.clear(); |
| 970 | } |
| 971 | DEBUG_ONLY(split_info.verify_clear();)split_info.verify_clear(); |
| 972 | } |
| 973 | |
| 974 | void PSParallelCompact::pre_compact() |
| 975 | { |
| 976 | // Update the from & to space pointers in space_info, since they are swapped |
| 977 | // at each young gen gc. Do the update unconditionally (even though a |
| 978 | // promotion failure does not swap spaces) because an unknown number of young |
| 979 | // collections will have swapped the spaces an unknown number of times. |
| 980 | GCTraceTime(Debug, gc, phases)GCTraceTimeWrapper<LogLevel::Debug, (LogTag::_gc), (LogTag ::_phases), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag:: __NO_TAG), (LogTag::__NO_TAG)> tm("Pre Compact", &_gc_timer); |
| 981 | ParallelScavengeHeap* heap = ParallelScavengeHeap::heap(); |
| 982 | _space_info[from_space_id].set_space(heap->young_gen()->from_space()); |
| 983 | _space_info[to_space_id].set_space(heap->young_gen()->to_space()); |
| 984 | |
| 985 | // Increment the invocation count |
| 986 | heap->increment_total_collections(true); |
| 987 | |
| 988 | // We need to track unique mark sweep invocations as well. |
| 989 | _total_invocations++; |
| 990 | |
| 991 | heap->print_heap_before_gc(); |
| 992 | heap->trace_heap_before_gc(&_gc_tracer); |
| 993 | |
| 994 | // Fill in TLABs |
| 995 | heap->ensure_parsability(true); // retire TLABs |
| 996 | |
| 997 | if (VerifyBeforeGC && heap->total_collections() >= VerifyGCStartAt) { |
| 998 | Universe::verify("Before GC"); |
| 999 | } |
| 1000 | |
| 1001 | // Verify object start arrays |
| 1002 | if (VerifyObjectStartArray && |
| 1003 | VerifyBeforeGC) { |
| 1004 | heap->old_gen()->verify_object_start_array(); |
| 1005 | } |
| 1006 | |
| 1007 | DEBUG_ONLY(mark_bitmap()->verify_clear();)mark_bitmap()->verify_clear(); |
| 1008 | DEBUG_ONLY(summary_data().verify_clear();)summary_data().verify_clear(); |
| 1009 | |
| 1010 | ParCompactionManager::reset_all_bitmap_query_caches(); |
| 1011 | } |
| 1012 | |
| 1013 | void PSParallelCompact::post_compact() |
| 1014 | { |
| 1015 | GCTraceTime(Info, gc, phases)GCTraceTimeWrapper<LogLevel::Info, (LogTag::_gc), (LogTag:: _phases), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG ), (LogTag::__NO_TAG)> tm("Post Compact", &_gc_timer); |
| 1016 | ParCompactionManager::remove_all_shadow_regions(); |
| 1017 | |
| 1018 | for (unsigned int id = old_space_id; id < last_space_id; ++id) { |
| 1019 | // Clear the marking bitmap, summary data and split info. |
| 1020 | clear_data_covering_space(SpaceId(id)); |
| 1021 | // Update top(). Must be done after clearing the bitmap and summary data. |
| 1022 | _space_info[id].publish_new_top(); |
| 1023 | } |
| 1024 | |
| 1025 | ParCompactionManager::flush_all_string_dedup_requests(); |
| 1026 | |
| 1027 | MutableSpace* const eden_space = _space_info[eden_space_id].space(); |
| 1028 | MutableSpace* const from_space = _space_info[from_space_id].space(); |
| 1029 | MutableSpace* const to_space = _space_info[to_space_id].space(); |
| 1030 | |
| 1031 | ParallelScavengeHeap* heap = ParallelScavengeHeap::heap(); |
| 1032 | bool eden_empty = eden_space->is_empty(); |
| 1033 | |
| 1034 | // Update heap occupancy information which is used as input to the soft ref |
| 1035 | // clearing policy at the next gc. |
| 1036 | Universe::heap()->update_capacity_and_used_at_gc(); |
| 1037 | |
| 1038 | bool young_gen_empty = eden_empty && from_space->is_empty() && |
| 1039 | to_space->is_empty(); |
| 1040 | |
| 1041 | PSCardTable* ct = heap->card_table(); |
| 1042 | MemRegion old_mr = heap->old_gen()->reserved(); |
| 1043 | if (young_gen_empty) { |
| 1044 | ct->clear(old_mr); |
| 1045 | } else { |
| 1046 | ct->invalidate(old_mr); |
| 1047 | } |
| 1048 | |
| 1049 | // Delete metaspaces for unloaded class loaders and clean up loader_data graph |
| 1050 | ClassLoaderDataGraph::purge(/*at_safepoint*/true); |
| 1051 | DEBUG_ONLY(MetaspaceUtils::verify();)MetaspaceUtils::verify(); |
| 1052 | |
| 1053 | heap->prune_scavengable_nmethods(); |
| 1054 | |
| 1055 | #if COMPILER2_OR_JVMCI1 |
| 1056 | DerivedPointerTable::update_pointers(); |
| 1057 | #endif |
| 1058 | |
| 1059 | if (ZapUnusedHeapArea) { |
| 1060 | heap->gen_mangle_unused_area(); |
| 1061 | } |
| 1062 | |
| 1063 | // Signal that we have completed a visit to all live objects. |
| 1064 | Universe::heap()->record_whole_heap_examined_timestamp(); |
| 1065 | } |
| 1066 | |
| 1067 | HeapWord* |
| 1068 | PSParallelCompact::compute_dense_prefix_via_density(const SpaceId id, |
| 1069 | bool maximum_compaction) |
| 1070 | { |
| 1071 | const size_t region_size = ParallelCompactData::RegionSize; |
| 1072 | const ParallelCompactData& sd = summary_data(); |
| 1073 | |
| 1074 | const MutableSpace* const space = _space_info[id].space(); |
| 1075 | HeapWord* const top_aligned_up = sd.region_align_up(space->top()); |
| 1076 | const RegionData* const beg_cp = sd.addr_to_region_ptr(space->bottom()); |
| 1077 | const RegionData* const end_cp = sd.addr_to_region_ptr(top_aligned_up); |
| 1078 | |
| 1079 | // Skip full regions at the beginning of the space--they are necessarily part |
| 1080 | // of the dense prefix. |
| 1081 | size_t full_count = 0; |
| 1082 | const RegionData* cp; |
| 1083 | for (cp = beg_cp; cp < end_cp && cp->data_size() == region_size; ++cp) { |
| 1084 | ++full_count; |
| 1085 | } |
| 1086 | |
| 1087 | assert(total_invocations() >= _maximum_compaction_gc_num, "sanity")do { if (!(total_invocations() >= _maximum_compaction_gc_num )) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 1087, "assert(" "total_invocations() >= _maximum_compaction_gc_num" ") failed", "sanity"); ::breakpoint(); } } while (0); |
| 1088 | const size_t gcs_since_max = total_invocations() - _maximum_compaction_gc_num; |
| 1089 | const bool interval_ended = gcs_since_max > HeapMaximumCompactionInterval; |
| 1090 | if (maximum_compaction || cp == end_cp || interval_ended) { |
| 1091 | _maximum_compaction_gc_num = total_invocations(); |
| 1092 | return sd.region_to_addr(cp); |
| 1093 | } |
| 1094 | |
| 1095 | HeapWord* const new_top = _space_info[id].new_top(); |
| 1096 | const size_t space_live = pointer_delta(new_top, space->bottom()); |
| 1097 | const size_t space_used = space->used_in_words(); |
| 1098 | const size_t space_capacity = space->capacity_in_words(); |
| 1099 | |
| 1100 | const double cur_density = double(space_live) / space_capacity; |
| 1101 | const double deadwood_density = |
| 1102 | (1.0 - cur_density) * (1.0 - cur_density) * cur_density * cur_density; |
| 1103 | const size_t deadwood_goal = size_t(space_capacity * deadwood_density); |
| 1104 | |
| 1105 | log_develop_debug(gc, compaction)(!(LogImpl<(LogTag::_gc), (LogTag::_compaction), (LogTag:: __NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG )>::is_level(LogLevel::Debug))) ? (void)0 : LogImpl<(LogTag ::_gc), (LogTag::_compaction), (LogTag::__NO_TAG), (LogTag::__NO_TAG ), (LogTag::__NO_TAG), (LogTag::__NO_TAG)>::write<LogLevel ::Debug>( |
| 1106 | "cur_dens=%5.3f dw_dens=%5.3f dw_goal=" SIZE_FORMAT"%" "l" "u", |
| 1107 | cur_density, deadwood_density, deadwood_goal); |
| 1108 | log_develop_debug(gc, compaction)(!(LogImpl<(LogTag::_gc), (LogTag::_compaction), (LogTag:: __NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG )>::is_level(LogLevel::Debug))) ? (void)0 : LogImpl<(LogTag ::_gc), (LogTag::_compaction), (LogTag::__NO_TAG), (LogTag::__NO_TAG ), (LogTag::__NO_TAG), (LogTag::__NO_TAG)>::write<LogLevel ::Debug>( |
| 1109 | "space_live=" SIZE_FORMAT"%" "l" "u" " space_used=" SIZE_FORMAT"%" "l" "u" " " |
| 1110 | "space_cap=" SIZE_FORMAT"%" "l" "u", |
| 1111 | space_live, space_used, |
| 1112 | space_capacity); |
| 1113 | |
| 1114 | // XXX - Use binary search? |
| 1115 | HeapWord* dense_prefix = sd.region_to_addr(cp); |
| 1116 | const RegionData* full_cp = cp; |
| 1117 | const RegionData* const top_cp = sd.addr_to_region_ptr(space->top() - 1); |
Value stored to 'top_cp' during its initialization is never read | |
| 1118 | while (cp < end_cp) { |
| 1119 | HeapWord* region_destination = cp->destination(); |
| 1120 | const size_t cur_deadwood = pointer_delta(dense_prefix, region_destination); |
| 1121 | |
| 1122 | log_develop_trace(gc, compaction)(!(LogImpl<(LogTag::_gc), (LogTag::_compaction), (LogTag:: __NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG )>::is_level(LogLevel::Trace))) ? (void)0 : LogImpl<(LogTag ::_gc), (LogTag::_compaction), (LogTag::__NO_TAG), (LogTag::__NO_TAG ), (LogTag::__NO_TAG), (LogTag::__NO_TAG)>::write<LogLevel ::Trace>( |
| 1123 | "c#=" SIZE_FORMAT_W(4)"%" "4" "l" "u" " dst=" PTR_FORMAT"0x%016" "l" "x" " " |
| 1124 | "dp=" PTR_FORMAT"0x%016" "l" "x" " cdw=" SIZE_FORMAT_W(8)"%" "8" "l" "u", |
| 1125 | sd.region(cp), p2i(region_destination), |
| 1126 | p2i(dense_prefix), cur_deadwood); |
| 1127 | |
| 1128 | if (cur_deadwood >= deadwood_goal) { |
| 1129 | // Found the region that has the correct amount of deadwood to the left. |
| 1130 | // This typically occurs after crossing a fairly sparse set of regions, so |
| 1131 | // iterate backwards over those sparse regions, looking for the region |
| 1132 | // that has the lowest density of live objects 'to the right.' |
| 1133 | size_t space_to_left = sd.region(cp) * region_size; |
| 1134 | size_t live_to_left = space_to_left - cur_deadwood; |
| 1135 | size_t space_to_right = space_capacity - space_to_left; |
| 1136 | size_t live_to_right = space_live - live_to_left; |
| 1137 | double density_to_right = double(live_to_right) / space_to_right; |
| 1138 | while (cp > full_cp) { |
| 1139 | --cp; |
| 1140 | const size_t prev_region_live_to_right = live_to_right - |
| 1141 | cp->data_size(); |
| 1142 | const size_t prev_region_space_to_right = space_to_right + region_size; |
| 1143 | double prev_region_density_to_right = |
| 1144 | double(prev_region_live_to_right) / prev_region_space_to_right; |
| 1145 | if (density_to_right <= prev_region_density_to_right) { |
| 1146 | return dense_prefix; |
| 1147 | } |
| 1148 | |
| 1149 | log_develop_trace(gc, compaction)(!(LogImpl<(LogTag::_gc), (LogTag::_compaction), (LogTag:: __NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG )>::is_level(LogLevel::Trace))) ? (void)0 : LogImpl<(LogTag ::_gc), (LogTag::_compaction), (LogTag::__NO_TAG), (LogTag::__NO_TAG ), (LogTag::__NO_TAG), (LogTag::__NO_TAG)>::write<LogLevel ::Trace>( |
| 1150 | "backing up from c=" SIZE_FORMAT_W(4)"%" "4" "l" "u" " d2r=%10.8f " |
| 1151 | "pc_d2r=%10.8f", |
| 1152 | sd.region(cp), density_to_right, |
| 1153 | prev_region_density_to_right); |
| 1154 | |
| 1155 | dense_prefix -= region_size; |
| 1156 | live_to_right = prev_region_live_to_right; |
| 1157 | space_to_right = prev_region_space_to_right; |
| 1158 | density_to_right = prev_region_density_to_right; |
| 1159 | } |
| 1160 | return dense_prefix; |
| 1161 | } |
| 1162 | |
| 1163 | dense_prefix += region_size; |
| 1164 | ++cp; |
| 1165 | } |
| 1166 | |
| 1167 | return dense_prefix; |
| 1168 | } |
| 1169 | |
| 1170 | #ifndef PRODUCT |
| 1171 | void PSParallelCompact::print_dense_prefix_stats(const char* const algorithm, |
| 1172 | const SpaceId id, |
| 1173 | const bool maximum_compaction, |
| 1174 | HeapWord* const addr) |
| 1175 | { |
| 1176 | const size_t region_idx = summary_data().addr_to_region_idx(addr); |
| 1177 | RegionData* const cp = summary_data().region(region_idx); |
| 1178 | const MutableSpace* const space = _space_info[id].space(); |
| 1179 | HeapWord* const new_top = _space_info[id].new_top(); |
| 1180 | |
| 1181 | const size_t space_live = pointer_delta(new_top, space->bottom()); |
| 1182 | const size_t dead_to_left = pointer_delta(addr, cp->destination()); |
| 1183 | const size_t space_cap = space->capacity_in_words(); |
| 1184 | const double dead_to_left_pct = double(dead_to_left) / space_cap; |
| 1185 | const size_t live_to_right = new_top - cp->destination(); |
| 1186 | const size_t dead_to_right = space->top() - addr - live_to_right; |
| 1187 | |
| 1188 | log_develop_debug(gc, compaction)(!(LogImpl<(LogTag::_gc), (LogTag::_compaction), (LogTag:: __NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG )>::is_level(LogLevel::Debug))) ? (void)0 : LogImpl<(LogTag ::_gc), (LogTag::_compaction), (LogTag::__NO_TAG), (LogTag::__NO_TAG ), (LogTag::__NO_TAG), (LogTag::__NO_TAG)>::write<LogLevel ::Debug>( |
| 1189 | "%s=" PTR_FORMAT"0x%016" "l" "x" " dpc=" SIZE_FORMAT_W(5)"%" "5" "l" "u" " " |
| 1190 | "spl=" SIZE_FORMAT"%" "l" "u" " " |
| 1191 | "d2l=" SIZE_FORMAT"%" "l" "u" " d2l%%=%6.4f " |
| 1192 | "d2r=" SIZE_FORMAT"%" "l" "u" " l2r=" SIZE_FORMAT"%" "l" "u" " " |
| 1193 | "ratio=%10.8f", |
| 1194 | algorithm, p2i(addr), region_idx, |
| 1195 | space_live, |
| 1196 | dead_to_left, dead_to_left_pct, |
| 1197 | dead_to_right, live_to_right, |
| 1198 | double(dead_to_right) / live_to_right); |
| 1199 | } |
| 1200 | #endif // #ifndef PRODUCT |
| 1201 | |
| 1202 | // Return a fraction indicating how much of the generation can be treated as |
| 1203 | // "dead wood" (i.e., not reclaimed). The function uses a normal distribution |
| 1204 | // based on the density of live objects in the generation to determine a limit, |
| 1205 | // which is then adjusted so the return value is min_percent when the density is |
| 1206 | // 1. |
| 1207 | // |
| 1208 | // The following table shows some return values for a different values of the |
| 1209 | // standard deviation (ParallelOldDeadWoodLimiterStdDev); the mean is 0.5 and |
| 1210 | // min_percent is 1. |
| 1211 | // |
| 1212 | // fraction allowed as dead wood |
| 1213 | // ----------------------------------------------------------------- |
| 1214 | // density std_dev=70 std_dev=75 std_dev=80 std_dev=85 std_dev=90 std_dev=95 |
| 1215 | // ------- ---------- ---------- ---------- ---------- ---------- ---------- |
| 1216 | // 0.00000 0.01000000 0.01000000 0.01000000 0.01000000 0.01000000 0.01000000 |
| 1217 | // 0.05000 0.03193096 0.02836880 0.02550828 0.02319280 0.02130337 0.01974941 |
| 1218 | // 0.10000 0.05247504 0.04547452 0.03988045 0.03537016 0.03170171 0.02869272 |
| 1219 | // 0.15000 0.07135702 0.06111390 0.05296419 0.04641639 0.04110601 0.03676066 |
| 1220 | // 0.20000 0.08831616 0.07509618 0.06461766 0.05622444 0.04943437 0.04388975 |
| 1221 | // 0.25000 0.10311208 0.08724696 0.07471205 0.06469760 0.05661313 0.05002313 |
| 1222 | // 0.30000 0.11553050 0.09741183 0.08313394 0.07175114 0.06257797 0.05511132 |
| 1223 | // 0.35000 0.12538832 0.10545958 0.08978741 0.07731366 0.06727491 0.05911289 |
| 1224 | // 0.40000 0.13253818 0.11128511 0.09459590 0.08132834 0.07066107 0.06199500 |
| 1225 | // 0.45000 0.13687208 0.11481163 0.09750361 0.08375387 0.07270534 0.06373386 |
| 1226 | // 0.50000 0.13832410 0.11599237 0.09847664 0.08456518 0.07338887 0.06431510 |
| 1227 | // 0.55000 0.13687208 0.11481163 0.09750361 0.08375387 0.07270534 0.06373386 |
| 1228 | // 0.60000 0.13253818 0.11128511 0.09459590 0.08132834 0.07066107 0.06199500 |
| 1229 | // 0.65000 0.12538832 0.10545958 0.08978741 0.07731366 0.06727491 0.05911289 |
| 1230 | // 0.70000 0.11553050 0.09741183 0.08313394 0.07175114 0.06257797 0.05511132 |
| 1231 | // 0.75000 0.10311208 0.08724696 0.07471205 0.06469760 0.05661313 0.05002313 |
| 1232 | // 0.80000 0.08831616 0.07509618 0.06461766 0.05622444 0.04943437 0.04388975 |
| 1233 | // 0.85000 0.07135702 0.06111390 0.05296419 0.04641639 0.04110601 0.03676066 |
| 1234 | // 0.90000 0.05247504 0.04547452 0.03988045 0.03537016 0.03170171 0.02869272 |
| 1235 | // 0.95000 0.03193096 0.02836880 0.02550828 0.02319280 0.02130337 0.01974941 |
| 1236 | // 1.00000 0.01000000 0.01000000 0.01000000 0.01000000 0.01000000 0.01000000 |
| 1237 | |
| 1238 | double PSParallelCompact::dead_wood_limiter(double density, size_t min_percent) |
| 1239 | { |
| 1240 | assert(_dwl_initialized, "uninitialized")do { if (!(_dwl_initialized)) { (*g_assert_poison) = 'X';; report_vm_error ("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 1240, "assert(" "_dwl_initialized" ") failed", "uninitialized" ); ::breakpoint(); } } while (0); |
| 1241 | |
| 1242 | // The raw limit is the value of the normal distribution at x = density. |
| 1243 | const double raw_limit = normal_distribution(density); |
| 1244 | |
| 1245 | // Adjust the raw limit so it becomes the minimum when the density is 1. |
| 1246 | // |
| 1247 | // First subtract the adjustment value (which is simply the precomputed value |
| 1248 | // normal_distribution(1.0)); this yields a value of 0 when the density is 1. |
| 1249 | // Then add the minimum value, so the minimum is returned when the density is |
| 1250 | // 1. Finally, prevent negative values, which occur when the mean is not 0.5. |
| 1251 | const double min = double(min_percent) / 100.0; |
| 1252 | const double limit = raw_limit - _dwl_adjustment + min; |
| 1253 | return MAX2(limit, 0.0); |
| 1254 | } |
| 1255 | |
| 1256 | ParallelCompactData::RegionData* |
| 1257 | PSParallelCompact::first_dead_space_region(const RegionData* beg, |
| 1258 | const RegionData* end) |
| 1259 | { |
| 1260 | const size_t region_size = ParallelCompactData::RegionSize; |
| 1261 | ParallelCompactData& sd = summary_data(); |
| 1262 | size_t left = sd.region(beg); |
| 1263 | size_t right = end > beg ? sd.region(end) - 1 : left; |
| 1264 | |
| 1265 | // Binary search. |
| 1266 | while (left < right) { |
| 1267 | // Equivalent to (left + right) / 2, but does not overflow. |
| 1268 | const size_t middle = left + (right - left) / 2; |
| 1269 | RegionData* const middle_ptr = sd.region(middle); |
| 1270 | HeapWord* const dest = middle_ptr->destination(); |
| 1271 | HeapWord* const addr = sd.region_to_addr(middle); |
| 1272 | assert(dest != NULL, "sanity")do { if (!(dest != __null)) { (*g_assert_poison) = 'X';; report_vm_error ("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 1272, "assert(" "dest != __null" ") failed", "sanity"); ::breakpoint (); } } while (0); |
| 1273 | assert(dest <= addr, "must move left")do { if (!(dest <= addr)) { (*g_assert_poison) = 'X';; report_vm_error ("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 1273, "assert(" "dest <= addr" ") failed", "must move left" ); ::breakpoint(); } } while (0); |
| 1274 | |
| 1275 | if (middle > left && dest < addr) { |
| 1276 | right = middle - 1; |
| 1277 | } else if (middle < right && middle_ptr->data_size() == region_size) { |
| 1278 | left = middle + 1; |
| 1279 | } else { |
| 1280 | return middle_ptr; |
| 1281 | } |
| 1282 | } |
| 1283 | return sd.region(left); |
| 1284 | } |
| 1285 | |
| 1286 | ParallelCompactData::RegionData* |
| 1287 | PSParallelCompact::dead_wood_limit_region(const RegionData* beg, |
| 1288 | const RegionData* end, |
| 1289 | size_t dead_words) |
| 1290 | { |
| 1291 | ParallelCompactData& sd = summary_data(); |
| 1292 | size_t left = sd.region(beg); |
| 1293 | size_t right = end > beg ? sd.region(end) - 1 : left; |
| 1294 | |
| 1295 | // Binary search. |
| 1296 | while (left < right) { |
| 1297 | // Equivalent to (left + right) / 2, but does not overflow. |
| 1298 | const size_t middle = left + (right - left) / 2; |
| 1299 | RegionData* const middle_ptr = sd.region(middle); |
| 1300 | HeapWord* const dest = middle_ptr->destination(); |
| 1301 | HeapWord* const addr = sd.region_to_addr(middle); |
| 1302 | assert(dest != NULL, "sanity")do { if (!(dest != __null)) { (*g_assert_poison) = 'X';; report_vm_error ("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 1302, "assert(" "dest != __null" ") failed", "sanity"); ::breakpoint (); } } while (0); |
| 1303 | assert(dest <= addr, "must move left")do { if (!(dest <= addr)) { (*g_assert_poison) = 'X';; report_vm_error ("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 1303, "assert(" "dest <= addr" ") failed", "must move left" ); ::breakpoint(); } } while (0); |
| 1304 | |
| 1305 | const size_t dead_to_left = pointer_delta(addr, dest); |
| 1306 | if (middle > left && dead_to_left > dead_words) { |
| 1307 | right = middle - 1; |
| 1308 | } else if (middle < right && dead_to_left < dead_words) { |
| 1309 | left = middle + 1; |
| 1310 | } else { |
| 1311 | return middle_ptr; |
| 1312 | } |
| 1313 | } |
| 1314 | return sd.region(left); |
| 1315 | } |
| 1316 | |
| 1317 | // The result is valid during the summary phase, after the initial summarization |
| 1318 | // of each space into itself, and before final summarization. |
| 1319 | inline double |
| 1320 | PSParallelCompact::reclaimed_ratio(const RegionData* const cp, |
| 1321 | HeapWord* const bottom, |
| 1322 | HeapWord* const top, |
| 1323 | HeapWord* const new_top) |
| 1324 | { |
| 1325 | ParallelCompactData& sd = summary_data(); |
| 1326 | |
| 1327 | assert(cp != NULL, "sanity")do { if (!(cp != __null)) { (*g_assert_poison) = 'X';; report_vm_error ("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 1327, "assert(" "cp != __null" ") failed", "sanity"); ::breakpoint (); } } while (0); |
| 1328 | assert(bottom != NULL, "sanity")do { if (!(bottom != __null)) { (*g_assert_poison) = 'X';; report_vm_error ("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 1328, "assert(" "bottom != __null" ") failed", "sanity"); :: breakpoint(); } } while (0); |
| 1329 | assert(top != NULL, "sanity")do { if (!(top != __null)) { (*g_assert_poison) = 'X';; report_vm_error ("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 1329, "assert(" "top != __null" ") failed", "sanity"); ::breakpoint (); } } while (0); |
| 1330 | assert(new_top != NULL, "sanity")do { if (!(new_top != __null)) { (*g_assert_poison) = 'X';; report_vm_error ("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 1330, "assert(" "new_top != __null" ") failed", "sanity"); :: breakpoint(); } } while (0); |
| 1331 | assert(top >= new_top, "summary data problem?")do { if (!(top >= new_top)) { (*g_assert_poison) = 'X';; report_vm_error ("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 1331, "assert(" "top >= new_top" ") failed", "summary data problem?" ); ::breakpoint(); } } while (0); |
| 1332 | assert(new_top > bottom, "space is empty; should not be here")do { if (!(new_top > bottom)) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 1332, "assert(" "new_top > bottom" ") failed", "space is empty; should not be here" ); ::breakpoint(); } } while (0); |
| 1333 | assert(new_top >= cp->destination(), "sanity")do { if (!(new_top >= cp->destination())) { (*g_assert_poison ) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 1333, "assert(" "new_top >= cp->destination()" ") failed" , "sanity"); ::breakpoint(); } } while (0); |
| 1334 | assert(top >= sd.region_to_addr(cp), "sanity")do { if (!(top >= sd.region_to_addr(cp))) { (*g_assert_poison ) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 1334, "assert(" "top >= sd.region_to_addr(cp)" ") failed" , "sanity"); ::breakpoint(); } } while (0); |
| 1335 | |
| 1336 | HeapWord* const destination = cp->destination(); |
| 1337 | const size_t dense_prefix_live = pointer_delta(destination, bottom); |
| 1338 | const size_t compacted_region_live = pointer_delta(new_top, destination); |
| 1339 | const size_t compacted_region_used = pointer_delta(top, |
| 1340 | sd.region_to_addr(cp)); |
| 1341 | const size_t reclaimable = compacted_region_used - compacted_region_live; |
| 1342 | |
| 1343 | const double divisor = dense_prefix_live + 1.25 * compacted_region_live; |
| 1344 | return double(reclaimable) / divisor; |
| 1345 | } |
| 1346 | |
| 1347 | // Return the address of the end of the dense prefix, a.k.a. the start of the |
| 1348 | // compacted region. The address is always on a region boundary. |
| 1349 | // |
| 1350 | // Completely full regions at the left are skipped, since no compaction can |
| 1351 | // occur in those regions. Then the maximum amount of dead wood to allow is |
| 1352 | // computed, based on the density (amount live / capacity) of the generation; |
| 1353 | // the region with approximately that amount of dead space to the left is |
| 1354 | // identified as the limit region. Regions between the last completely full |
| 1355 | // region and the limit region are scanned and the one that has the best |
| 1356 | // (maximum) reclaimed_ratio() is selected. |
| 1357 | HeapWord* |
| 1358 | PSParallelCompact::compute_dense_prefix(const SpaceId id, |
| 1359 | bool maximum_compaction) |
| 1360 | { |
| 1361 | const size_t region_size = ParallelCompactData::RegionSize; |
| 1362 | const ParallelCompactData& sd = summary_data(); |
| 1363 | |
| 1364 | const MutableSpace* const space = _space_info[id].space(); |
| 1365 | HeapWord* const top = space->top(); |
| 1366 | HeapWord* const top_aligned_up = sd.region_align_up(top); |
| 1367 | HeapWord* const new_top = _space_info[id].new_top(); |
| 1368 | HeapWord* const new_top_aligned_up = sd.region_align_up(new_top); |
| 1369 | HeapWord* const bottom = space->bottom(); |
| 1370 | const RegionData* const beg_cp = sd.addr_to_region_ptr(bottom); |
| 1371 | const RegionData* const top_cp = sd.addr_to_region_ptr(top_aligned_up); |
| 1372 | const RegionData* const new_top_cp = |
| 1373 | sd.addr_to_region_ptr(new_top_aligned_up); |
| 1374 | |
| 1375 | // Skip full regions at the beginning of the space--they are necessarily part |
| 1376 | // of the dense prefix. |
| 1377 | const RegionData* const full_cp = first_dead_space_region(beg_cp, new_top_cp); |
| 1378 | assert(full_cp->destination() == sd.region_to_addr(full_cp) ||do { if (!(full_cp->destination() == sd.region_to_addr(full_cp ) || space->is_empty())) { (*g_assert_poison) = 'X';; report_vm_error ("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 1379, "assert(" "full_cp->destination() == sd.region_to_addr(full_cp) || space->is_empty()" ") failed", "no dead space allowed to the left"); ::breakpoint (); } } while (0) |
| 1379 | space->is_empty(), "no dead space allowed to the left")do { if (!(full_cp->destination() == sd.region_to_addr(full_cp ) || space->is_empty())) { (*g_assert_poison) = 'X';; report_vm_error ("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 1379, "assert(" "full_cp->destination() == sd.region_to_addr(full_cp) || space->is_empty()" ") failed", "no dead space allowed to the left"); ::breakpoint (); } } while (0); |
| 1380 | assert(full_cp->data_size() < region_size || full_cp == new_top_cp - 1,do { if (!(full_cp->data_size() < region_size || full_cp == new_top_cp - 1)) { (*g_assert_poison) = 'X';; report_vm_error ("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 1381, "assert(" "full_cp->data_size() < region_size || full_cp == new_top_cp - 1" ") failed", "region must have dead space"); ::breakpoint(); } } while (0) |
| 1381 | "region must have dead space")do { if (!(full_cp->data_size() < region_size || full_cp == new_top_cp - 1)) { (*g_assert_poison) = 'X';; report_vm_error ("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 1381, "assert(" "full_cp->data_size() < region_size || full_cp == new_top_cp - 1" ") failed", "region must have dead space"); ::breakpoint(); } } while (0); |
| 1382 | |
| 1383 | // The gc number is saved whenever a maximum compaction is done, and used to |
| 1384 | // determine when the maximum compaction interval has expired. This avoids |
| 1385 | // successive max compactions for different reasons. |
| 1386 | assert(total_invocations() >= _maximum_compaction_gc_num, "sanity")do { if (!(total_invocations() >= _maximum_compaction_gc_num )) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 1386, "assert(" "total_invocations() >= _maximum_compaction_gc_num" ") failed", "sanity"); ::breakpoint(); } } while (0); |
| 1387 | const size_t gcs_since_max = total_invocations() - _maximum_compaction_gc_num; |
| 1388 | const bool interval_ended = gcs_since_max > HeapMaximumCompactionInterval || |
| 1389 | total_invocations() == HeapFirstMaximumCompactionCount; |
| 1390 | if (maximum_compaction || full_cp == top_cp || interval_ended) { |
| 1391 | _maximum_compaction_gc_num = total_invocations(); |
| 1392 | return sd.region_to_addr(full_cp); |
| 1393 | } |
| 1394 | |
| 1395 | const size_t space_live = pointer_delta(new_top, bottom); |
| 1396 | const size_t space_used = space->used_in_words(); |
| 1397 | const size_t space_capacity = space->capacity_in_words(); |
| 1398 | |
| 1399 | const double density = double(space_live) / double(space_capacity); |
| 1400 | const size_t min_percent_free = MarkSweepDeadRatio; |
| 1401 | const double limiter = dead_wood_limiter(density, min_percent_free); |
| 1402 | const size_t dead_wood_max = space_used - space_live; |
| 1403 | const size_t dead_wood_limit = MIN2(size_t(space_capacity * limiter), |
| 1404 | dead_wood_max); |
| 1405 | |
| 1406 | log_develop_debug(gc, compaction)(!(LogImpl<(LogTag::_gc), (LogTag::_compaction), (LogTag:: __NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG )>::is_level(LogLevel::Debug))) ? (void)0 : LogImpl<(LogTag ::_gc), (LogTag::_compaction), (LogTag::__NO_TAG), (LogTag::__NO_TAG ), (LogTag::__NO_TAG), (LogTag::__NO_TAG)>::write<LogLevel ::Debug>( |
| 1407 | "space_live=" SIZE_FORMAT"%" "l" "u" " space_used=" SIZE_FORMAT"%" "l" "u" " " |
| 1408 | "space_cap=" SIZE_FORMAT"%" "l" "u", |
| 1409 | space_live, space_used, |
| 1410 | space_capacity); |
| 1411 | log_develop_debug(gc, compaction)(!(LogImpl<(LogTag::_gc), (LogTag::_compaction), (LogTag:: __NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG )>::is_level(LogLevel::Debug))) ? (void)0 : LogImpl<(LogTag ::_gc), (LogTag::_compaction), (LogTag::__NO_TAG), (LogTag::__NO_TAG ), (LogTag::__NO_TAG), (LogTag::__NO_TAG)>::write<LogLevel ::Debug>( |
| 1412 | "dead_wood_limiter(%6.4f, " SIZE_FORMAT"%" "l" "u" ")=%6.4f " |
| 1413 | "dead_wood_max=" SIZE_FORMAT"%" "l" "u" " dead_wood_limit=" SIZE_FORMAT"%" "l" "u", |
| 1414 | density, min_percent_free, limiter, |
| 1415 | dead_wood_max, dead_wood_limit); |
| 1416 | |
| 1417 | // Locate the region with the desired amount of dead space to the left. |
| 1418 | const RegionData* const limit_cp = |
| 1419 | dead_wood_limit_region(full_cp, top_cp, dead_wood_limit); |
| 1420 | |
| 1421 | // Scan from the first region with dead space to the limit region and find the |
| 1422 | // one with the best (largest) reclaimed ratio. |
| 1423 | double best_ratio = 0.0; |
| 1424 | const RegionData* best_cp = full_cp; |
| 1425 | for (const RegionData* cp = full_cp; cp < limit_cp; ++cp) { |
| 1426 | double tmp_ratio = reclaimed_ratio(cp, bottom, top, new_top); |
| 1427 | if (tmp_ratio > best_ratio) { |
| 1428 | best_cp = cp; |
| 1429 | best_ratio = tmp_ratio; |
| 1430 | } |
| 1431 | } |
| 1432 | |
| 1433 | return sd.region_to_addr(best_cp); |
| 1434 | } |
| 1435 | |
| 1436 | void PSParallelCompact::summarize_spaces_quick() |
| 1437 | { |
| 1438 | for (unsigned int i = 0; i < last_space_id; ++i) { |
| 1439 | const MutableSpace* space = _space_info[i].space(); |
| 1440 | HeapWord** nta = _space_info[i].new_top_addr(); |
| 1441 | bool result = _summary_data.summarize(_space_info[i].split_info(), |
| 1442 | space->bottom(), space->top(), NULL__null, |
| 1443 | space->bottom(), space->end(), nta); |
| 1444 | assert(result, "space must fit into itself")do { if (!(result)) { (*g_assert_poison) = 'X';; report_vm_error ("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 1444, "assert(" "result" ") failed", "space must fit into itself" ); ::breakpoint(); } } while (0); |
| 1445 | _space_info[i].set_dense_prefix(space->bottom()); |
| 1446 | } |
| 1447 | } |
| 1448 | |
| 1449 | void PSParallelCompact::fill_dense_prefix_end(SpaceId id) |
| 1450 | { |
| 1451 | HeapWord* const dense_prefix_end = dense_prefix(id); |
| 1452 | const RegionData* region = _summary_data.addr_to_region_ptr(dense_prefix_end); |
| 1453 | const idx_t dense_prefix_bit = _mark_bitmap.addr_to_bit(dense_prefix_end); |
| 1454 | if (dead_space_crosses_boundary(region, dense_prefix_bit)) { |
| 1455 | // Only enough dead space is filled so that any remaining dead space to the |
| 1456 | // left is larger than the minimum filler object. (The remainder is filled |
| 1457 | // during the copy/update phase.) |
| 1458 | // |
| 1459 | // The size of the dead space to the right of the boundary is not a |
| 1460 | // concern, since compaction will be able to use whatever space is |
| 1461 | // available. |
| 1462 | // |
| 1463 | // Here '||' is the boundary, 'x' represents a don't care bit and a box |
| 1464 | // surrounds the space to be filled with an object. |
| 1465 | // |
| 1466 | // In the 32-bit VM, each bit represents two 32-bit words: |
| 1467 | // +---+ |
| 1468 | // a) beg_bits: ... x x x | 0 | || 0 x x ... |
| 1469 | // end_bits: ... x x x | 0 | || 0 x x ... |
| 1470 | // +---+ |
| 1471 | // |
| 1472 | // In the 64-bit VM, each bit represents one 64-bit word: |
| 1473 | // +------------+ |
| 1474 | // b) beg_bits: ... x x x | 0 || 0 | x x ... |
| 1475 | // end_bits: ... x x 1 | 0 || 0 | x x ... |
| 1476 | // +------------+ |
| 1477 | // +-------+ |
| 1478 | // c) beg_bits: ... x x | 0 0 | || 0 x x ... |
| 1479 | // end_bits: ... x 1 | 0 0 | || 0 x x ... |
| 1480 | // +-------+ |
| 1481 | // +-----------+ |
| 1482 | // d) beg_bits: ... x | 0 0 0 | || 0 x x ... |
| 1483 | // end_bits: ... 1 | 0 0 0 | || 0 x x ... |
| 1484 | // +-----------+ |
| 1485 | // +-------+ |
| 1486 | // e) beg_bits: ... 0 0 | 0 0 | || 0 x x ... |
| 1487 | // end_bits: ... 0 0 | 0 0 | || 0 x x ... |
| 1488 | // +-------+ |
| 1489 | |
| 1490 | // Initially assume case a, c or e will apply. |
| 1491 | size_t obj_len = CollectedHeap::min_fill_size(); |
| 1492 | HeapWord* obj_beg = dense_prefix_end - obj_len; |
| 1493 | |
| 1494 | #ifdef _LP641 |
| 1495 | if (MinObjAlignment > 1) { // object alignment > heap word size |
| 1496 | // Cases a, c or e. |
| 1497 | } else if (_mark_bitmap.is_obj_end(dense_prefix_bit - 2)) { |
| 1498 | // Case b above. |
| 1499 | obj_beg = dense_prefix_end - 1; |
| 1500 | } else if (!_mark_bitmap.is_obj_end(dense_prefix_bit - 3) && |
| 1501 | _mark_bitmap.is_obj_end(dense_prefix_bit - 4)) { |
| 1502 | // Case d above. |
| 1503 | obj_beg = dense_prefix_end - 3; |
| 1504 | obj_len = 3; |
| 1505 | } |
| 1506 | #endif // #ifdef _LP64 |
| 1507 | |
| 1508 | CollectedHeap::fill_with_object(obj_beg, obj_len); |
| 1509 | _mark_bitmap.mark_obj(obj_beg, obj_len); |
| 1510 | _summary_data.add_obj(obj_beg, obj_len); |
| 1511 | assert(start_array(id) != NULL, "sanity")do { if (!(start_array(id) != __null)) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 1511, "assert(" "start_array(id) != __null" ") failed", "sanity" ); ::breakpoint(); } } while (0); |
| 1512 | start_array(id)->allocate_block(obj_beg); |
| 1513 | } |
| 1514 | } |
| 1515 | |
| 1516 | void |
| 1517 | PSParallelCompact::summarize_space(SpaceId id, bool maximum_compaction) |
| 1518 | { |
| 1519 | assert(id < last_space_id, "id out of range")do { if (!(id < last_space_id)) { (*g_assert_poison) = 'X' ;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 1519, "assert(" "id < last_space_id" ") failed", "id out of range" ); ::breakpoint(); } } while (0); |
| 1520 | assert(_space_info[id].dense_prefix() == _space_info[id].space()->bottom(),do { if (!(_space_info[id].dense_prefix() == _space_info[id]. space()->bottom())) { (*g_assert_poison) = 'X';; report_vm_error ("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 1521, "assert(" "_space_info[id].dense_prefix() == _space_info[id].space()->bottom()" ") failed", "should have been reset in summarize_spaces_quick()" ); ::breakpoint(); } } while (0) |
| 1521 | "should have been reset in summarize_spaces_quick()")do { if (!(_space_info[id].dense_prefix() == _space_info[id]. space()->bottom())) { (*g_assert_poison) = 'X';; report_vm_error ("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 1521, "assert(" "_space_info[id].dense_prefix() == _space_info[id].space()->bottom()" ") failed", "should have been reset in summarize_spaces_quick()" ); ::breakpoint(); } } while (0); |
| 1522 | |
| 1523 | const MutableSpace* space = _space_info[id].space(); |
| 1524 | if (_space_info[id].new_top() != space->bottom()) { |
| 1525 | HeapWord* dense_prefix_end = compute_dense_prefix(id, maximum_compaction); |
| 1526 | _space_info[id].set_dense_prefix(dense_prefix_end); |
| 1527 | |
| 1528 | #ifndef PRODUCT |
| 1529 | if (log_is_enabled(Debug, gc, compaction)(LogImpl<(LogTag::_gc), (LogTag::_compaction), (LogTag::__NO_TAG ), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG) >::is_level(LogLevel::Debug))) { |
| 1530 | print_dense_prefix_stats("ratio", id, maximum_compaction, |
| 1531 | dense_prefix_end); |
| 1532 | HeapWord* addr = compute_dense_prefix_via_density(id, maximum_compaction); |
| 1533 | print_dense_prefix_stats("density", id, maximum_compaction, addr); |
| 1534 | } |
| 1535 | #endif // #ifndef PRODUCT |
| 1536 | |
| 1537 | // Recompute the summary data, taking into account the dense prefix. If |
| 1538 | // every last byte will be reclaimed, then the existing summary data which |
| 1539 | // compacts everything can be left in place. |
| 1540 | if (!maximum_compaction && dense_prefix_end != space->bottom()) { |
| 1541 | // If dead space crosses the dense prefix boundary, it is (at least |
| 1542 | // partially) filled with a dummy object, marked live and added to the |
| 1543 | // summary data. This simplifies the copy/update phase and must be done |
| 1544 | // before the final locations of objects are determined, to prevent |
| 1545 | // leaving a fragment of dead space that is too small to fill. |
| 1546 | fill_dense_prefix_end(id); |
| 1547 | |
| 1548 | // Compute the destination of each Region, and thus each object. |
| 1549 | _summary_data.summarize_dense_prefix(space->bottom(), dense_prefix_end); |
| 1550 | _summary_data.summarize(_space_info[id].split_info(), |
| 1551 | dense_prefix_end, space->top(), NULL__null, |
| 1552 | dense_prefix_end, space->end(), |
| 1553 | _space_info[id].new_top_addr()); |
| 1554 | } |
| 1555 | } |
| 1556 | |
| 1557 | if (log_develop_is_enabled(Trace, gc, compaction)(LogImpl<(LogTag::_gc), (LogTag::_compaction), (LogTag::__NO_TAG ), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG) >::is_level(LogLevel::Trace))) { |
| 1558 | const size_t region_size = ParallelCompactData::RegionSize; |
| 1559 | HeapWord* const dense_prefix_end = _space_info[id].dense_prefix(); |
| 1560 | const size_t dp_region = _summary_data.addr_to_region_idx(dense_prefix_end); |
| 1561 | const size_t dp_words = pointer_delta(dense_prefix_end, space->bottom()); |
| 1562 | HeapWord* const new_top = _space_info[id].new_top(); |
| 1563 | const HeapWord* nt_aligned_up = _summary_data.region_align_up(new_top); |
| 1564 | const size_t cr_words = pointer_delta(nt_aligned_up, dense_prefix_end); |
| 1565 | log_develop_trace(gc, compaction)(!(LogImpl<(LogTag::_gc), (LogTag::_compaction), (LogTag:: __NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG )>::is_level(LogLevel::Trace))) ? (void)0 : LogImpl<(LogTag ::_gc), (LogTag::_compaction), (LogTag::__NO_TAG), (LogTag::__NO_TAG ), (LogTag::__NO_TAG), (LogTag::__NO_TAG)>::write<LogLevel ::Trace>( |
| 1566 | "id=%d cap=" SIZE_FORMAT"%" "l" "u" " dp=" PTR_FORMAT"0x%016" "l" "x" " " |
| 1567 | "dp_region=" SIZE_FORMAT"%" "l" "u" " " "dp_count=" SIZE_FORMAT"%" "l" "u" " " |
| 1568 | "cr_count=" SIZE_FORMAT"%" "l" "u" " " "nt=" PTR_FORMAT"0x%016" "l" "x", |
| 1569 | id, space->capacity_in_words(), p2i(dense_prefix_end), |
| 1570 | dp_region, dp_words / region_size, |
| 1571 | cr_words / region_size, p2i(new_top)); |
| 1572 | } |
| 1573 | } |
| 1574 | |
| 1575 | #ifndef PRODUCT |
| 1576 | void PSParallelCompact::summary_phase_msg(SpaceId dst_space_id, |
| 1577 | HeapWord* dst_beg, HeapWord* dst_end, |
| 1578 | SpaceId src_space_id, |
| 1579 | HeapWord* src_beg, HeapWord* src_end) |
| 1580 | { |
| 1581 | log_develop_trace(gc, compaction)(!(LogImpl<(LogTag::_gc), (LogTag::_compaction), (LogTag:: __NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG )>::is_level(LogLevel::Trace))) ? (void)0 : LogImpl<(LogTag ::_gc), (LogTag::_compaction), (LogTag::__NO_TAG), (LogTag::__NO_TAG ), (LogTag::__NO_TAG), (LogTag::__NO_TAG)>::write<LogLevel ::Trace>( |
| 1582 | "Summarizing %d [%s] into %d [%s]: " |
| 1583 | "src=" PTR_FORMAT"0x%016" "l" "x" "-" PTR_FORMAT"0x%016" "l" "x" " " |
| 1584 | SIZE_FORMAT"%" "l" "u" "-" SIZE_FORMAT"%" "l" "u" " " |
| 1585 | "dst=" PTR_FORMAT"0x%016" "l" "x" "-" PTR_FORMAT"0x%016" "l" "x" " " |
| 1586 | SIZE_FORMAT"%" "l" "u" "-" SIZE_FORMAT"%" "l" "u", |
| 1587 | src_space_id, space_names[src_space_id], |
| 1588 | dst_space_id, space_names[dst_space_id], |
| 1589 | p2i(src_beg), p2i(src_end), |
| 1590 | _summary_data.addr_to_region_idx(src_beg), |
| 1591 | _summary_data.addr_to_region_idx(src_end), |
| 1592 | p2i(dst_beg), p2i(dst_end), |
| 1593 | _summary_data.addr_to_region_idx(dst_beg), |
| 1594 | _summary_data.addr_to_region_idx(dst_end)); |
| 1595 | } |
| 1596 | #endif // #ifndef PRODUCT |
| 1597 | |
| 1598 | void PSParallelCompact::summary_phase(ParCompactionManager* cm, |
| 1599 | bool maximum_compaction) |
| 1600 | { |
| 1601 | GCTraceTime(Info, gc, phases)GCTraceTimeWrapper<LogLevel::Info, (LogTag::_gc), (LogTag:: _phases), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG ), (LogTag::__NO_TAG)> tm("Summary Phase", &_gc_timer); |
| 1602 | |
| 1603 | // Quick summarization of each space into itself, to see how much is live. |
| 1604 | summarize_spaces_quick(); |
| 1605 | |
| 1606 | log_develop_trace(gc, compaction)(!(LogImpl<(LogTag::_gc), (LogTag::_compaction), (LogTag:: __NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG )>::is_level(LogLevel::Trace))) ? (void)0 : LogImpl<(LogTag ::_gc), (LogTag::_compaction), (LogTag::__NO_TAG), (LogTag::__NO_TAG ), (LogTag::__NO_TAG), (LogTag::__NO_TAG)>::write<LogLevel ::Trace>("summary phase: after summarizing each space to self"); |
| 1607 | NOT_PRODUCT(print_region_ranges())print_region_ranges(); |
| 1608 | NOT_PRODUCT(print_initial_summary_data(_summary_data, _space_info))print_initial_summary_data(_summary_data, _space_info); |
| 1609 | |
| 1610 | // The amount of live data that will end up in old space (assuming it fits). |
| 1611 | size_t old_space_total_live = 0; |
| 1612 | for (unsigned int id = old_space_id; id < last_space_id; ++id) { |
| 1613 | old_space_total_live += pointer_delta(_space_info[id].new_top(), |
| 1614 | _space_info[id].space()->bottom()); |
| 1615 | } |
| 1616 | |
| 1617 | MutableSpace* const old_space = _space_info[old_space_id].space(); |
| 1618 | const size_t old_capacity = old_space->capacity_in_words(); |
| 1619 | if (old_space_total_live > old_capacity) { |
| 1620 | // XXX - should also try to expand |
| 1621 | maximum_compaction = true; |
| 1622 | } |
| 1623 | |
| 1624 | // Old generations. |
| 1625 | summarize_space(old_space_id, maximum_compaction); |
| 1626 | |
| 1627 | // Summarize the remaining spaces in the young gen. The initial target space |
| 1628 | // is the old gen. If a space does not fit entirely into the target, then the |
| 1629 | // remainder is compacted into the space itself and that space becomes the new |
| 1630 | // target. |
| 1631 | SpaceId dst_space_id = old_space_id; |
| 1632 | HeapWord* dst_space_end = old_space->end(); |
| 1633 | HeapWord** new_top_addr = _space_info[dst_space_id].new_top_addr(); |
| 1634 | for (unsigned int id = eden_space_id; id < last_space_id; ++id) { |
| 1635 | const MutableSpace* space = _space_info[id].space(); |
| 1636 | const size_t live = pointer_delta(_space_info[id].new_top(), |
| 1637 | space->bottom()); |
| 1638 | const size_t available = pointer_delta(dst_space_end, *new_top_addr); |
| 1639 | |
| 1640 | NOT_PRODUCT(summary_phase_msg(dst_space_id, *new_top_addr, dst_space_end,summary_phase_msg(dst_space_id, *new_top_addr, dst_space_end, SpaceId(id), space->bottom(), space->top()); |
| 1641 | SpaceId(id), space->bottom(), space->top());)summary_phase_msg(dst_space_id, *new_top_addr, dst_space_end, SpaceId(id), space->bottom(), space->top()); |
| 1642 | if (live > 0 && live <= available) { |
| 1643 | // All the live data will fit. |
| 1644 | bool done = _summary_data.summarize(_space_info[id].split_info(), |
| 1645 | space->bottom(), space->top(), |
| 1646 | NULL__null, |
| 1647 | *new_top_addr, dst_space_end, |
| 1648 | new_top_addr); |
| 1649 | assert(done, "space must fit into old gen")do { if (!(done)) { (*g_assert_poison) = 'X';; report_vm_error ("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 1649, "assert(" "done" ") failed", "space must fit into old gen" ); ::breakpoint(); } } while (0); |
| 1650 | |
| 1651 | // Reset the new_top value for the space. |
| 1652 | _space_info[id].set_new_top(space->bottom()); |
| 1653 | } else if (live > 0) { |
| 1654 | // Attempt to fit part of the source space into the target space. |
| 1655 | HeapWord* next_src_addr = NULL__null; |
| 1656 | bool done = _summary_data.summarize(_space_info[id].split_info(), |
| 1657 | space->bottom(), space->top(), |
| 1658 | &next_src_addr, |
| 1659 | *new_top_addr, dst_space_end, |
| 1660 | new_top_addr); |
| 1661 | assert(!done, "space should not fit into old gen")do { if (!(!done)) { (*g_assert_poison) = 'X';; report_vm_error ("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 1661, "assert(" "!done" ") failed", "space should not fit into old gen" ); ::breakpoint(); } } while (0); |
| 1662 | assert(next_src_addr != NULL, "sanity")do { if (!(next_src_addr != __null)) { (*g_assert_poison) = 'X' ;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 1662, "assert(" "next_src_addr != __null" ") failed", "sanity" ); ::breakpoint(); } } while (0); |
| 1663 | |
| 1664 | // The source space becomes the new target, so the remainder is compacted |
| 1665 | // within the space itself. |
| 1666 | dst_space_id = SpaceId(id); |
| 1667 | dst_space_end = space->end(); |
| 1668 | new_top_addr = _space_info[id].new_top_addr(); |
| 1669 | NOT_PRODUCT(summary_phase_msg(dst_space_id,summary_phase_msg(dst_space_id, space->bottom(), dst_space_end , SpaceId(id), next_src_addr, space->top()); |
| 1670 | space->bottom(), dst_space_end,summary_phase_msg(dst_space_id, space->bottom(), dst_space_end , SpaceId(id), next_src_addr, space->top()); |
| 1671 | SpaceId(id), next_src_addr, space->top());)summary_phase_msg(dst_space_id, space->bottom(), dst_space_end , SpaceId(id), next_src_addr, space->top()); |
| 1672 | done = _summary_data.summarize(_space_info[id].split_info(), |
| 1673 | next_src_addr, space->top(), |
| 1674 | NULL__null, |
| 1675 | space->bottom(), dst_space_end, |
| 1676 | new_top_addr); |
| 1677 | assert(done, "space must fit when compacted into itself")do { if (!(done)) { (*g_assert_poison) = 'X';; report_vm_error ("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 1677, "assert(" "done" ") failed", "space must fit when compacted into itself" ); ::breakpoint(); } } while (0); |
| 1678 | assert(*new_top_addr <= space->top(), "usage should not grow")do { if (!(*new_top_addr <= space->top())) { (*g_assert_poison ) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 1678, "assert(" "*new_top_addr <= space->top()" ") failed" , "usage should not grow"); ::breakpoint(); } } while (0); |
| 1679 | } |
| 1680 | } |
| 1681 | |
| 1682 | log_develop_trace(gc, compaction)(!(LogImpl<(LogTag::_gc), (LogTag::_compaction), (LogTag:: __NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG )>::is_level(LogLevel::Trace))) ? (void)0 : LogImpl<(LogTag ::_gc), (LogTag::_compaction), (LogTag::__NO_TAG), (LogTag::__NO_TAG ), (LogTag::__NO_TAG), (LogTag::__NO_TAG)>::write<LogLevel ::Trace>("Summary_phase: after final summarization"); |
| 1683 | NOT_PRODUCT(print_region_ranges())print_region_ranges(); |
| 1684 | NOT_PRODUCT(print_initial_summary_data(_summary_data, _space_info))print_initial_summary_data(_summary_data, _space_info); |
| 1685 | } |
| 1686 | |
| 1687 | // This method should contain all heap-specific policy for invoking a full |
| 1688 | // collection. invoke_no_policy() will only attempt to compact the heap; it |
| 1689 | // will do nothing further. If we need to bail out for policy reasons, scavenge |
| 1690 | // before full gc, or any other specialized behavior, it needs to be added here. |
| 1691 | // |
| 1692 | // Note that this method should only be called from the vm_thread while at a |
| 1693 | // safepoint. |
| 1694 | // |
| 1695 | // Note that the all_soft_refs_clear flag in the soft ref policy |
| 1696 | // may be true because this method can be called without intervening |
| 1697 | // activity. For example when the heap space is tight and full measure |
| 1698 | // are being taken to free space. |
| 1699 | void PSParallelCompact::invoke(bool maximum_heap_compaction) { |
| 1700 | assert(SafepointSynchronize::is_at_safepoint(), "should be at safepoint")do { if (!(SafepointSynchronize::is_at_safepoint())) { (*g_assert_poison ) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 1700, "assert(" "SafepointSynchronize::is_at_safepoint()" ") failed" , "should be at safepoint"); ::breakpoint(); } } while (0); |
| 1701 | assert(Thread::current() == (Thread*)VMThread::vm_thread(),do { if (!(Thread::current() == (Thread*)VMThread::vm_thread( ))) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 1702, "assert(" "Thread::current() == (Thread*)VMThread::vm_thread()" ") failed", "should be in vm thread"); ::breakpoint(); } } while (0) |
| 1702 | "should be in vm thread")do { if (!(Thread::current() == (Thread*)VMThread::vm_thread( ))) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 1702, "assert(" "Thread::current() == (Thread*)VMThread::vm_thread()" ") failed", "should be in vm thread"); ::breakpoint(); } } while (0); |
| 1703 | |
| 1704 | ParallelScavengeHeap* heap = ParallelScavengeHeap::heap(); |
| 1705 | GCCause::Cause gc_cause = heap->gc_cause(); |
| 1706 | assert(!heap->is_gc_active(), "not reentrant")do { if (!(!heap->is_gc_active())) { (*g_assert_poison) = 'X' ;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 1706, "assert(" "!heap->is_gc_active()" ") failed", "not reentrant" ); ::breakpoint(); } } while (0); |
| 1707 | |
| 1708 | PSAdaptiveSizePolicy* policy = heap->size_policy(); |
| 1709 | IsGCActiveMark mark; |
| 1710 | |
| 1711 | if (ScavengeBeforeFullGC) { |
| 1712 | PSScavenge::invoke_no_policy(); |
| 1713 | } |
| 1714 | |
| 1715 | const bool clear_all_soft_refs = |
| 1716 | heap->soft_ref_policy()->should_clear_all_soft_refs(); |
| 1717 | |
| 1718 | PSParallelCompact::invoke_no_policy(clear_all_soft_refs || |
| 1719 | maximum_heap_compaction); |
| 1720 | } |
| 1721 | |
| 1722 | // This method contains no policy. You should probably |
| 1723 | // be calling invoke() instead. |
| 1724 | bool PSParallelCompact::invoke_no_policy(bool maximum_heap_compaction) { |
| 1725 | assert(SafepointSynchronize::is_at_safepoint(), "must be at a safepoint")do { if (!(SafepointSynchronize::is_at_safepoint())) { (*g_assert_poison ) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 1725, "assert(" "SafepointSynchronize::is_at_safepoint()" ") failed" , "must be at a safepoint"); ::breakpoint(); } } while (0); |
| 1726 | assert(ref_processor() != NULL, "Sanity")do { if (!(ref_processor() != __null)) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 1726, "assert(" "ref_processor() != __null" ") failed", "Sanity" ); ::breakpoint(); } } while (0); |
| 1727 | |
| 1728 | if (GCLocker::check_active_before_gc()) { |
| 1729 | return false; |
| 1730 | } |
| 1731 | |
| 1732 | ParallelScavengeHeap* heap = ParallelScavengeHeap::heap(); |
| 1733 | |
| 1734 | GCIdMark gc_id_mark; |
| 1735 | _gc_timer.register_gc_start(); |
| 1736 | _gc_tracer.report_gc_start(heap->gc_cause(), _gc_timer.gc_start()); |
| 1737 | |
| 1738 | TimeStamp marking_start; |
| 1739 | TimeStamp compaction_start; |
| 1740 | TimeStamp collection_exit; |
| 1741 | |
| 1742 | GCCause::Cause gc_cause = heap->gc_cause(); |
| 1743 | PSYoungGen* young_gen = heap->young_gen(); |
| 1744 | PSOldGen* old_gen = heap->old_gen(); |
| 1745 | PSAdaptiveSizePolicy* size_policy = heap->size_policy(); |
| 1746 | |
| 1747 | // The scope of casr should end after code that can change |
| 1748 | // SoftRefPolicy::_should_clear_all_soft_refs. |
| 1749 | ClearedAllSoftRefs casr(maximum_heap_compaction, |
| 1750 | heap->soft_ref_policy()); |
| 1751 | |
| 1752 | if (ZapUnusedHeapArea) { |
| 1753 | // Save information needed to minimize mangling |
| 1754 | heap->record_gen_tops_before_GC(); |
| 1755 | } |
| 1756 | |
| 1757 | // Make sure data structures are sane, make the heap parsable, and do other |
| 1758 | // miscellaneous bookkeeping. |
| 1759 | pre_compact(); |
| 1760 | |
| 1761 | const PreGenGCValues pre_gc_values = heap->get_pre_gc_values(); |
| 1762 | |
| 1763 | // Get the compaction manager reserved for the VM thread. |
| 1764 | ParCompactionManager* const vmthread_cm = ParCompactionManager::get_vmthread_cm(); |
| 1765 | |
| 1766 | { |
| 1767 | const uint active_workers = |
| 1768 | WorkerPolicy::calc_active_workers(ParallelScavengeHeap::heap()->workers().max_workers(), |
| 1769 | ParallelScavengeHeap::heap()->workers().active_workers(), |
| 1770 | Threads::number_of_non_daemon_threads()); |
| 1771 | ParallelScavengeHeap::heap()->workers().set_active_workers(active_workers); |
| 1772 | |
| 1773 | GCTraceCPUTime tcpu; |
| 1774 | GCTraceTime(Info, gc)GCTraceTimeWrapper<LogLevel::Info, (LogTag::_gc), (LogTag:: __NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG ), (LogTag::__NO_TAG)> tm("Pause Full", NULL__null, gc_cause, true); |
| 1775 | |
| 1776 | heap->pre_full_gc_dump(&_gc_timer); |
| 1777 | |
| 1778 | TraceCollectorStats tcs(counters()); |
| 1779 | TraceMemoryManagerStats tms(heap->old_gc_manager(), gc_cause); |
| 1780 | |
| 1781 | if (log_is_enabled(Debug, gc, heap, exit)(LogImpl<(LogTag::_gc), (LogTag::_heap), (LogTag::_exit), ( LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG)> ::is_level(LogLevel::Debug))) { |
| 1782 | accumulated_time()->start(); |
| 1783 | } |
| 1784 | |
| 1785 | // Let the size policy know we're starting |
| 1786 | size_policy->major_collection_begin(); |
| 1787 | |
| 1788 | #if COMPILER2_OR_JVMCI1 |
| 1789 | DerivedPointerTable::clear(); |
| 1790 | #endif |
| 1791 | |
| 1792 | ref_processor()->start_discovery(maximum_heap_compaction); |
| 1793 | |
| 1794 | marking_start.update(); |
| 1795 | marking_phase(vmthread_cm, &_gc_tracer); |
| 1796 | |
| 1797 | bool max_on_system_gc = UseMaximumCompactionOnSystemGC |
| 1798 | && GCCause::is_user_requested_gc(gc_cause); |
| 1799 | summary_phase(vmthread_cm, maximum_heap_compaction || max_on_system_gc); |
| 1800 | |
| 1801 | #if COMPILER2_OR_JVMCI1 |
| 1802 | assert(DerivedPointerTable::is_active(), "Sanity")do { if (!(DerivedPointerTable::is_active())) { (*g_assert_poison ) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 1802, "assert(" "DerivedPointerTable::is_active()" ") failed" , "Sanity"); ::breakpoint(); } } while (0); |
| 1803 | DerivedPointerTable::set_active(false); |
| 1804 | #endif |
| 1805 | |
| 1806 | // adjust_roots() updates Universe::_intArrayKlassObj which is |
| 1807 | // needed by the compaction for filling holes in the dense prefix. |
| 1808 | adjust_roots(); |
| 1809 | |
| 1810 | compaction_start.update(); |
| 1811 | compact(); |
| 1812 | |
| 1813 | ParCompactionManager::verify_all_region_stack_empty(); |
| 1814 | |
| 1815 | // Reset the mark bitmap, summary data, and do other bookkeeping. Must be |
| 1816 | // done before resizing. |
| 1817 | post_compact(); |
| 1818 | |
| 1819 | // Let the size policy know we're done |
| 1820 | size_policy->major_collection_end(old_gen->used_in_bytes(), gc_cause); |
| 1821 | |
| 1822 | if (UseAdaptiveSizePolicy) { |
| 1823 | log_debug(gc, ergo)(!(LogImpl<(LogTag::_gc), (LogTag::_ergo), (LogTag::__NO_TAG ), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG) >::is_level(LogLevel::Debug))) ? (void)0 : LogImpl<(LogTag ::_gc), (LogTag::_ergo), (LogTag::__NO_TAG), (LogTag::__NO_TAG ), (LogTag::__NO_TAG), (LogTag::__NO_TAG)>::write<LogLevel ::Debug>("AdaptiveSizeStart: collection: %d ", heap->total_collections()); |
| 1824 | log_trace(gc, ergo)(!(LogImpl<(LogTag::_gc), (LogTag::_ergo), (LogTag::__NO_TAG ), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG) >::is_level(LogLevel::Trace))) ? (void)0 : LogImpl<(LogTag ::_gc), (LogTag::_ergo), (LogTag::__NO_TAG), (LogTag::__NO_TAG ), (LogTag::__NO_TAG), (LogTag::__NO_TAG)>::write<LogLevel ::Trace>("old_gen_capacity: " SIZE_FORMAT"%" "l" "u" " young_gen_capacity: " SIZE_FORMAT"%" "l" "u", |
| 1825 | old_gen->capacity_in_bytes(), young_gen->capacity_in_bytes()); |
| 1826 | |
| 1827 | // Don't check if the size_policy is ready here. Let |
| 1828 | // the size_policy check that internally. |
| 1829 | if (UseAdaptiveGenerationSizePolicyAtMajorCollection && |
| 1830 | AdaptiveSizePolicy::should_update_promo_stats(gc_cause)) { |
| 1831 | // Swap the survivor spaces if from_space is empty. The |
| 1832 | // resize_young_gen() called below is normally used after |
| 1833 | // a successful young GC and swapping of survivor spaces; |
| 1834 | // otherwise, it will fail to resize the young gen with |
| 1835 | // the current implementation. |
| 1836 | if (young_gen->from_space()->is_empty()) { |
| 1837 | young_gen->from_space()->clear(SpaceDecorator::Mangle); |
| 1838 | young_gen->swap_spaces(); |
| 1839 | } |
| 1840 | |
| 1841 | // Calculate optimal free space amounts |
| 1842 | assert(young_gen->max_gen_size() >do { if (!(young_gen->max_gen_size() > young_gen->from_space ()->capacity_in_bytes() + young_gen->to_space()->capacity_in_bytes ())) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 1845, "assert(" "young_gen->max_gen_size() > young_gen->from_space()->capacity_in_bytes() + young_gen->to_space()->capacity_in_bytes()" ") failed", "Sizes of space in young gen are out-of-bounds") ; ::breakpoint(); } } while (0) |
| 1843 | young_gen->from_space()->capacity_in_bytes() +do { if (!(young_gen->max_gen_size() > young_gen->from_space ()->capacity_in_bytes() + young_gen->to_space()->capacity_in_bytes ())) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 1845, "assert(" "young_gen->max_gen_size() > young_gen->from_space()->capacity_in_bytes() + young_gen->to_space()->capacity_in_bytes()" ") failed", "Sizes of space in young gen are out-of-bounds") ; ::breakpoint(); } } while (0) |
| 1844 | young_gen->to_space()->capacity_in_bytes(),do { if (!(young_gen->max_gen_size() > young_gen->from_space ()->capacity_in_bytes() + young_gen->to_space()->capacity_in_bytes ())) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 1845, "assert(" "young_gen->max_gen_size() > young_gen->from_space()->capacity_in_bytes() + young_gen->to_space()->capacity_in_bytes()" ") failed", "Sizes of space in young gen are out-of-bounds") ; ::breakpoint(); } } while (0) |
| 1845 | "Sizes of space in young gen are out-of-bounds")do { if (!(young_gen->max_gen_size() > young_gen->from_space ()->capacity_in_bytes() + young_gen->to_space()->capacity_in_bytes ())) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 1845, "assert(" "young_gen->max_gen_size() > young_gen->from_space()->capacity_in_bytes() + young_gen->to_space()->capacity_in_bytes()" ") failed", "Sizes of space in young gen are out-of-bounds") ; ::breakpoint(); } } while (0); |
| 1846 | |
| 1847 | size_t young_live = young_gen->used_in_bytes(); |
| 1848 | size_t eden_live = young_gen->eden_space()->used_in_bytes(); |
| 1849 | size_t old_live = old_gen->used_in_bytes(); |
| 1850 | size_t cur_eden = young_gen->eden_space()->capacity_in_bytes(); |
| 1851 | size_t max_old_gen_size = old_gen->max_gen_size(); |
| 1852 | size_t max_eden_size = young_gen->max_gen_size() - |
| 1853 | young_gen->from_space()->capacity_in_bytes() - |
| 1854 | young_gen->to_space()->capacity_in_bytes(); |
| 1855 | |
| 1856 | // Used for diagnostics |
| 1857 | size_policy->clear_generation_free_space_flags(); |
| 1858 | |
| 1859 | size_policy->compute_generations_free_space(young_live, |
| 1860 | eden_live, |
| 1861 | old_live, |
| 1862 | cur_eden, |
| 1863 | max_old_gen_size, |
| 1864 | max_eden_size, |
| 1865 | true /* full gc*/); |
| 1866 | |
| 1867 | size_policy->check_gc_overhead_limit(eden_live, |
| 1868 | max_old_gen_size, |
| 1869 | max_eden_size, |
| 1870 | true /* full gc*/, |
| 1871 | gc_cause, |
| 1872 | heap->soft_ref_policy()); |
| 1873 | |
| 1874 | size_policy->decay_supplemental_growth(true /* full gc*/); |
| 1875 | |
| 1876 | heap->resize_old_gen( |
| 1877 | size_policy->calculated_old_free_size_in_bytes()); |
| 1878 | |
| 1879 | heap->resize_young_gen(size_policy->calculated_eden_size_in_bytes(), |
| 1880 | size_policy->calculated_survivor_size_in_bytes()); |
| 1881 | } |
| 1882 | |
| 1883 | log_debug(gc, ergo)(!(LogImpl<(LogTag::_gc), (LogTag::_ergo), (LogTag::__NO_TAG ), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG) >::is_level(LogLevel::Debug))) ? (void)0 : LogImpl<(LogTag ::_gc), (LogTag::_ergo), (LogTag::__NO_TAG), (LogTag::__NO_TAG ), (LogTag::__NO_TAG), (LogTag::__NO_TAG)>::write<LogLevel ::Debug>("AdaptiveSizeStop: collection: %d ", heap->total_collections()); |
| 1884 | } |
| 1885 | |
| 1886 | if (UsePerfData) { |
| 1887 | PSGCAdaptivePolicyCounters* const counters = heap->gc_policy_counters(); |
| 1888 | counters->update_counters(); |
| 1889 | counters->update_old_capacity(old_gen->capacity_in_bytes()); |
| 1890 | counters->update_young_capacity(young_gen->capacity_in_bytes()); |
| 1891 | } |
| 1892 | |
| 1893 | heap->resize_all_tlabs(); |
| 1894 | |
| 1895 | // Resize the metaspace capacity after a collection |
| 1896 | MetaspaceGC::compute_new_size(); |
| 1897 | |
| 1898 | if (log_is_enabled(Debug, gc, heap, exit)(LogImpl<(LogTag::_gc), (LogTag::_heap), (LogTag::_exit), ( LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG)> ::is_level(LogLevel::Debug))) { |
| 1899 | accumulated_time()->stop(); |
| 1900 | } |
| 1901 | |
| 1902 | heap->print_heap_change(pre_gc_values); |
| 1903 | |
| 1904 | // Track memory usage and detect low memory |
| 1905 | MemoryService::track_memory_usage(); |
| 1906 | heap->update_counters(); |
| 1907 | |
| 1908 | heap->post_full_gc_dump(&_gc_timer); |
| 1909 | } |
| 1910 | |
| 1911 | if (VerifyAfterGC && heap->total_collections() >= VerifyGCStartAt) { |
| 1912 | Universe::verify("After GC"); |
| 1913 | } |
| 1914 | |
| 1915 | // Re-verify object start arrays |
| 1916 | if (VerifyObjectStartArray && |
| 1917 | VerifyAfterGC) { |
| 1918 | old_gen->verify_object_start_array(); |
| 1919 | } |
| 1920 | |
| 1921 | if (ZapUnusedHeapArea) { |
| 1922 | old_gen->object_space()->check_mangled_unused_area_complete(); |
| 1923 | } |
| 1924 | |
| 1925 | collection_exit.update(); |
| 1926 | |
| 1927 | heap->print_heap_after_gc(); |
| 1928 | heap->trace_heap_after_gc(&_gc_tracer); |
| 1929 | |
| 1930 | log_debug(gc, task, time)(!(LogImpl<(LogTag::_gc), (LogTag::_task), (LogTag::_time) , (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG)> ::is_level(LogLevel::Debug))) ? (void)0 : LogImpl<(LogTag:: _gc), (LogTag::_task), (LogTag::_time), (LogTag::__NO_TAG), ( LogTag::__NO_TAG), (LogTag::__NO_TAG)>::write<LogLevel:: Debug>("VM-Thread " JLONG_FORMAT"%" "l" "d" " " JLONG_FORMAT"%" "l" "d" " " JLONG_FORMAT"%" "l" "d", |
| 1931 | marking_start.ticks(), compaction_start.ticks(), |
| 1932 | collection_exit.ticks()); |
| 1933 | |
| 1934 | AdaptiveSizePolicyOutput::print(size_policy, heap->total_collections()); |
| 1935 | |
| 1936 | _gc_timer.register_gc_end(); |
| 1937 | |
| 1938 | _gc_tracer.report_dense_prefix(dense_prefix(old_space_id)); |
| 1939 | _gc_tracer.report_gc_end(_gc_timer.gc_end(), _gc_timer.time_partitions()); |
| 1940 | |
| 1941 | return true; |
| 1942 | } |
| 1943 | |
| 1944 | class PCAddThreadRootsMarkingTaskClosure : public ThreadClosure { |
| 1945 | private: |
| 1946 | uint _worker_id; |
| 1947 | |
| 1948 | public: |
| 1949 | PCAddThreadRootsMarkingTaskClosure(uint worker_id) : _worker_id(worker_id) { } |
| 1950 | void do_thread(Thread* thread) { |
| 1951 | assert(ParallelScavengeHeap::heap()->is_gc_active(), "called outside gc")do { if (!(ParallelScavengeHeap::heap()->is_gc_active())) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 1951, "assert(" "ParallelScavengeHeap::heap()->is_gc_active()" ") failed", "called outside gc"); ::breakpoint(); } } while ( 0); |
| 1952 | |
| 1953 | ResourceMark rm; |
| 1954 | |
| 1955 | ParCompactionManager* cm = ParCompactionManager::gc_thread_compaction_manager(_worker_id); |
| 1956 | |
| 1957 | PCMarkAndPushClosure mark_and_push_closure(cm); |
| 1958 | MarkingCodeBlobClosure mark_and_push_in_blobs(&mark_and_push_closure, !CodeBlobToOopClosure::FixRelocations); |
| 1959 | |
| 1960 | thread->oops_do(&mark_and_push_closure, &mark_and_push_in_blobs); |
| 1961 | |
| 1962 | // Do the real work |
| 1963 | cm->follow_marking_stacks(); |
| 1964 | } |
| 1965 | }; |
| 1966 | |
| 1967 | static void mark_from_roots_work(ParallelRootType::Value root_type, uint worker_id) { |
| 1968 | assert(ParallelScavengeHeap::heap()->is_gc_active(), "called outside gc")do { if (!(ParallelScavengeHeap::heap()->is_gc_active())) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 1968, "assert(" "ParallelScavengeHeap::heap()->is_gc_active()" ") failed", "called outside gc"); ::breakpoint(); } } while ( 0); |
| 1969 | |
| 1970 | ParCompactionManager* cm = |
| 1971 | ParCompactionManager::gc_thread_compaction_manager(worker_id); |
| 1972 | PCMarkAndPushClosure mark_and_push_closure(cm); |
| 1973 | |
| 1974 | switch (root_type) { |
| 1975 | case ParallelRootType::class_loader_data: |
| 1976 | { |
| 1977 | CLDToOopClosure cld_closure(&mark_and_push_closure, ClassLoaderData::_claim_strong); |
| 1978 | ClassLoaderDataGraph::always_strong_cld_do(&cld_closure); |
| 1979 | } |
| 1980 | break; |
| 1981 | |
| 1982 | case ParallelRootType::code_cache: |
| 1983 | // Do not treat nmethods as strong roots for mark/sweep, since we can unload them. |
| 1984 | //ScavengableNMethods::scavengable_nmethods_do(CodeBlobToOopClosure(&mark_and_push_closure)); |
| 1985 | break; |
| 1986 | |
| 1987 | case ParallelRootType::sentinel: |
| 1988 | DEBUG_ONLY(default:)default: // DEBUG_ONLY hack will create compile error on release builds (-Wswitch) and runtime check on debug builds |
| 1989 | fatal("Bad enumeration value: %u", root_type)do { (*g_assert_poison) = 'X';; report_fatal(INTERNAL_ERROR, "/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 1989, "Bad enumeration value: %u", root_type); ::breakpoint (); } while (0); |
| 1990 | break; |
| 1991 | } |
| 1992 | |
| 1993 | // Do the real work |
| 1994 | cm->follow_marking_stacks(); |
| 1995 | } |
| 1996 | |
| 1997 | void steal_marking_work(TaskTerminator& terminator, uint worker_id) { |
| 1998 | assert(ParallelScavengeHeap::heap()->is_gc_active(), "called outside gc")do { if (!(ParallelScavengeHeap::heap()->is_gc_active())) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 1998, "assert(" "ParallelScavengeHeap::heap()->is_gc_active()" ") failed", "called outside gc"); ::breakpoint(); } } while ( 0); |
| 1999 | |
| 2000 | ParCompactionManager* cm = |
| 2001 | ParCompactionManager::gc_thread_compaction_manager(worker_id); |
| 2002 | |
| 2003 | oop obj = NULL__null; |
| 2004 | ObjArrayTask task; |
| 2005 | do { |
| 2006 | while (ParCompactionManager::steal_objarray(worker_id, task)) { |
| 2007 | cm->follow_array((objArrayOop)task.obj(), task.index()); |
| 2008 | cm->follow_marking_stacks(); |
| 2009 | } |
| 2010 | while (ParCompactionManager::steal(worker_id, obj)) { |
| 2011 | cm->follow_contents(obj); |
| 2012 | cm->follow_marking_stacks(); |
| 2013 | } |
| 2014 | } while (!terminator.offer_termination()); |
| 2015 | } |
| 2016 | |
| 2017 | class MarkFromRootsTask : public WorkerTask { |
| 2018 | StrongRootsScope _strong_roots_scope; // needed for Threads::possibly_parallel_threads_do |
| 2019 | OopStorageSetStrongParState<false /* concurrent */, false /* is_const */> _oop_storage_set_par_state; |
| 2020 | SequentialSubTasksDone _subtasks; |
| 2021 | TaskTerminator _terminator; |
| 2022 | uint _active_workers; |
| 2023 | |
| 2024 | public: |
| 2025 | MarkFromRootsTask(uint active_workers) : |
| 2026 | WorkerTask("MarkFromRootsTask"), |
| 2027 | _strong_roots_scope(active_workers), |
| 2028 | _subtasks(ParallelRootType::sentinel), |
| 2029 | _terminator(active_workers, ParCompactionManager::oop_task_queues()), |
| 2030 | _active_workers(active_workers) { |
| 2031 | } |
| 2032 | |
| 2033 | virtual void work(uint worker_id) { |
| 2034 | for (uint task = 0; _subtasks.try_claim_task(task); /*empty*/ ) { |
| 2035 | mark_from_roots_work(static_cast<ParallelRootType::Value>(task), worker_id); |
| 2036 | } |
| 2037 | |
| 2038 | PCAddThreadRootsMarkingTaskClosure closure(worker_id); |
| 2039 | Threads::possibly_parallel_threads_do(true /*parallel */, &closure); |
| 2040 | |
| 2041 | // Mark from OopStorages |
| 2042 | { |
| 2043 | ParCompactionManager* cm = ParCompactionManager::gc_thread_compaction_manager(worker_id); |
| 2044 | PCMarkAndPushClosure closure(cm); |
| 2045 | _oop_storage_set_par_state.oops_do(&closure); |
| 2046 | // Do the real work |
| 2047 | cm->follow_marking_stacks(); |
| 2048 | } |
| 2049 | |
| 2050 | if (_active_workers > 1) { |
| 2051 | steal_marking_work(_terminator, worker_id); |
| 2052 | } |
| 2053 | } |
| 2054 | }; |
| 2055 | |
| 2056 | class ParallelCompactRefProcProxyTask : public RefProcProxyTask { |
| 2057 | TaskTerminator _terminator; |
| 2058 | |
| 2059 | public: |
| 2060 | ParallelCompactRefProcProxyTask(uint max_workers) |
| 2061 | : RefProcProxyTask("ParallelCompactRefProcProxyTask", max_workers), |
| 2062 | _terminator(_max_workers, ParCompactionManager::oop_task_queues()) {} |
| 2063 | |
| 2064 | void work(uint worker_id) override { |
| 2065 | assert(worker_id < _max_workers, "sanity")do { if (!(worker_id < _max_workers)) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 2065, "assert(" "worker_id < _max_workers" ") failed", "sanity" ); ::breakpoint(); } } while (0); |
| 2066 | ParCompactionManager* cm = (_tm == RefProcThreadModel::Single) ? ParCompactionManager::get_vmthread_cm() : ParCompactionManager::gc_thread_compaction_manager(worker_id); |
| 2067 | PCMarkAndPushClosure keep_alive(cm); |
| 2068 | BarrierEnqueueDiscoveredFieldClosure enqueue; |
| 2069 | ParCompactionManager::FollowStackClosure complete_gc(cm, (_tm == RefProcThreadModel::Single) ? nullptr : &_terminator, worker_id); |
| 2070 | _rp_task->rp_work(worker_id, PSParallelCompact::is_alive_closure(), &keep_alive, &enqueue, &complete_gc); |
| 2071 | } |
| 2072 | |
| 2073 | void prepare_run_task_hook() override { |
| 2074 | _terminator.reset_for_reuse(_queue_count); |
| 2075 | } |
| 2076 | }; |
| 2077 | |
| 2078 | void PSParallelCompact::marking_phase(ParCompactionManager* cm, |
| 2079 | ParallelOldTracer *gc_tracer) { |
| 2080 | // Recursively traverse all live objects and mark them |
| 2081 | GCTraceTime(Info, gc, phases)GCTraceTimeWrapper<LogLevel::Info, (LogTag::_gc), (LogTag:: _phases), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG ), (LogTag::__NO_TAG)> tm("Marking Phase", &_gc_timer); |
| 2082 | |
| 2083 | uint active_gc_threads = ParallelScavengeHeap::heap()->workers().active_workers(); |
| 2084 | |
| 2085 | // Need new claim bits before marking starts. |
| 2086 | ClassLoaderDataGraph::clear_claimed_marks(); |
| 2087 | |
| 2088 | { |
| 2089 | GCTraceTime(Debug, gc, phases)GCTraceTimeWrapper<LogLevel::Debug, (LogTag::_gc), (LogTag ::_phases), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag:: __NO_TAG), (LogTag::__NO_TAG)> tm("Par Mark", &_gc_timer); |
| 2090 | |
| 2091 | MarkFromRootsTask task(active_gc_threads); |
| 2092 | ParallelScavengeHeap::heap()->workers().run_task(&task); |
| 2093 | } |
| 2094 | |
| 2095 | // Process reference objects found during marking |
| 2096 | { |
| 2097 | GCTraceTime(Debug, gc, phases)GCTraceTimeWrapper<LogLevel::Debug, (LogTag::_gc), (LogTag ::_phases), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag:: __NO_TAG), (LogTag::__NO_TAG)> tm("Reference Processing", &_gc_timer); |
| 2098 | |
| 2099 | ReferenceProcessorStats stats; |
| 2100 | ReferenceProcessorPhaseTimes pt(&_gc_timer, ref_processor()->max_num_queues()); |
| 2101 | |
| 2102 | ref_processor()->set_active_mt_degree(active_gc_threads); |
| 2103 | ParallelCompactRefProcProxyTask task(ref_processor()->max_num_queues()); |
| 2104 | stats = ref_processor()->process_discovered_references(task, pt); |
| 2105 | |
| 2106 | gc_tracer->report_gc_reference_stats(stats); |
| 2107 | pt.print_all_references(); |
| 2108 | } |
| 2109 | |
| 2110 | // This is the point where the entire marking should have completed. |
| 2111 | ParCompactionManager::verify_all_marking_stack_empty(); |
| 2112 | |
| 2113 | { |
| 2114 | GCTraceTime(Debug, gc, phases)GCTraceTimeWrapper<LogLevel::Debug, (LogTag::_gc), (LogTag ::_phases), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag:: __NO_TAG), (LogTag::__NO_TAG)> tm("Weak Processing", &_gc_timer); |
| 2115 | WeakProcessor::weak_oops_do(&ParallelScavengeHeap::heap()->workers(), |
| 2116 | is_alive_closure(), |
| 2117 | &do_nothing_cl, |
| 2118 | 1); |
| 2119 | } |
| 2120 | |
| 2121 | { |
| 2122 | GCTraceTime(Debug, gc, phases)GCTraceTimeWrapper<LogLevel::Debug, (LogTag::_gc), (LogTag ::_phases), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag:: __NO_TAG), (LogTag::__NO_TAG)> tm_m("Class Unloading", &_gc_timer); |
| 2123 | |
| 2124 | // Follow system dictionary roots and unload classes. |
| 2125 | bool purged_class = SystemDictionary::do_unloading(&_gc_timer); |
| 2126 | |
| 2127 | // Unload nmethods. |
| 2128 | CodeCache::do_unloading(is_alive_closure(), purged_class); |
| 2129 | |
| 2130 | // Prune dead klasses from subklass/sibling/implementor lists. |
| 2131 | Klass::clean_weak_klass_links(purged_class); |
| 2132 | |
| 2133 | // Clean JVMCI metadata handles. |
| 2134 | JVMCI_ONLY(JVMCI::do_unloading(purged_class))JVMCI::do_unloading(purged_class); |
| 2135 | } |
| 2136 | |
| 2137 | _gc_tracer.report_object_count_after_gc(is_alive_closure()); |
| 2138 | } |
| 2139 | |
| 2140 | #ifdef ASSERT1 |
| 2141 | void PCAdjustPointerClosure::verify_cm(ParCompactionManager* cm) { |
| 2142 | assert(cm != NULL, "associate ParCompactionManage should not be NULL")do { if (!(cm != __null)) { (*g_assert_poison) = 'X';; report_vm_error ("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 2142, "assert(" "cm != __null" ") failed", "associate ParCompactionManage should not be NULL" ); ::breakpoint(); } } while (0); |
| 2143 | auto vmthread_cm = ParCompactionManager::get_vmthread_cm(); |
| 2144 | if (Thread::current()->is_VM_thread()) { |
| 2145 | assert(cm == vmthread_cm, "VM threads should use ParCompactionManager from get_vmthread_cm()")do { if (!(cm == vmthread_cm)) { (*g_assert_poison) = 'X';; report_vm_error ("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 2145, "assert(" "cm == vmthread_cm" ") failed", "VM threads should use ParCompactionManager from get_vmthread_cm()" ); ::breakpoint(); } } while (0); |
| 2146 | } else { |
| 2147 | assert(Thread::current()->is_Worker_thread(), "Must be a GC thread")do { if (!(Thread::current()->is_Worker_thread())) { (*g_assert_poison ) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 2147, "assert(" "Thread::current()->is_Worker_thread()" ") failed" , "Must be a GC thread"); ::breakpoint(); } } while (0); |
| 2148 | assert(cm != vmthread_cm, "GC threads should use ParCompactionManager from gc_thread_compaction_manager()")do { if (!(cm != vmthread_cm)) { (*g_assert_poison) = 'X';; report_vm_error ("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 2148, "assert(" "cm != vmthread_cm" ") failed", "GC threads should use ParCompactionManager from gc_thread_compaction_manager()" ); ::breakpoint(); } } while (0); |
| 2149 | } |
| 2150 | } |
| 2151 | #endif |
| 2152 | |
| 2153 | class PSAdjustTask final : public WorkerTask { |
| 2154 | SubTasksDone _sub_tasks; |
| 2155 | WeakProcessor::Task _weak_proc_task; |
| 2156 | OopStorageSetStrongParState<false, false> _oop_storage_iter; |
| 2157 | uint _nworkers; |
| 2158 | |
| 2159 | enum PSAdjustSubTask { |
| 2160 | PSAdjustSubTask_code_cache, |
| 2161 | |
| 2162 | PSAdjustSubTask_num_elements |
| 2163 | }; |
| 2164 | |
| 2165 | public: |
| 2166 | PSAdjustTask(uint nworkers) : |
| 2167 | WorkerTask("PSAdjust task"), |
| 2168 | _sub_tasks(PSAdjustSubTask_num_elements), |
| 2169 | _weak_proc_task(nworkers), |
| 2170 | _nworkers(nworkers) { |
| 2171 | // Need new claim bits when tracing through and adjusting pointers. |
| 2172 | ClassLoaderDataGraph::clear_claimed_marks(); |
| 2173 | if (nworkers > 1) { |
| 2174 | Threads::change_thread_claim_token(); |
| 2175 | } |
| 2176 | } |
| 2177 | |
| 2178 | ~PSAdjustTask() { |
| 2179 | Threads::assert_all_threads_claimed(); |
| 2180 | } |
| 2181 | |
| 2182 | void work(uint worker_id) { |
| 2183 | ParCompactionManager* cm = ParCompactionManager::gc_thread_compaction_manager(worker_id); |
| 2184 | PCAdjustPointerClosure adjust(cm); |
| 2185 | { |
| 2186 | ResourceMark rm; |
| 2187 | Threads::possibly_parallel_oops_do(_nworkers > 1, &adjust, nullptr); |
| 2188 | } |
| 2189 | _oop_storage_iter.oops_do(&adjust); |
| 2190 | { |
| 2191 | CLDToOopClosure cld_closure(&adjust, ClassLoaderData::_claim_strong); |
| 2192 | ClassLoaderDataGraph::cld_do(&cld_closure); |
| 2193 | } |
| 2194 | { |
| 2195 | AlwaysTrueClosure always_alive; |
| 2196 | _weak_proc_task.work(worker_id, &always_alive, &adjust); |
| 2197 | } |
| 2198 | if (_sub_tasks.try_claim_task(PSAdjustSubTask_code_cache)) { |
| 2199 | CodeBlobToOopClosure adjust_code(&adjust, CodeBlobToOopClosure::FixRelocations); |
| 2200 | CodeCache::blobs_do(&adjust_code); |
| 2201 | } |
| 2202 | _sub_tasks.all_tasks_claimed(); |
| 2203 | } |
| 2204 | }; |
| 2205 | |
| 2206 | void PSParallelCompact::adjust_roots() { |
| 2207 | // Adjust the pointers to reflect the new locations |
| 2208 | GCTraceTime(Info, gc, phases)GCTraceTimeWrapper<LogLevel::Info, (LogTag::_gc), (LogTag:: _phases), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG ), (LogTag::__NO_TAG)> tm("Adjust Roots", &_gc_timer); |
| 2209 | uint nworkers = ParallelScavengeHeap::heap()->workers().active_workers(); |
| 2210 | PSAdjustTask task(nworkers); |
| 2211 | ParallelScavengeHeap::heap()->workers().run_task(&task); |
| 2212 | } |
| 2213 | |
| 2214 | // Helper class to print 8 region numbers per line and then print the total at the end. |
| 2215 | class FillableRegionLogger : public StackObj { |
| 2216 | private: |
| 2217 | Log(gc, compaction)LogImpl<(LogTag::_gc), (LogTag::_compaction), (LogTag::__NO_TAG ), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG) > log; |
| 2218 | static const int LineLength = 8; |
| 2219 | size_t _regions[LineLength]; |
| 2220 | int _next_index; |
| 2221 | bool _enabled; |
| 2222 | size_t _total_regions; |
| 2223 | public: |
| 2224 | FillableRegionLogger() : _next_index(0), _enabled(log_develop_is_enabled(Trace, gc, compaction)(LogImpl<(LogTag::_gc), (LogTag::_compaction), (LogTag::__NO_TAG ), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG) >::is_level(LogLevel::Trace))), _total_regions(0) { } |
| 2225 | ~FillableRegionLogger() { |
| 2226 | log.trace(SIZE_FORMAT"%" "l" "u" " initially fillable regions", _total_regions); |
| 2227 | } |
| 2228 | |
| 2229 | void print_line() { |
| 2230 | if (!_enabled || _next_index == 0) { |
| 2231 | return; |
| 2232 | } |
| 2233 | FormatBuffer<> line("Fillable: "); |
| 2234 | for (int i = 0; i < _next_index; i++) { |
| 2235 | line.append(" " SIZE_FORMAT_W(7)"%" "7" "l" "u", _regions[i]); |
| 2236 | } |
| 2237 | log.trace("%s", line.buffer()); |
| 2238 | _next_index = 0; |
| 2239 | } |
| 2240 | |
| 2241 | void handle(size_t region) { |
| 2242 | if (!_enabled) { |
| 2243 | return; |
| 2244 | } |
| 2245 | _regions[_next_index++] = region; |
| 2246 | if (_next_index == LineLength) { |
| 2247 | print_line(); |
| 2248 | } |
| 2249 | _total_regions++; |
| 2250 | } |
| 2251 | }; |
| 2252 | |
| 2253 | void PSParallelCompact::prepare_region_draining_tasks(uint parallel_gc_threads) |
| 2254 | { |
| 2255 | GCTraceTime(Trace, gc, phases)GCTraceTimeWrapper<LogLevel::Trace, (LogTag::_gc), (LogTag ::_phases), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag:: __NO_TAG), (LogTag::__NO_TAG)> tm("Drain Task Setup", &_gc_timer); |
| 2256 | |
| 2257 | // Find the threads that are active |
| 2258 | uint worker_id = 0; |
| 2259 | |
| 2260 | // Find all regions that are available (can be filled immediately) and |
| 2261 | // distribute them to the thread stacks. The iteration is done in reverse |
| 2262 | // order (high to low) so the regions will be removed in ascending order. |
| 2263 | |
| 2264 | const ParallelCompactData& sd = PSParallelCompact::summary_data(); |
| 2265 | |
| 2266 | // id + 1 is used to test termination so unsigned can |
| 2267 | // be used with an old_space_id == 0. |
| 2268 | FillableRegionLogger region_logger; |
| 2269 | for (unsigned int id = to_space_id; id + 1 > old_space_id; --id) { |
| 2270 | SpaceInfo* const space_info = _space_info + id; |
| 2271 | HeapWord* const new_top = space_info->new_top(); |
| 2272 | |
| 2273 | const size_t beg_region = sd.addr_to_region_idx(space_info->dense_prefix()); |
| 2274 | const size_t end_region = |
| 2275 | sd.addr_to_region_idx(sd.region_align_up(new_top)); |
| 2276 | |
| 2277 | for (size_t cur = end_region - 1; cur + 1 > beg_region; --cur) { |
| 2278 | if (sd.region(cur)->claim_unsafe()) { |
| 2279 | ParCompactionManager* cm = ParCompactionManager::gc_thread_compaction_manager(worker_id); |
| 2280 | bool result = sd.region(cur)->mark_normal(); |
| 2281 | assert(result, "Must succeed at this point.")do { if (!(result)) { (*g_assert_poison) = 'X';; report_vm_error ("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 2281, "assert(" "result" ") failed", "Must succeed at this point." ); ::breakpoint(); } } while (0); |
| 2282 | cm->region_stack()->push(cur); |
| 2283 | region_logger.handle(cur); |
| 2284 | // Assign regions to tasks in round-robin fashion. |
| 2285 | if (++worker_id == parallel_gc_threads) { |
| 2286 | worker_id = 0; |
| 2287 | } |
| 2288 | } |
| 2289 | } |
| 2290 | region_logger.print_line(); |
| 2291 | } |
| 2292 | } |
| 2293 | |
| 2294 | class TaskQueue : StackObj { |
| 2295 | volatile uint _counter; |
| 2296 | uint _size; |
| 2297 | uint _insert_index; |
| 2298 | PSParallelCompact::UpdateDensePrefixTask* _backing_array; |
| 2299 | public: |
| 2300 | explicit TaskQueue(uint size) : _counter(0), _size(size), _insert_index(0), _backing_array(NULL__null) { |
| 2301 | _backing_array = NEW_C_HEAP_ARRAY(PSParallelCompact::UpdateDensePrefixTask, _size, mtGC)(PSParallelCompact::UpdateDensePrefixTask*) (AllocateHeap((_size ) * sizeof(PSParallelCompact::UpdateDensePrefixTask), mtGC)); |
| 2302 | } |
| 2303 | ~TaskQueue() { |
| 2304 | assert(_counter >= _insert_index, "not all queue elements were claimed")do { if (!(_counter >= _insert_index)) { (*g_assert_poison ) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 2304, "assert(" "_counter >= _insert_index" ") failed", "not all queue elements were claimed" ); ::breakpoint(); } } while (0); |
| 2305 | FREE_C_HEAP_ARRAY(T, _backing_array)FreeHeap((char*)(_backing_array)); |
| 2306 | } |
| 2307 | |
| 2308 | void push(const PSParallelCompact::UpdateDensePrefixTask& value) { |
| 2309 | assert(_insert_index < _size, "too small backing array")do { if (!(_insert_index < _size)) { (*g_assert_poison) = 'X' ;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 2309, "assert(" "_insert_index < _size" ") failed", "too small backing array" ); ::breakpoint(); } } while (0); |
| 2310 | _backing_array[_insert_index++] = value; |
| 2311 | } |
| 2312 | |
| 2313 | bool try_claim(PSParallelCompact::UpdateDensePrefixTask& reference) { |
| 2314 | uint claimed = Atomic::fetch_and_add(&_counter, 1u); |
| 2315 | if (claimed < _insert_index) { |
| 2316 | reference = _backing_array[claimed]; |
| 2317 | return true; |
| 2318 | } else { |
| 2319 | return false; |
| 2320 | } |
| 2321 | } |
| 2322 | }; |
| 2323 | |
| 2324 | #define PAR_OLD_DENSE_PREFIX_OVER_PARTITIONING4 4 |
| 2325 | |
| 2326 | void PSParallelCompact::enqueue_dense_prefix_tasks(TaskQueue& task_queue, |
| 2327 | uint parallel_gc_threads) { |
| 2328 | GCTraceTime(Trace, gc, phases)GCTraceTimeWrapper<LogLevel::Trace, (LogTag::_gc), (LogTag ::_phases), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag:: __NO_TAG), (LogTag::__NO_TAG)> tm("Dense Prefix Task Setup", &_gc_timer); |
| 2329 | |
| 2330 | ParallelCompactData& sd = PSParallelCompact::summary_data(); |
| 2331 | |
| 2332 | // Iterate over all the spaces adding tasks for updating |
| 2333 | // regions in the dense prefix. Assume that 1 gc thread |
| 2334 | // will work on opening the gaps and the remaining gc threads |
| 2335 | // will work on the dense prefix. |
| 2336 | unsigned int space_id; |
| 2337 | for (space_id = old_space_id; space_id < last_space_id; ++ space_id) { |
| 2338 | HeapWord* const dense_prefix_end = _space_info[space_id].dense_prefix(); |
| 2339 | const MutableSpace* const space = _space_info[space_id].space(); |
| 2340 | |
| 2341 | if (dense_prefix_end == space->bottom()) { |
| 2342 | // There is no dense prefix for this space. |
| 2343 | continue; |
| 2344 | } |
| 2345 | |
| 2346 | // The dense prefix is before this region. |
| 2347 | size_t region_index_end_dense_prefix = |
| 2348 | sd.addr_to_region_idx(dense_prefix_end); |
| 2349 | RegionData* const dense_prefix_cp = |
| 2350 | sd.region(region_index_end_dense_prefix); |
| 2351 | assert(dense_prefix_end == space->end() ||do { if (!(dense_prefix_end == space->end() || dense_prefix_cp ->available() || dense_prefix_cp->claimed())) { (*g_assert_poison ) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 2354, "assert(" "dense_prefix_end == space->end() || dense_prefix_cp->available() || dense_prefix_cp->claimed()" ") failed", "The region after the dense prefix should always be ready to fill" ); ::breakpoint(); } } while (0) |
| 2352 | dense_prefix_cp->available() ||do { if (!(dense_prefix_end == space->end() || dense_prefix_cp ->available() || dense_prefix_cp->claimed())) { (*g_assert_poison ) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 2354, "assert(" "dense_prefix_end == space->end() || dense_prefix_cp->available() || dense_prefix_cp->claimed()" ") failed", "The region after the dense prefix should always be ready to fill" ); ::breakpoint(); } } while (0) |
| 2353 | dense_prefix_cp->claimed(),do { if (!(dense_prefix_end == space->end() || dense_prefix_cp ->available() || dense_prefix_cp->claimed())) { (*g_assert_poison ) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 2354, "assert(" "dense_prefix_end == space->end() || dense_prefix_cp->available() || dense_prefix_cp->claimed()" ") failed", "The region after the dense prefix should always be ready to fill" ); ::breakpoint(); } } while (0) |
| 2354 | "The region after the dense prefix should always be ready to fill")do { if (!(dense_prefix_end == space->end() || dense_prefix_cp ->available() || dense_prefix_cp->claimed())) { (*g_assert_poison ) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 2354, "assert(" "dense_prefix_end == space->end() || dense_prefix_cp->available() || dense_prefix_cp->claimed()" ") failed", "The region after the dense prefix should always be ready to fill" ); ::breakpoint(); } } while (0); |
| 2355 | |
| 2356 | size_t region_index_start = sd.addr_to_region_idx(space->bottom()); |
| 2357 | |
| 2358 | // Is there dense prefix work? |
| 2359 | size_t total_dense_prefix_regions = |
| 2360 | region_index_end_dense_prefix - region_index_start; |
| 2361 | // How many regions of the dense prefix should be given to |
| 2362 | // each thread? |
| 2363 | if (total_dense_prefix_regions > 0) { |
| 2364 | uint tasks_for_dense_prefix = 1; |
| 2365 | if (total_dense_prefix_regions <= |
| 2366 | (parallel_gc_threads * PAR_OLD_DENSE_PREFIX_OVER_PARTITIONING4)) { |
| 2367 | // Don't over partition. This assumes that |
| 2368 | // PAR_OLD_DENSE_PREFIX_OVER_PARTITIONING is a small integer value |
| 2369 | // so there are not many regions to process. |
| 2370 | tasks_for_dense_prefix = parallel_gc_threads; |
| 2371 | } else { |
| 2372 | // Over partition |
| 2373 | tasks_for_dense_prefix = parallel_gc_threads * |
| 2374 | PAR_OLD_DENSE_PREFIX_OVER_PARTITIONING4; |
| 2375 | } |
| 2376 | size_t regions_per_thread = total_dense_prefix_regions / |
| 2377 | tasks_for_dense_prefix; |
| 2378 | // Give each thread at least 1 region. |
| 2379 | if (regions_per_thread == 0) { |
| 2380 | regions_per_thread = 1; |
| 2381 | } |
| 2382 | |
| 2383 | for (uint k = 0; k < tasks_for_dense_prefix; k++) { |
| 2384 | if (region_index_start >= region_index_end_dense_prefix) { |
| 2385 | break; |
| 2386 | } |
| 2387 | // region_index_end is not processed |
| 2388 | size_t region_index_end = MIN2(region_index_start + regions_per_thread, |
| 2389 | region_index_end_dense_prefix); |
| 2390 | task_queue.push(UpdateDensePrefixTask(SpaceId(space_id), |
| 2391 | region_index_start, |
| 2392 | region_index_end)); |
| 2393 | region_index_start = region_index_end; |
| 2394 | } |
| 2395 | } |
| 2396 | // This gets any part of the dense prefix that did not |
| 2397 | // fit evenly. |
| 2398 | if (region_index_start < region_index_end_dense_prefix) { |
| 2399 | task_queue.push(UpdateDensePrefixTask(SpaceId(space_id), |
| 2400 | region_index_start, |
| 2401 | region_index_end_dense_prefix)); |
| 2402 | } |
| 2403 | } |
| 2404 | } |
| 2405 | |
| 2406 | #ifdef ASSERT1 |
| 2407 | // Write a histogram of the number of times the block table was filled for a |
| 2408 | // region. |
| 2409 | void PSParallelCompact::write_block_fill_histogram() |
| 2410 | { |
| 2411 | if (!log_develop_is_enabled(Trace, gc, compaction)(LogImpl<(LogTag::_gc), (LogTag::_compaction), (LogTag::__NO_TAG ), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG) >::is_level(LogLevel::Trace))) { |
| 2412 | return; |
| 2413 | } |
| 2414 | |
| 2415 | Log(gc, compaction)LogImpl<(LogTag::_gc), (LogTag::_compaction), (LogTag::__NO_TAG ), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG) > log; |
| 2416 | ResourceMark rm; |
| 2417 | LogStream ls(log.trace()); |
| 2418 | outputStream* out = &ls; |
| 2419 | |
| 2420 | typedef ParallelCompactData::RegionData rd_t; |
| 2421 | ParallelCompactData& sd = summary_data(); |
| 2422 | |
| 2423 | for (unsigned int id = old_space_id; id < last_space_id; ++id) { |
| 2424 | MutableSpace* const spc = _space_info[id].space(); |
| 2425 | if (spc->bottom() != spc->top()) { |
| 2426 | const rd_t* const beg = sd.addr_to_region_ptr(spc->bottom()); |
| 2427 | HeapWord* const top_aligned_up = sd.region_align_up(spc->top()); |
| 2428 | const rd_t* const end = sd.addr_to_region_ptr(top_aligned_up); |
| 2429 | |
| 2430 | size_t histo[5] = { 0, 0, 0, 0, 0 }; |
| 2431 | const size_t histo_len = sizeof(histo) / sizeof(size_t); |
| 2432 | const size_t region_cnt = pointer_delta(end, beg, sizeof(rd_t)); |
| 2433 | |
| 2434 | for (const rd_t* cur = beg; cur < end; ++cur) { |
| 2435 | ++histo[MIN2(cur->blocks_filled_count(), histo_len - 1)]; |
| 2436 | } |
| 2437 | out->print("Block fill histogram: %u %-4s" SIZE_FORMAT_W(5)"%" "5" "l" "u", id, space_names[id], region_cnt); |
| 2438 | for (size_t i = 0; i < histo_len; ++i) { |
| 2439 | out->print(" " SIZE_FORMAT_W(5)"%" "5" "l" "u" " %5.1f%%", |
| 2440 | histo[i], 100.0 * histo[i] / region_cnt); |
| 2441 | } |
| 2442 | out->cr(); |
| 2443 | } |
| 2444 | } |
| 2445 | } |
| 2446 | #endif // #ifdef ASSERT |
| 2447 | |
| 2448 | static void compaction_with_stealing_work(TaskTerminator* terminator, uint worker_id) { |
| 2449 | assert(ParallelScavengeHeap::heap()->is_gc_active(), "called outside gc")do { if (!(ParallelScavengeHeap::heap()->is_gc_active())) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 2449, "assert(" "ParallelScavengeHeap::heap()->is_gc_active()" ") failed", "called outside gc"); ::breakpoint(); } } while ( 0); |
| 2450 | |
| 2451 | ParCompactionManager* cm = |
| 2452 | ParCompactionManager::gc_thread_compaction_manager(worker_id); |
| 2453 | |
| 2454 | // Drain the stacks that have been preloaded with regions |
| 2455 | // that are ready to fill. |
| 2456 | |
| 2457 | cm->drain_region_stacks(); |
| 2458 | |
| 2459 | guarantee(cm->region_stack()->is_empty(), "Not empty")do { if (!(cm->region_stack()->is_empty())) { (*g_assert_poison ) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 2459, "guarantee(" "cm->region_stack()->is_empty()" ") failed" , "Not empty"); ::breakpoint(); } } while (0); |
| 2460 | |
| 2461 | size_t region_index = 0; |
| 2462 | |
| 2463 | while (true) { |
| 2464 | if (ParCompactionManager::steal(worker_id, region_index)) { |
| 2465 | PSParallelCompact::fill_and_update_region(cm, region_index); |
| 2466 | cm->drain_region_stacks(); |
| 2467 | } else if (PSParallelCompact::steal_unavailable_region(cm, region_index)) { |
| 2468 | // Fill and update an unavailable region with the help of a shadow region |
| 2469 | PSParallelCompact::fill_and_update_shadow_region(cm, region_index); |
| 2470 | cm->drain_region_stacks(); |
| 2471 | } else { |
| 2472 | if (terminator->offer_termination()) { |
| 2473 | break; |
| 2474 | } |
| 2475 | // Go around again. |
| 2476 | } |
| 2477 | } |
| 2478 | } |
| 2479 | |
| 2480 | class UpdateDensePrefixAndCompactionTask: public WorkerTask { |
| 2481 | TaskQueue& _tq; |
| 2482 | TaskTerminator _terminator; |
| 2483 | uint _active_workers; |
| 2484 | |
| 2485 | public: |
| 2486 | UpdateDensePrefixAndCompactionTask(TaskQueue& tq, uint active_workers) : |
| 2487 | WorkerTask("UpdateDensePrefixAndCompactionTask"), |
| 2488 | _tq(tq), |
| 2489 | _terminator(active_workers, ParCompactionManager::region_task_queues()), |
| 2490 | _active_workers(active_workers) { |
| 2491 | } |
| 2492 | virtual void work(uint worker_id) { |
| 2493 | ParCompactionManager* cm = ParCompactionManager::gc_thread_compaction_manager(worker_id); |
| 2494 | |
| 2495 | for (PSParallelCompact::UpdateDensePrefixTask task; _tq.try_claim(task); /* empty */) { |
| 2496 | PSParallelCompact::update_and_deadwood_in_dense_prefix(cm, |
| 2497 | task._space_id, |
| 2498 | task._region_index_start, |
| 2499 | task._region_index_end); |
| 2500 | } |
| 2501 | |
| 2502 | // Once a thread has drained it's stack, it should try to steal regions from |
| 2503 | // other threads. |
| 2504 | compaction_with_stealing_work(&_terminator, worker_id); |
| 2505 | } |
| 2506 | }; |
| 2507 | |
| 2508 | void PSParallelCompact::compact() { |
| 2509 | GCTraceTime(Info, gc, phases)GCTraceTimeWrapper<LogLevel::Info, (LogTag::_gc), (LogTag:: _phases), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG ), (LogTag::__NO_TAG)> tm("Compaction Phase", &_gc_timer); |
| 2510 | |
| 2511 | ParallelScavengeHeap* heap = ParallelScavengeHeap::heap(); |
| 2512 | PSOldGen* old_gen = heap->old_gen(); |
| 2513 | old_gen->start_array()->reset(); |
| 2514 | uint active_gc_threads = ParallelScavengeHeap::heap()->workers().active_workers(); |
| 2515 | |
| 2516 | // for [0..last_space_id) |
| 2517 | // for [0..active_gc_threads * PAR_OLD_DENSE_PREFIX_OVER_PARTITIONING) |
| 2518 | // push |
| 2519 | // push |
| 2520 | // |
| 2521 | // max push count is thus: last_space_id * (active_gc_threads * PAR_OLD_DENSE_PREFIX_OVER_PARTITIONING + 1) |
| 2522 | TaskQueue task_queue(last_space_id * (active_gc_threads * PAR_OLD_DENSE_PREFIX_OVER_PARTITIONING4 + 1)); |
| 2523 | initialize_shadow_regions(active_gc_threads); |
| 2524 | prepare_region_draining_tasks(active_gc_threads); |
| 2525 | enqueue_dense_prefix_tasks(task_queue, active_gc_threads); |
| 2526 | |
| 2527 | { |
| 2528 | GCTraceTime(Trace, gc, phases)GCTraceTimeWrapper<LogLevel::Trace, (LogTag::_gc), (LogTag ::_phases), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag:: __NO_TAG), (LogTag::__NO_TAG)> tm("Par Compact", &_gc_timer); |
| 2529 | |
| 2530 | UpdateDensePrefixAndCompactionTask task(task_queue, active_gc_threads); |
| 2531 | ParallelScavengeHeap::heap()->workers().run_task(&task); |
| 2532 | |
| 2533 | #ifdef ASSERT1 |
| 2534 | // Verify that all regions have been processed before the deferred updates. |
| 2535 | for (unsigned int id = old_space_id; id < last_space_id; ++id) { |
| 2536 | verify_complete(SpaceId(id)); |
| 2537 | } |
| 2538 | #endif |
| 2539 | } |
| 2540 | |
| 2541 | { |
| 2542 | GCTraceTime(Trace, gc, phases)GCTraceTimeWrapper<LogLevel::Trace, (LogTag::_gc), (LogTag ::_phases), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag:: __NO_TAG), (LogTag::__NO_TAG)> tm("Deferred Updates", &_gc_timer); |
| 2543 | // Update the deferred objects, if any. In principle, any compaction |
| 2544 | // manager can be used. However, since the current thread is VM thread, we |
| 2545 | // use the rightful one to keep the verification logic happy. |
| 2546 | ParCompactionManager* cm = ParCompactionManager::get_vmthread_cm(); |
| 2547 | for (unsigned int id = old_space_id; id < last_space_id; ++id) { |
| 2548 | update_deferred_objects(cm, SpaceId(id)); |
| 2549 | } |
| 2550 | } |
| 2551 | |
| 2552 | DEBUG_ONLY(write_block_fill_histogram())write_block_fill_histogram(); |
| 2553 | } |
| 2554 | |
| 2555 | #ifdef ASSERT1 |
| 2556 | void PSParallelCompact::verify_complete(SpaceId space_id) { |
| 2557 | // All Regions between space bottom() to new_top() should be marked as filled |
| 2558 | // and all Regions between new_top() and top() should be available (i.e., |
| 2559 | // should have been emptied). |
| 2560 | ParallelCompactData& sd = summary_data(); |
| 2561 | SpaceInfo si = _space_info[space_id]; |
| 2562 | HeapWord* new_top_addr = sd.region_align_up(si.new_top()); |
| 2563 | HeapWord* old_top_addr = sd.region_align_up(si.space()->top()); |
| 2564 | const size_t beg_region = sd.addr_to_region_idx(si.space()->bottom()); |
| 2565 | const size_t new_top_region = sd.addr_to_region_idx(new_top_addr); |
| 2566 | const size_t old_top_region = sd.addr_to_region_idx(old_top_addr); |
| 2567 | |
| 2568 | bool issued_a_warning = false; |
| 2569 | |
| 2570 | size_t cur_region; |
| 2571 | for (cur_region = beg_region; cur_region < new_top_region; ++cur_region) { |
| 2572 | const RegionData* const c = sd.region(cur_region); |
| 2573 | if (!c->completed()) { |
| 2574 | log_warning(gc)(!(LogImpl<(LogTag::_gc), (LogTag::__NO_TAG), (LogTag::__NO_TAG ), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG) >::is_level(LogLevel::Warning))) ? (void)0 : LogImpl<(LogTag ::_gc), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG ), (LogTag::__NO_TAG), (LogTag::__NO_TAG)>::write<LogLevel ::Warning>("region " SIZE_FORMAT"%" "l" "u" " not filled: destination_count=%u", |
| 2575 | cur_region, c->destination_count()); |
| 2576 | issued_a_warning = true; |
| 2577 | } |
| 2578 | } |
| 2579 | |
| 2580 | for (cur_region = new_top_region; cur_region < old_top_region; ++cur_region) { |
| 2581 | const RegionData* const c = sd.region(cur_region); |
| 2582 | if (!c->available()) { |
| 2583 | log_warning(gc)(!(LogImpl<(LogTag::_gc), (LogTag::__NO_TAG), (LogTag::__NO_TAG ), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG) >::is_level(LogLevel::Warning))) ? (void)0 : LogImpl<(LogTag ::_gc), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG ), (LogTag::__NO_TAG), (LogTag::__NO_TAG)>::write<LogLevel ::Warning>("region " SIZE_FORMAT"%" "l" "u" " not empty: destination_count=%u", |
| 2584 | cur_region, c->destination_count()); |
| 2585 | issued_a_warning = true; |
| 2586 | } |
| 2587 | } |
| 2588 | |
| 2589 | if (issued_a_warning) { |
| 2590 | print_region_ranges(); |
| 2591 | } |
| 2592 | } |
| 2593 | #endif // #ifdef ASSERT |
| 2594 | |
| 2595 | inline void UpdateOnlyClosure::do_addr(HeapWord* addr) { |
| 2596 | _start_array->allocate_block(addr); |
| 2597 | compaction_manager()->update_contents(cast_to_oop(addr)); |
| 2598 | } |
| 2599 | |
| 2600 | // Update interior oops in the ranges of regions [beg_region, end_region). |
| 2601 | void |
| 2602 | PSParallelCompact::update_and_deadwood_in_dense_prefix(ParCompactionManager* cm, |
| 2603 | SpaceId space_id, |
| 2604 | size_t beg_region, |
| 2605 | size_t end_region) { |
| 2606 | ParallelCompactData& sd = summary_data(); |
| 2607 | ParMarkBitMap* const mbm = mark_bitmap(); |
| 2608 | |
| 2609 | HeapWord* beg_addr = sd.region_to_addr(beg_region); |
| 2610 | HeapWord* const end_addr = sd.region_to_addr(end_region); |
| 2611 | assert(beg_region <= end_region, "bad region range")do { if (!(beg_region <= end_region)) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 2611, "assert(" "beg_region <= end_region" ") failed", "bad region range" ); ::breakpoint(); } } while (0); |
| 2612 | assert(end_addr <= dense_prefix(space_id), "not in the dense prefix")do { if (!(end_addr <= dense_prefix(space_id))) { (*g_assert_poison ) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 2612, "assert(" "end_addr <= dense_prefix(space_id)" ") failed" , "not in the dense prefix"); ::breakpoint(); } } while (0); |
| 2613 | |
| 2614 | #ifdef ASSERT1 |
| 2615 | // Claim the regions to avoid triggering an assert when they are marked as |
| 2616 | // filled. |
| 2617 | for (size_t claim_region = beg_region; claim_region < end_region; ++claim_region) { |
| 2618 | assert(sd.region(claim_region)->claim_unsafe(), "claim() failed")do { if (!(sd.region(claim_region)->claim_unsafe())) { (*g_assert_poison ) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 2618, "assert(" "sd.region(claim_region)->claim_unsafe()" ") failed", "claim() failed"); ::breakpoint(); } } while (0); |
| 2619 | } |
| 2620 | #endif // #ifdef ASSERT |
| 2621 | |
| 2622 | if (beg_addr != space(space_id)->bottom()) { |
| 2623 | // Find the first live object or block of dead space that *starts* in this |
| 2624 | // range of regions. If a partial object crosses onto the region, skip it; |
| 2625 | // it will be marked for 'deferred update' when the object head is |
| 2626 | // processed. If dead space crosses onto the region, it is also skipped; it |
| 2627 | // will be filled when the prior region is processed. If neither of those |
| 2628 | // apply, the first word in the region is the start of a live object or dead |
| 2629 | // space. |
| 2630 | assert(beg_addr > space(space_id)->bottom(), "sanity")do { if (!(beg_addr > space(space_id)->bottom())) { (*g_assert_poison ) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 2630, "assert(" "beg_addr > space(space_id)->bottom()" ") failed", "sanity"); ::breakpoint(); } } while (0); |
| 2631 | const RegionData* const cp = sd.region(beg_region); |
| 2632 | if (cp->partial_obj_size() != 0) { |
| 2633 | beg_addr = sd.partial_obj_end(beg_region); |
| 2634 | } else if (dead_space_crosses_boundary(cp, mbm->addr_to_bit(beg_addr))) { |
| 2635 | beg_addr = mbm->find_obj_beg(beg_addr, end_addr); |
| 2636 | } |
| 2637 | } |
| 2638 | |
| 2639 | if (beg_addr < end_addr) { |
| 2640 | // A live object or block of dead space starts in this range of Regions. |
| 2641 | HeapWord* const dense_prefix_end = dense_prefix(space_id); |
| 2642 | |
| 2643 | // Create closures and iterate. |
| 2644 | UpdateOnlyClosure update_closure(mbm, cm, space_id); |
| 2645 | FillClosure fill_closure(cm, space_id); |
| 2646 | ParMarkBitMap::IterationStatus status; |
| 2647 | status = mbm->iterate(&update_closure, &fill_closure, beg_addr, end_addr, |
| 2648 | dense_prefix_end); |
| 2649 | if (status == ParMarkBitMap::incomplete) { |
| 2650 | update_closure.do_addr(update_closure.source()); |
| 2651 | } |
| 2652 | } |
| 2653 | |
| 2654 | // Mark the regions as filled. |
| 2655 | RegionData* const beg_cp = sd.region(beg_region); |
| 2656 | RegionData* const end_cp = sd.region(end_region); |
| 2657 | for (RegionData* cp = beg_cp; cp < end_cp; ++cp) { |
| 2658 | cp->set_completed(); |
| 2659 | } |
| 2660 | } |
| 2661 | |
| 2662 | // Return the SpaceId for the space containing addr. If addr is not in the |
| 2663 | // heap, last_space_id is returned. In debug mode it expects the address to be |
| 2664 | // in the heap and asserts such. |
| 2665 | PSParallelCompact::SpaceId PSParallelCompact::space_id(HeapWord* addr) { |
| 2666 | assert(ParallelScavengeHeap::heap()->is_in_reserved(addr), "addr not in the heap")do { if (!(ParallelScavengeHeap::heap()->is_in_reserved(addr ))) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 2666, "assert(" "ParallelScavengeHeap::heap()->is_in_reserved(addr)" ") failed", "addr not in the heap"); ::breakpoint(); } } while (0); |
| 2667 | |
| 2668 | for (unsigned int id = old_space_id; id < last_space_id; ++id) { |
| 2669 | if (_space_info[id].space()->contains(addr)) { |
| 2670 | return SpaceId(id); |
| 2671 | } |
| 2672 | } |
| 2673 | |
| 2674 | assert(false, "no space contains the addr")do { if (!(false)) { (*g_assert_poison) = 'X';; report_vm_error ("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 2674, "assert(" "false" ") failed", "no space contains the addr" ); ::breakpoint(); } } while (0); |
| 2675 | return last_space_id; |
| 2676 | } |
| 2677 | |
| 2678 | void PSParallelCompact::update_deferred_objects(ParCompactionManager* cm, |
| 2679 | SpaceId id) { |
| 2680 | assert(id < last_space_id, "bad space id")do { if (!(id < last_space_id)) { (*g_assert_poison) = 'X' ;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 2680, "assert(" "id < last_space_id" ") failed", "bad space id" ); ::breakpoint(); } } while (0); |
| 2681 | |
| 2682 | ParallelCompactData& sd = summary_data(); |
| 2683 | const SpaceInfo* const space_info = _space_info + id; |
| 2684 | ObjectStartArray* const start_array = space_info->start_array(); |
| 2685 | |
| 2686 | const MutableSpace* const space = space_info->space(); |
| 2687 | assert(space_info->dense_prefix() >= space->bottom(), "dense_prefix not set")do { if (!(space_info->dense_prefix() >= space->bottom ())) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 2687, "assert(" "space_info->dense_prefix() >= space->bottom()" ") failed", "dense_prefix not set"); ::breakpoint(); } } while (0); |
| 2688 | HeapWord* const beg_addr = space_info->dense_prefix(); |
| 2689 | HeapWord* const end_addr = sd.region_align_up(space_info->new_top()); |
| 2690 | |
| 2691 | const RegionData* const beg_region = sd.addr_to_region_ptr(beg_addr); |
| 2692 | const RegionData* const end_region = sd.addr_to_region_ptr(end_addr); |
| 2693 | const RegionData* cur_region; |
| 2694 | for (cur_region = beg_region; cur_region < end_region; ++cur_region) { |
| 2695 | HeapWord* const addr = cur_region->deferred_obj_addr(); |
| 2696 | if (addr != NULL__null) { |
| 2697 | if (start_array != NULL__null) { |
| 2698 | start_array->allocate_block(addr); |
| 2699 | } |
| 2700 | cm->update_contents(cast_to_oop(addr)); |
| 2701 | assert(oopDesc::is_oop_or_null(cast_to_oop(addr)), "Expected an oop or NULL at " PTR_FORMAT, p2i(cast_to_oop(addr)))do { if (!(oopDesc::is_oop_or_null(cast_to_oop(addr)))) { (*g_assert_poison ) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 2701, "assert(" "oopDesc::is_oop_or_null(cast_to_oop(addr))" ") failed", "Expected an oop or NULL at " "0x%016" "l" "x", p2i (cast_to_oop(addr))); ::breakpoint(); } } while (0); |
| 2702 | } |
| 2703 | } |
| 2704 | } |
| 2705 | |
| 2706 | // Skip over count live words starting from beg, and return the address of the |
| 2707 | // next live word. Unless marked, the word corresponding to beg is assumed to |
| 2708 | // be dead. Callers must either ensure beg does not correspond to the middle of |
| 2709 | // an object, or account for those live words in some other way. Callers must |
| 2710 | // also ensure that there are enough live words in the range [beg, end) to skip. |
| 2711 | HeapWord* |
| 2712 | PSParallelCompact::skip_live_words(HeapWord* beg, HeapWord* end, size_t count) |
| 2713 | { |
| 2714 | assert(count > 0, "sanity")do { if (!(count > 0)) { (*g_assert_poison) = 'X';; report_vm_error ("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 2714, "assert(" "count > 0" ") failed", "sanity"); ::breakpoint (); } } while (0); |
| 2715 | |
| 2716 | ParMarkBitMap* m = mark_bitmap(); |
| 2717 | idx_t bits_to_skip = m->words_to_bits(count); |
| 2718 | idx_t cur_beg = m->addr_to_bit(beg); |
| 2719 | const idx_t search_end = m->align_range_end(m->addr_to_bit(end)); |
| 2720 | |
| 2721 | do { |
| 2722 | cur_beg = m->find_obj_beg(cur_beg, search_end); |
| 2723 | idx_t cur_end = m->find_obj_end(cur_beg, search_end); |
| 2724 | const size_t obj_bits = cur_end - cur_beg + 1; |
| 2725 | if (obj_bits > bits_to_skip) { |
| 2726 | return m->bit_to_addr(cur_beg + bits_to_skip); |
| 2727 | } |
| 2728 | bits_to_skip -= obj_bits; |
| 2729 | cur_beg = cur_end + 1; |
| 2730 | } while (bits_to_skip > 0); |
| 2731 | |
| 2732 | // Skipping the desired number of words landed just past the end of an object. |
| 2733 | // Find the start of the next object. |
| 2734 | cur_beg = m->find_obj_beg(cur_beg, search_end); |
| 2735 | assert(cur_beg < m->addr_to_bit(end), "not enough live words to skip")do { if (!(cur_beg < m->addr_to_bit(end))) { (*g_assert_poison ) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 2735, "assert(" "cur_beg < m->addr_to_bit(end)" ") failed" , "not enough live words to skip"); ::breakpoint(); } } while (0); |
| 2736 | return m->bit_to_addr(cur_beg); |
| 2737 | } |
| 2738 | |
| 2739 | HeapWord* PSParallelCompact::first_src_addr(HeapWord* const dest_addr, |
| 2740 | SpaceId src_space_id, |
| 2741 | size_t src_region_idx) |
| 2742 | { |
| 2743 | assert(summary_data().is_region_aligned(dest_addr), "not aligned")do { if (!(summary_data().is_region_aligned(dest_addr))) { (* g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 2743, "assert(" "summary_data().is_region_aligned(dest_addr)" ") failed", "not aligned"); ::breakpoint(); } } while (0); |
| 2744 | |
| 2745 | const SplitInfo& split_info = _space_info[src_space_id].split_info(); |
| 2746 | if (split_info.dest_region_addr() == dest_addr) { |
| 2747 | // The partial object ending at the split point contains the first word to |
| 2748 | // be copied to dest_addr. |
| 2749 | return split_info.first_src_addr(); |
| 2750 | } |
| 2751 | |
| 2752 | const ParallelCompactData& sd = summary_data(); |
| 2753 | ParMarkBitMap* const bitmap = mark_bitmap(); |
| 2754 | const size_t RegionSize = ParallelCompactData::RegionSize; |
| 2755 | |
| 2756 | assert(sd.is_region_aligned(dest_addr), "not aligned")do { if (!(sd.is_region_aligned(dest_addr))) { (*g_assert_poison ) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 2756, "assert(" "sd.is_region_aligned(dest_addr)" ") failed" , "not aligned"); ::breakpoint(); } } while (0); |
| 2757 | const RegionData* const src_region_ptr = sd.region(src_region_idx); |
| 2758 | const size_t partial_obj_size = src_region_ptr->partial_obj_size(); |
| 2759 | HeapWord* const src_region_destination = src_region_ptr->destination(); |
| 2760 | |
| 2761 | assert(dest_addr >= src_region_destination, "wrong src region")do { if (!(dest_addr >= src_region_destination)) { (*g_assert_poison ) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 2761, "assert(" "dest_addr >= src_region_destination" ") failed" , "wrong src region"); ::breakpoint(); } } while (0); |
| 2762 | assert(src_region_ptr->data_size() > 0, "src region cannot be empty")do { if (!(src_region_ptr->data_size() > 0)) { (*g_assert_poison ) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 2762, "assert(" "src_region_ptr->data_size() > 0" ") failed" , "src region cannot be empty"); ::breakpoint(); } } while (0 ); |
| 2763 | |
| 2764 | HeapWord* const src_region_beg = sd.region_to_addr(src_region_idx); |
| 2765 | HeapWord* const src_region_end = src_region_beg + RegionSize; |
| 2766 | |
| 2767 | HeapWord* addr = src_region_beg; |
| 2768 | if (dest_addr == src_region_destination) { |
| 2769 | // Return the first live word in the source region. |
| 2770 | if (partial_obj_size == 0) { |
| 2771 | addr = bitmap->find_obj_beg(addr, src_region_end); |
| 2772 | assert(addr < src_region_end, "no objects start in src region")do { if (!(addr < src_region_end)) { (*g_assert_poison) = 'X' ;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 2772, "assert(" "addr < src_region_end" ") failed", "no objects start in src region" ); ::breakpoint(); } } while (0); |
| 2773 | } |
| 2774 | return addr; |
| 2775 | } |
| 2776 | |
| 2777 | // Must skip some live data. |
| 2778 | size_t words_to_skip = dest_addr - src_region_destination; |
| 2779 | assert(src_region_ptr->data_size() > words_to_skip, "wrong src region")do { if (!(src_region_ptr->data_size() > words_to_skip) ) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 2779, "assert(" "src_region_ptr->data_size() > words_to_skip" ") failed", "wrong src region"); ::breakpoint(); } } while ( 0); |
| 2780 | |
| 2781 | if (partial_obj_size >= words_to_skip) { |
| 2782 | // All the live words to skip are part of the partial object. |
| 2783 | addr += words_to_skip; |
| 2784 | if (partial_obj_size == words_to_skip) { |
| 2785 | // Find the first live word past the partial object. |
| 2786 | addr = bitmap->find_obj_beg(addr, src_region_end); |
| 2787 | assert(addr < src_region_end, "wrong src region")do { if (!(addr < src_region_end)) { (*g_assert_poison) = 'X' ;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 2787, "assert(" "addr < src_region_end" ") failed", "wrong src region" ); ::breakpoint(); } } while (0); |
| 2788 | } |
| 2789 | return addr; |
| 2790 | } |
| 2791 | |
| 2792 | // Skip over the partial object (if any). |
| 2793 | if (partial_obj_size != 0) { |
| 2794 | words_to_skip -= partial_obj_size; |
| 2795 | addr += partial_obj_size; |
| 2796 | } |
| 2797 | |
| 2798 | // Skip over live words due to objects that start in the region. |
| 2799 | addr = skip_live_words(addr, src_region_end, words_to_skip); |
| 2800 | assert(addr < src_region_end, "wrong src region")do { if (!(addr < src_region_end)) { (*g_assert_poison) = 'X' ;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 2800, "assert(" "addr < src_region_end" ") failed", "wrong src region" ); ::breakpoint(); } } while (0); |
| 2801 | return addr; |
| 2802 | } |
| 2803 | |
| 2804 | void PSParallelCompact::decrement_destination_counts(ParCompactionManager* cm, |
| 2805 | SpaceId src_space_id, |
| 2806 | size_t beg_region, |
| 2807 | HeapWord* end_addr) |
| 2808 | { |
| 2809 | ParallelCompactData& sd = summary_data(); |
| 2810 | |
| 2811 | #ifdef ASSERT1 |
| 2812 | MutableSpace* const src_space = _space_info[src_space_id].space(); |
| 2813 | HeapWord* const beg_addr = sd.region_to_addr(beg_region); |
| 2814 | assert(src_space->contains(beg_addr) || beg_addr == src_space->end(),do { if (!(src_space->contains(beg_addr) || beg_addr == src_space ->end())) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 2815, "assert(" "src_space->contains(beg_addr) || beg_addr == src_space->end()" ") failed", "src_space_id does not match beg_addr"); ::breakpoint (); } } while (0) |
| 2815 | "src_space_id does not match beg_addr")do { if (!(src_space->contains(beg_addr) || beg_addr == src_space ->end())) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 2815, "assert(" "src_space->contains(beg_addr) || beg_addr == src_space->end()" ") failed", "src_space_id does not match beg_addr"); ::breakpoint (); } } while (0); |
| 2816 | assert(src_space->contains(end_addr) || end_addr == src_space->end(),do { if (!(src_space->contains(end_addr) || end_addr == src_space ->end())) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 2817, "assert(" "src_space->contains(end_addr) || end_addr == src_space->end()" ") failed", "src_space_id does not match end_addr"); ::breakpoint (); } } while (0) |
| 2817 | "src_space_id does not match end_addr")do { if (!(src_space->contains(end_addr) || end_addr == src_space ->end())) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 2817, "assert(" "src_space->contains(end_addr) || end_addr == src_space->end()" ") failed", "src_space_id does not match end_addr"); ::breakpoint (); } } while (0); |
| 2818 | #endif // #ifdef ASSERT |
| 2819 | |
| 2820 | RegionData* const beg = sd.region(beg_region); |
| 2821 | RegionData* const end = sd.addr_to_region_ptr(sd.region_align_up(end_addr)); |
| 2822 | |
| 2823 | // Regions up to new_top() are enqueued if they become available. |
| 2824 | HeapWord* const new_top = _space_info[src_space_id].new_top(); |
| 2825 | RegionData* const enqueue_end = |
| 2826 | sd.addr_to_region_ptr(sd.region_align_up(new_top)); |
| 2827 | |
| 2828 | for (RegionData* cur = beg; cur < end; ++cur) { |
| 2829 | assert(cur->data_size() > 0, "region must have live data")do { if (!(cur->data_size() > 0)) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 2829, "assert(" "cur->data_size() > 0" ") failed", "region must have live data" ); ::breakpoint(); } } while (0); |
| 2830 | cur->decrement_destination_count(); |
| 2831 | if (cur < enqueue_end && cur->available() && cur->claim()) { |
| 2832 | if (cur->mark_normal()) { |
| 2833 | cm->push_region(sd.region(cur)); |
| 2834 | } else if (cur->mark_copied()) { |
| 2835 | // Try to copy the content of the shadow region back to its corresponding |
| 2836 | // heap region if the shadow region is filled. Otherwise, the GC thread |
| 2837 | // fills the shadow region will copy the data back (see |
| 2838 | // MoveAndUpdateShadowClosure::complete_region). |
| 2839 | copy_back(sd.region_to_addr(cur->shadow_region()), sd.region_to_addr(cur)); |
| 2840 | ParCompactionManager::push_shadow_region_mt_safe(cur->shadow_region()); |
| 2841 | cur->set_completed(); |
| 2842 | } |
| 2843 | } |
| 2844 | } |
| 2845 | } |
| 2846 | |
| 2847 | size_t PSParallelCompact::next_src_region(MoveAndUpdateClosure& closure, |
| 2848 | SpaceId& src_space_id, |
| 2849 | HeapWord*& src_space_top, |
| 2850 | HeapWord* end_addr) |
| 2851 | { |
| 2852 | typedef ParallelCompactData::RegionData RegionData; |
| 2853 | |
| 2854 | ParallelCompactData& sd = PSParallelCompact::summary_data(); |
| 2855 | const size_t region_size = ParallelCompactData::RegionSize; |
| 2856 | |
| 2857 | size_t src_region_idx = 0; |
| 2858 | |
| 2859 | // Skip empty regions (if any) up to the top of the space. |
| 2860 | HeapWord* const src_aligned_up = sd.region_align_up(end_addr); |
| 2861 | RegionData* src_region_ptr = sd.addr_to_region_ptr(src_aligned_up); |
| 2862 | HeapWord* const top_aligned_up = sd.region_align_up(src_space_top); |
| 2863 | const RegionData* const top_region_ptr = |
| 2864 | sd.addr_to_region_ptr(top_aligned_up); |
| 2865 | while (src_region_ptr < top_region_ptr && src_region_ptr->data_size() == 0) { |
| 2866 | ++src_region_ptr; |
| 2867 | } |
| 2868 | |
| 2869 | if (src_region_ptr < top_region_ptr) { |
| 2870 | // The next source region is in the current space. Update src_region_idx |
| 2871 | // and the source address to match src_region_ptr. |
| 2872 | src_region_idx = sd.region(src_region_ptr); |
| 2873 | HeapWord* const src_region_addr = sd.region_to_addr(src_region_idx); |
| 2874 | if (src_region_addr > closure.source()) { |
| 2875 | closure.set_source(src_region_addr); |
| 2876 | } |
| 2877 | return src_region_idx; |
| 2878 | } |
| 2879 | |
| 2880 | // Switch to a new source space and find the first non-empty region. |
| 2881 | unsigned int space_id = src_space_id + 1; |
| 2882 | assert(space_id < last_space_id, "not enough spaces")do { if (!(space_id < last_space_id)) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 2882, "assert(" "space_id < last_space_id" ") failed", "not enough spaces" ); ::breakpoint(); } } while (0); |
| 2883 | |
| 2884 | HeapWord* const destination = closure.destination(); |
| 2885 | |
| 2886 | do { |
| 2887 | MutableSpace* space = _space_info[space_id].space(); |
| 2888 | HeapWord* const bottom = space->bottom(); |
| 2889 | const RegionData* const bottom_cp = sd.addr_to_region_ptr(bottom); |
| 2890 | |
| 2891 | // Iterate over the spaces that do not compact into themselves. |
| 2892 | if (bottom_cp->destination() != bottom) { |
| 2893 | HeapWord* const top_aligned_up = sd.region_align_up(space->top()); |
| 2894 | const RegionData* const top_cp = sd.addr_to_region_ptr(top_aligned_up); |
| 2895 | |
| 2896 | for (const RegionData* src_cp = bottom_cp; src_cp < top_cp; ++src_cp) { |
| 2897 | if (src_cp->live_obj_size() > 0) { |
| 2898 | // Found it. |
| 2899 | assert(src_cp->destination() == destination,do { if (!(src_cp->destination() == destination)) { (*g_assert_poison ) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 2900, "assert(" "src_cp->destination() == destination" ") failed" , "first live obj in the space must match the destination"); :: breakpoint(); } } while (0) |
| 2900 | "first live obj in the space must match the destination")do { if (!(src_cp->destination() == destination)) { (*g_assert_poison ) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 2900, "assert(" "src_cp->destination() == destination" ") failed" , "first live obj in the space must match the destination"); :: breakpoint(); } } while (0); |
| 2901 | assert(src_cp->partial_obj_size() == 0,do { if (!(src_cp->partial_obj_size() == 0)) { (*g_assert_poison ) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 2902, "assert(" "src_cp->partial_obj_size() == 0" ") failed" , "a space cannot begin with a partial obj"); ::breakpoint(); } } while (0) |
| 2902 | "a space cannot begin with a partial obj")do { if (!(src_cp->partial_obj_size() == 0)) { (*g_assert_poison ) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 2902, "assert(" "src_cp->partial_obj_size() == 0" ") failed" , "a space cannot begin with a partial obj"); ::breakpoint(); } } while (0); |
| 2903 | |
| 2904 | src_space_id = SpaceId(space_id); |
| 2905 | src_space_top = space->top(); |
| 2906 | const size_t src_region_idx = sd.region(src_cp); |
| 2907 | closure.set_source(sd.region_to_addr(src_region_idx)); |
| 2908 | return src_region_idx; |
| 2909 | } else { |
| 2910 | assert(src_cp->data_size() == 0, "sanity")do { if (!(src_cp->data_size() == 0)) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 2910, "assert(" "src_cp->data_size() == 0" ") failed", "sanity" ); ::breakpoint(); } } while (0); |
| 2911 | } |
| 2912 | } |
| 2913 | } |
| 2914 | } while (++space_id < last_space_id); |
| 2915 | |
| 2916 | assert(false, "no source region was found")do { if (!(false)) { (*g_assert_poison) = 'X';; report_vm_error ("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 2916, "assert(" "false" ") failed", "no source region was found" ); ::breakpoint(); } } while (0); |
| 2917 | return 0; |
| 2918 | } |
| 2919 | |
| 2920 | void PSParallelCompact::fill_region(ParCompactionManager* cm, MoveAndUpdateClosure& closure, size_t region_idx) |
| 2921 | { |
| 2922 | typedef ParMarkBitMap::IterationStatus IterationStatus; |
| 2923 | ParMarkBitMap* const bitmap = mark_bitmap(); |
| 2924 | ParallelCompactData& sd = summary_data(); |
| 2925 | RegionData* const region_ptr = sd.region(region_idx); |
| 2926 | |
| 2927 | // Get the source region and related info. |
| 2928 | size_t src_region_idx = region_ptr->source_region(); |
| 2929 | SpaceId src_space_id = space_id(sd.region_to_addr(src_region_idx)); |
| 2930 | HeapWord* src_space_top = _space_info[src_space_id].space()->top(); |
| 2931 | HeapWord* dest_addr = sd.region_to_addr(region_idx); |
| 2932 | |
| 2933 | closure.set_source(first_src_addr(dest_addr, src_space_id, src_region_idx)); |
| 2934 | |
| 2935 | // Adjust src_region_idx to prepare for decrementing destination counts (the |
| 2936 | // destination count is not decremented when a region is copied to itself). |
| 2937 | if (src_region_idx == region_idx) { |
| 2938 | src_region_idx += 1; |
| 2939 | } |
| 2940 | |
| 2941 | if (bitmap->is_unmarked(closure.source())) { |
| 2942 | // The first source word is in the middle of an object; copy the remainder |
| 2943 | // of the object or as much as will fit. The fact that pointer updates were |
| 2944 | // deferred will be noted when the object header is processed. |
| 2945 | HeapWord* const old_src_addr = closure.source(); |
| 2946 | closure.copy_partial_obj(); |
| 2947 | if (closure.is_full()) { |
| 2948 | decrement_destination_counts(cm, src_space_id, src_region_idx, |
| 2949 | closure.source()); |
| 2950 | region_ptr->set_deferred_obj_addr(NULL__null); |
| 2951 | closure.complete_region(cm, dest_addr, region_ptr); |
| 2952 | return; |
| 2953 | } |
| 2954 | |
| 2955 | HeapWord* const end_addr = sd.region_align_down(closure.source()); |
| 2956 | if (sd.region_align_down(old_src_addr) != end_addr) { |
| 2957 | // The partial object was copied from more than one source region. |
| 2958 | decrement_destination_counts(cm, src_space_id, src_region_idx, end_addr); |
| 2959 | |
| 2960 | // Move to the next source region, possibly switching spaces as well. All |
| 2961 | // args except end_addr may be modified. |
| 2962 | src_region_idx = next_src_region(closure, src_space_id, src_space_top, |
| 2963 | end_addr); |
| 2964 | } |
| 2965 | } |
| 2966 | |
| 2967 | do { |
| 2968 | HeapWord* const cur_addr = closure.source(); |
| 2969 | HeapWord* const end_addr = MIN2(sd.region_align_up(cur_addr + 1), |
| 2970 | src_space_top); |
| 2971 | IterationStatus status = bitmap->iterate(&closure, cur_addr, end_addr); |
| 2972 | |
| 2973 | if (status == ParMarkBitMap::incomplete) { |
| 2974 | // The last obj that starts in the source region does not end in the |
| 2975 | // region. |
| 2976 | assert(closure.source() < end_addr, "sanity")do { if (!(closure.source() < end_addr)) { (*g_assert_poison ) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 2976, "assert(" "closure.source() < end_addr" ") failed" , "sanity"); ::breakpoint(); } } while (0); |
| 2977 | HeapWord* const obj_beg = closure.source(); |
| 2978 | HeapWord* const range_end = MIN2(obj_beg + closure.words_remaining(), |
| 2979 | src_space_top); |
| 2980 | HeapWord* const obj_end = bitmap->find_obj_end(obj_beg, range_end); |
| 2981 | if (obj_end < range_end) { |
| 2982 | // The end was found; the entire object will fit. |
| 2983 | status = closure.do_addr(obj_beg, bitmap->obj_size(obj_beg, obj_end)); |
| 2984 | assert(status != ParMarkBitMap::would_overflow, "sanity")do { if (!(status != ParMarkBitMap::would_overflow)) { (*g_assert_poison ) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 2984, "assert(" "status != ParMarkBitMap::would_overflow" ") failed" , "sanity"); ::breakpoint(); } } while (0); |
| 2985 | } else { |
| 2986 | // The end was not found; the object will not fit. |
| 2987 | assert(range_end < src_space_top, "obj cannot cross space boundary")do { if (!(range_end < src_space_top)) { (*g_assert_poison ) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 2987, "assert(" "range_end < src_space_top" ") failed", "obj cannot cross space boundary" ); ::breakpoint(); } } while (0); |
| 2988 | status = ParMarkBitMap::would_overflow; |
| 2989 | } |
| 2990 | } |
| 2991 | |
| 2992 | if (status == ParMarkBitMap::would_overflow) { |
| 2993 | // The last object did not fit. Note that interior oop updates were |
| 2994 | // deferred, then copy enough of the object to fill the region. |
| 2995 | region_ptr->set_deferred_obj_addr(closure.destination()); |
| 2996 | status = closure.copy_until_full(); // copies from closure.source() |
| 2997 | |
| 2998 | decrement_destination_counts(cm, src_space_id, src_region_idx, |
| 2999 | closure.source()); |
| 3000 | closure.complete_region(cm, dest_addr, region_ptr); |
| 3001 | return; |
| 3002 | } |
| 3003 | |
| 3004 | if (status == ParMarkBitMap::full) { |
| 3005 | decrement_destination_counts(cm, src_space_id, src_region_idx, |
| 3006 | closure.source()); |
| 3007 | region_ptr->set_deferred_obj_addr(NULL__null); |
| 3008 | closure.complete_region(cm, dest_addr, region_ptr); |
| 3009 | return; |
| 3010 | } |
| 3011 | |
| 3012 | decrement_destination_counts(cm, src_space_id, src_region_idx, end_addr); |
| 3013 | |
| 3014 | // Move to the next source region, possibly switching spaces as well. All |
| 3015 | // args except end_addr may be modified. |
| 3016 | src_region_idx = next_src_region(closure, src_space_id, src_space_top, |
| 3017 | end_addr); |
| 3018 | } while (true); |
| 3019 | } |
| 3020 | |
| 3021 | void PSParallelCompact::fill_and_update_region(ParCompactionManager* cm, size_t region_idx) |
| 3022 | { |
| 3023 | MoveAndUpdateClosure cl(mark_bitmap(), cm, region_idx); |
| 3024 | fill_region(cm, cl, region_idx); |
| 3025 | } |
| 3026 | |
| 3027 | void PSParallelCompact::fill_and_update_shadow_region(ParCompactionManager* cm, size_t region_idx) |
| 3028 | { |
| 3029 | // Get a shadow region first |
| 3030 | ParallelCompactData& sd = summary_data(); |
| 3031 | RegionData* const region_ptr = sd.region(region_idx); |
| 3032 | size_t shadow_region = ParCompactionManager::pop_shadow_region_mt_safe(region_ptr); |
| 3033 | // The InvalidShadow return value indicates the corresponding heap region is available, |
| 3034 | // so use MoveAndUpdateClosure to fill the normal region. Otherwise, use |
| 3035 | // MoveAndUpdateShadowClosure to fill the acquired shadow region. |
| 3036 | if (shadow_region == ParCompactionManager::InvalidShadow) { |
| 3037 | MoveAndUpdateClosure cl(mark_bitmap(), cm, region_idx); |
| 3038 | region_ptr->shadow_to_normal(); |
| 3039 | return fill_region(cm, cl, region_idx); |
| 3040 | } else { |
| 3041 | MoveAndUpdateShadowClosure cl(mark_bitmap(), cm, region_idx, shadow_region); |
| 3042 | return fill_region(cm, cl, region_idx); |
| 3043 | } |
| 3044 | } |
| 3045 | |
| 3046 | void PSParallelCompact::copy_back(HeapWord *shadow_addr, HeapWord *region_addr) |
| 3047 | { |
| 3048 | Copy::aligned_conjoint_words(shadow_addr, region_addr, _summary_data.RegionSize); |
| 3049 | } |
| 3050 | |
| 3051 | bool PSParallelCompact::steal_unavailable_region(ParCompactionManager* cm, size_t ®ion_idx) |
| 3052 | { |
| 3053 | size_t next = cm->next_shadow_region(); |
| 3054 | ParallelCompactData& sd = summary_data(); |
| 3055 | size_t old_new_top = sd.addr_to_region_idx(_space_info[old_space_id].new_top()); |
| 3056 | uint active_gc_threads = ParallelScavengeHeap::heap()->workers().active_workers(); |
| 3057 | |
| 3058 | while (next < old_new_top) { |
| 3059 | if (sd.region(next)->mark_shadow()) { |
| 3060 | region_idx = next; |
| 3061 | return true; |
| 3062 | } |
| 3063 | next = cm->move_next_shadow_region_by(active_gc_threads); |
| 3064 | } |
| 3065 | |
| 3066 | return false; |
| 3067 | } |
| 3068 | |
| 3069 | // The shadow region is an optimization to address region dependencies in full GC. The basic |
| 3070 | // idea is making more regions available by temporally storing their live objects in empty |
| 3071 | // shadow regions to resolve dependencies between them and the destination regions. Therefore, |
| 3072 | // GC threads need not wait destination regions to be available before processing sources. |
| 3073 | // |
| 3074 | // A typical workflow would be: |
| 3075 | // After draining its own stack and failing to steal from others, a GC worker would pick an |
| 3076 | // unavailable region (destination count > 0) and get a shadow region. Then the worker fills |
| 3077 | // the shadow region by copying live objects from source regions of the unavailable one. Once |
| 3078 | // the unavailable region becomes available, the data in the shadow region will be copied back. |
| 3079 | // Shadow regions are empty regions in the to-space and regions between top and end of other spaces. |
| 3080 | void PSParallelCompact::initialize_shadow_regions(uint parallel_gc_threads) |
| 3081 | { |
| 3082 | const ParallelCompactData& sd = PSParallelCompact::summary_data(); |
| 3083 | |
| 3084 | for (unsigned int id = old_space_id; id < last_space_id; ++id) { |
| 3085 | SpaceInfo* const space_info = _space_info + id; |
| 3086 | MutableSpace* const space = space_info->space(); |
| 3087 | |
| 3088 | const size_t beg_region = |
| 3089 | sd.addr_to_region_idx(sd.region_align_up(MAX2(space_info->new_top(), space->top()))); |
| 3090 | const size_t end_region = |
| 3091 | sd.addr_to_region_idx(sd.region_align_down(space->end())); |
| 3092 | |
| 3093 | for (size_t cur = beg_region; cur < end_region; ++cur) { |
| 3094 | ParCompactionManager::push_shadow_region(cur); |
| 3095 | } |
| 3096 | } |
| 3097 | |
| 3098 | size_t beg_region = sd.addr_to_region_idx(_space_info[old_space_id].dense_prefix()); |
| 3099 | for (uint i = 0; i < parallel_gc_threads; i++) { |
| 3100 | ParCompactionManager *cm = ParCompactionManager::gc_thread_compaction_manager(i); |
| 3101 | cm->set_next_shadow_region(beg_region + i); |
| 3102 | } |
| 3103 | } |
| 3104 | |
| 3105 | void PSParallelCompact::fill_blocks(size_t region_idx) |
| 3106 | { |
| 3107 | // Fill in the block table elements for the specified region. Each block |
| 3108 | // table element holds the number of live words in the region that are to the |
| 3109 | // left of the first object that starts in the block. Thus only blocks in |
| 3110 | // which an object starts need to be filled. |
| 3111 | // |
| 3112 | // The algorithm scans the section of the bitmap that corresponds to the |
| 3113 | // region, keeping a running total of the live words. When an object start is |
| 3114 | // found, if it's the first to start in the block that contains it, the |
| 3115 | // current total is written to the block table element. |
| 3116 | const size_t Log2BlockSize = ParallelCompactData::Log2BlockSize; |
| 3117 | const size_t Log2RegionSize = ParallelCompactData::Log2RegionSize; |
| 3118 | const size_t RegionSize = ParallelCompactData::RegionSize; |
| 3119 | |
| 3120 | ParallelCompactData& sd = summary_data(); |
| 3121 | const size_t partial_obj_size = sd.region(region_idx)->partial_obj_size(); |
| 3122 | if (partial_obj_size >= RegionSize) { |
| 3123 | return; // No objects start in this region. |
| 3124 | } |
| 3125 | |
| 3126 | // Ensure the first loop iteration decides that the block has changed. |
| 3127 | size_t cur_block = sd.block_count(); |
| 3128 | |
| 3129 | const ParMarkBitMap* const bitmap = mark_bitmap(); |
| 3130 | |
| 3131 | const size_t Log2BitsPerBlock = Log2BlockSize - LogMinObjAlignment; |
| 3132 | assert((size_t)1 << Log2BitsPerBlock ==do { if (!((size_t)1 << Log2BitsPerBlock == bitmap-> words_to_bits(ParallelCompactData::BlockSize))) { (*g_assert_poison ) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 3133, "assert(" "(size_t)1 << Log2BitsPerBlock == bitmap->words_to_bits(ParallelCompactData::BlockSize)" ") failed", "sanity"); ::breakpoint(); } } while (0) |
| 3133 | bitmap->words_to_bits(ParallelCompactData::BlockSize), "sanity")do { if (!((size_t)1 << Log2BitsPerBlock == bitmap-> words_to_bits(ParallelCompactData::BlockSize))) { (*g_assert_poison ) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 3133, "assert(" "(size_t)1 << Log2BitsPerBlock == bitmap->words_to_bits(ParallelCompactData::BlockSize)" ") failed", "sanity"); ::breakpoint(); } } while (0); |
| 3134 | |
| 3135 | size_t beg_bit = bitmap->words_to_bits(region_idx << Log2RegionSize); |
| 3136 | const size_t range_end = beg_bit + bitmap->words_to_bits(RegionSize); |
| 3137 | size_t live_bits = bitmap->words_to_bits(partial_obj_size); |
| 3138 | beg_bit = bitmap->find_obj_beg(beg_bit + live_bits, range_end); |
| 3139 | while (beg_bit < range_end) { |
| 3140 | const size_t new_block = beg_bit >> Log2BitsPerBlock; |
| 3141 | if (new_block != cur_block) { |
| 3142 | cur_block = new_block; |
| 3143 | sd.block(cur_block)->set_offset(bitmap->bits_to_words(live_bits)); |
| 3144 | } |
| 3145 | |
| 3146 | const size_t end_bit = bitmap->find_obj_end(beg_bit, range_end); |
| 3147 | if (end_bit < range_end - 1) { |
| 3148 | live_bits += end_bit - beg_bit + 1; |
| 3149 | beg_bit = bitmap->find_obj_beg(end_bit + 1, range_end); |
| 3150 | } else { |
| 3151 | return; |
| 3152 | } |
| 3153 | } |
| 3154 | } |
| 3155 | |
| 3156 | ParMarkBitMap::IterationStatus MoveAndUpdateClosure::copy_until_full() |
| 3157 | { |
| 3158 | if (source() != copy_destination()) { |
| 3159 | DEBUG_ONLY(PSParallelCompact::check_new_location(source(), destination());)PSParallelCompact::check_new_location(source(), destination() ); |
| 3160 | Copy::aligned_conjoint_words(source(), copy_destination(), words_remaining()); |
| 3161 | } |
| 3162 | update_state(words_remaining()); |
| 3163 | assert(is_full(), "sanity")do { if (!(is_full())) { (*g_assert_poison) = 'X';; report_vm_error ("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 3163, "assert(" "is_full()" ") failed", "sanity"); ::breakpoint (); } } while (0); |
| 3164 | return ParMarkBitMap::full; |
| 3165 | } |
| 3166 | |
| 3167 | void MoveAndUpdateClosure::copy_partial_obj() |
| 3168 | { |
| 3169 | size_t words = words_remaining(); |
| 3170 | |
| 3171 | HeapWord* const range_end = MIN2(source() + words, bitmap()->region_end()); |
| 3172 | HeapWord* const end_addr = bitmap()->find_obj_end(source(), range_end); |
| 3173 | if (end_addr < range_end) { |
| 3174 | words = bitmap()->obj_size(source(), end_addr); |
| 3175 | } |
| 3176 | |
| 3177 | // This test is necessary; if omitted, the pointer updates to a partial object |
| 3178 | // that crosses the dense prefix boundary could be overwritten. |
| 3179 | if (source() != copy_destination()) { |
| 3180 | DEBUG_ONLY(PSParallelCompact::check_new_location(source(), destination());)PSParallelCompact::check_new_location(source(), destination() ); |
| 3181 | Copy::aligned_conjoint_words(source(), copy_destination(), words); |
| 3182 | } |
| 3183 | update_state(words); |
| 3184 | } |
| 3185 | |
| 3186 | void MoveAndUpdateClosure::complete_region(ParCompactionManager *cm, HeapWord *dest_addr, |
| 3187 | PSParallelCompact::RegionData *region_ptr) { |
| 3188 | assert(region_ptr->shadow_state() == ParallelCompactData::RegionData::NormalRegion, "Region should be finished")do { if (!(region_ptr->shadow_state() == ParallelCompactData ::RegionData::NormalRegion)) { (*g_assert_poison) = 'X';; report_vm_error ("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 3188, "assert(" "region_ptr->shadow_state() == ParallelCompactData::RegionData::NormalRegion" ") failed", "Region should be finished"); ::breakpoint(); } } while (0); |
| 3189 | region_ptr->set_completed(); |
| 3190 | } |
| 3191 | |
| 3192 | ParMarkBitMapClosure::IterationStatus |
| 3193 | MoveAndUpdateClosure::do_addr(HeapWord* addr, size_t words) { |
| 3194 | assert(destination() != NULL, "sanity")do { if (!(destination() != __null)) { (*g_assert_poison) = 'X' ;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 3194, "assert(" "destination() != __null" ") failed", "sanity" ); ::breakpoint(); } } while (0); |
| 3195 | assert(bitmap()->obj_size(addr) == words, "bad size")do { if (!(bitmap()->obj_size(addr) == words)) { (*g_assert_poison ) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 3195, "assert(" "bitmap()->obj_size(addr) == words" ") failed" , "bad size"); ::breakpoint(); } } while (0); |
| 3196 | |
| 3197 | _source = addr; |
| 3198 | assert(PSParallelCompact::summary_data().calc_new_pointer(source(), compaction_manager()) ==do { if (!(PSParallelCompact::summary_data().calc_new_pointer (source(), compaction_manager()) == destination())) { (*g_assert_poison ) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 3199, "assert(" "PSParallelCompact::summary_data().calc_new_pointer(source(), compaction_manager()) == destination()" ") failed", "wrong destination"); ::breakpoint(); } } while ( 0) |
| 3199 | destination(), "wrong destination")do { if (!(PSParallelCompact::summary_data().calc_new_pointer (source(), compaction_manager()) == destination())) { (*g_assert_poison ) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 3199, "assert(" "PSParallelCompact::summary_data().calc_new_pointer(source(), compaction_manager()) == destination()" ") failed", "wrong destination"); ::breakpoint(); } } while ( 0); |
| 3200 | |
| 3201 | if (words > words_remaining()) { |
| 3202 | return ParMarkBitMap::would_overflow; |
| 3203 | } |
| 3204 | |
| 3205 | // The start_array must be updated even if the object is not moving. |
| 3206 | if (_start_array != NULL__null) { |
| 3207 | _start_array->allocate_block(destination()); |
| 3208 | } |
| 3209 | |
| 3210 | if (copy_destination() != source()) { |
| 3211 | DEBUG_ONLY(PSParallelCompact::check_new_location(source(), destination());)PSParallelCompact::check_new_location(source(), destination() ); |
| 3212 | Copy::aligned_conjoint_words(source(), copy_destination(), words); |
| 3213 | } |
| 3214 | |
| 3215 | oop moved_oop = cast_to_oop(copy_destination()); |
| 3216 | compaction_manager()->update_contents(moved_oop); |
| 3217 | assert(oopDesc::is_oop_or_null(moved_oop), "Expected an oop or NULL at " PTR_FORMAT, p2i(moved_oop))do { if (!(oopDesc::is_oop_or_null(moved_oop))) { (*g_assert_poison ) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 3217, "assert(" "oopDesc::is_oop_or_null(moved_oop)" ") failed" , "Expected an oop or NULL at " "0x%016" "l" "x", p2i(moved_oop )); ::breakpoint(); } } while (0); |
| 3218 | |
| 3219 | update_state(words); |
| 3220 | assert(copy_destination() == cast_from_oop<HeapWord*>(moved_oop) + moved_oop->size(), "sanity")do { if (!(copy_destination() == cast_from_oop<HeapWord*> (moved_oop) + moved_oop->size())) { (*g_assert_poison) = 'X' ;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 3220, "assert(" "copy_destination() == cast_from_oop<HeapWord*>(moved_oop) + moved_oop->size()" ") failed", "sanity"); ::breakpoint(); } } while (0); |
| 3221 | return is_full() ? ParMarkBitMap::full : ParMarkBitMap::incomplete; |
| 3222 | } |
| 3223 | |
| 3224 | void MoveAndUpdateShadowClosure::complete_region(ParCompactionManager *cm, HeapWord *dest_addr, |
| 3225 | PSParallelCompact::RegionData *region_ptr) { |
| 3226 | assert(region_ptr->shadow_state() == ParallelCompactData::RegionData::ShadowRegion, "Region should be shadow")do { if (!(region_ptr->shadow_state() == ParallelCompactData ::RegionData::ShadowRegion)) { (*g_assert_poison) = 'X';; report_vm_error ("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 3226, "assert(" "region_ptr->shadow_state() == ParallelCompactData::RegionData::ShadowRegion" ") failed", "Region should be shadow"); ::breakpoint(); } } while (0); |
| 3227 | // Record the shadow region index |
| 3228 | region_ptr->set_shadow_region(_shadow); |
| 3229 | // Mark the shadow region as filled to indicate the data is ready to be |
| 3230 | // copied back |
| 3231 | region_ptr->mark_filled(); |
| 3232 | // Try to copy the content of the shadow region back to its corresponding |
| 3233 | // heap region if available; the GC thread that decreases the destination |
| 3234 | // count to zero will do the copying otherwise (see |
| 3235 | // PSParallelCompact::decrement_destination_counts). |
| 3236 | if (((region_ptr->available() && region_ptr->claim()) || region_ptr->claimed()) && region_ptr->mark_copied()) { |
| 3237 | region_ptr->set_completed(); |
| 3238 | PSParallelCompact::copy_back(PSParallelCompact::summary_data().region_to_addr(_shadow), dest_addr); |
| 3239 | ParCompactionManager::push_shadow_region_mt_safe(_shadow); |
| 3240 | } |
| 3241 | } |
| 3242 | |
| 3243 | UpdateOnlyClosure::UpdateOnlyClosure(ParMarkBitMap* mbm, |
| 3244 | ParCompactionManager* cm, |
| 3245 | PSParallelCompact::SpaceId space_id) : |
| 3246 | ParMarkBitMapClosure(mbm, cm), |
| 3247 | _space_id(space_id), |
| 3248 | _start_array(PSParallelCompact::start_array(space_id)) |
| 3249 | { |
| 3250 | } |
| 3251 | |
| 3252 | // Updates the references in the object to their new values. |
| 3253 | ParMarkBitMapClosure::IterationStatus |
| 3254 | UpdateOnlyClosure::do_addr(HeapWord* addr, size_t words) { |
| 3255 | do_addr(addr); |
| 3256 | return ParMarkBitMap::incomplete; |
| 3257 | } |
| 3258 | |
| 3259 | FillClosure::FillClosure(ParCompactionManager* cm, PSParallelCompact::SpaceId space_id) : |
| 3260 | ParMarkBitMapClosure(PSParallelCompact::mark_bitmap(), cm), |
| 3261 | _start_array(PSParallelCompact::start_array(space_id)) |
| 3262 | { |
| 3263 | assert(space_id == PSParallelCompact::old_space_id,do { if (!(space_id == PSParallelCompact::old_space_id)) { (* g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 3264, "assert(" "space_id == PSParallelCompact::old_space_id" ") failed", "cannot use FillClosure in the young gen"); ::breakpoint (); } } while (0) |
| 3264 | "cannot use FillClosure in the young gen")do { if (!(space_id == PSParallelCompact::old_space_id)) { (* g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/gc/parallel/psParallelCompact.cpp" , 3264, "assert(" "space_id == PSParallelCompact::old_space_id" ") failed", "cannot use FillClosure in the young gen"); ::breakpoint (); } } while (0); |
| 3265 | } |
| 3266 | |
| 3267 | ParMarkBitMapClosure::IterationStatus |
| 3268 | FillClosure::do_addr(HeapWord* addr, size_t size) { |
| 3269 | CollectedHeap::fill_with_objects(addr, size); |
| 3270 | HeapWord* const end = addr + size; |
| 3271 | do { |
| 3272 | _start_array->allocate_block(addr); |
| 3273 | addr += cast_to_oop(addr)->size(); |
| 3274 | } while (addr < end); |
| 3275 | return ParMarkBitMap::incomplete; |
| 3276 | } |