truffle: src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp annotate

annotate src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp @ 3979:4dfb2df418f2

6484982: G1: process references during evacuation pauses Summary: G1 now uses two reference processors - one is used by concurrent marking and the other is used by STW GCs (both full and incremental evacuation pauses). In an evacuation pause, the reference processor is embedded into the closures used to scan objects. Doing so causes causes reference objects to be 'discovered' by the reference processor. At the end of the evacuation pause, these discovered reference objects are processed - preserving (and copying) referent objects (and their reachable graphs) as appropriate. Reviewed-by: ysr, jwilhelm, brutisso, stefank, tonyp

author	johnc
date	Thu, 22 Sep 2011 10:57:37 -0700
parents	c2bf0120ee5d
children	bca17e38de00

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
2369 92da084fefc9 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads ysr parents: 2177 diff changeset	2 * Copyright (c) 2005, 2011, Oracle and/or its affiliates. All rights reserved.
0 a61af66fc99e Initial load duke parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load duke parents: diff changeset	4 *
a61af66fc99e Initial load duke parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load duke parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load duke parents: diff changeset	7 * published by the Free Software Foundation.
a61af66fc99e Initial load duke parents: diff changeset	8 *
a61af66fc99e Initial load duke parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load duke parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load duke parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load duke parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load duke parents: diff changeset	13 * accompanied this code).
a61af66fc99e Initial load duke parents: diff changeset	14 *
a61af66fc99e Initial load duke parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load duke parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load duke parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load duke parents: diff changeset	18 *
1552 c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1489 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1489 diff changeset	20 * or visit www.oracle.com if you need additional information or have any
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1489 diff changeset	21 * questions.
0 a61af66fc99e Initial load duke parents: diff changeset	22 *
a61af66fc99e Initial load duke parents: diff changeset	23 */
a61af66fc99e Initial load duke parents: diff changeset	24
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	25 #include "precompiled.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	26 #include "classfile/symbolTable.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	27 #include "classfile/systemDictionary.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	28 #include "code/codeCache.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	29 #include "gc_implementation/parallelScavenge/gcTaskManager.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	30 #include "gc_implementation/parallelScavenge/generationSizer.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	31 #include "gc_implementation/parallelScavenge/parallelScavengeHeap.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	32 #include "gc_implementation/parallelScavenge/pcTasks.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	33 #include "gc_implementation/parallelScavenge/psAdaptiveSizePolicy.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	34 #include "gc_implementation/parallelScavenge/psCompactionManager.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	35 #include "gc_implementation/parallelScavenge/psMarkSweep.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	36 #include "gc_implementation/parallelScavenge/psMarkSweepDecorator.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	37 #include "gc_implementation/parallelScavenge/psOldGen.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	38 #include "gc_implementation/parallelScavenge/psParallelCompact.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	39 #include "gc_implementation/parallelScavenge/psPermGen.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	40 #include "gc_implementation/parallelScavenge/psPromotionManager.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	41 #include "gc_implementation/parallelScavenge/psScavenge.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	42 #include "gc_implementation/parallelScavenge/psYoungGen.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	43 #include "gc_implementation/shared/isGCActiveMark.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	44 #include "gc_interface/gcCause.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	45 #include "memory/gcLocker.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	46 #include "memory/referencePolicy.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	47 #include "memory/referenceProcessor.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	48 #include "oops/methodDataOop.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	49 #include "oops/oop.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	50 #include "oops/oop.pcgc.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	51 #include "runtime/fprofiler.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	52 #include "runtime/safepoint.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	53 #include "runtime/vmThread.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	54 #include "services/management.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	55 #include "services/memoryService.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	56 #include "utilities/events.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	57 #include "utilities/stack.inline.hpp"
0 a61af66fc99e Initial load duke parents: diff changeset	58
a61af66fc99e Initial load duke parents: diff changeset	59 #include <math.h>
a61af66fc99e Initial load duke parents: diff changeset	60
a61af66fc99e Initial load duke parents: diff changeset	61 // All sizes are in HeapWords.
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	62 const size_t ParallelCompactData::Log2RegionSize = 9; // 512 words
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	63 const size_t ParallelCompactData::RegionSize = (size_t)1 << Log2RegionSize;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	64 const size_t ParallelCompactData::RegionSizeBytes =
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	65 RegionSize << LogHeapWordSize;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	66 const size_t ParallelCompactData::RegionSizeOffsetMask = RegionSize - 1;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	67 const size_t ParallelCompactData::RegionAddrOffsetMask = RegionSizeBytes - 1;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	68 const size_t ParallelCompactData::RegionAddrMask = ~RegionAddrOffsetMask;
0 a61af66fc99e Initial load duke parents: diff changeset	69
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	70 const ParallelCompactData::RegionData::region_sz_t
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	71 ParallelCompactData::RegionData::dc_shift = 27;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	72
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	73 const ParallelCompactData::RegionData::region_sz_t
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	74 ParallelCompactData::RegionData::dc_mask = ~0U << dc_shift;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	75
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	76 const ParallelCompactData::RegionData::region_sz_t
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	77 ParallelCompactData::RegionData::dc_one = 0x1U << dc_shift;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	78
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	79 const ParallelCompactData::RegionData::region_sz_t
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	80 ParallelCompactData::RegionData::los_mask = ~dc_mask;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	81
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	82 const ParallelCompactData::RegionData::region_sz_t
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	83 ParallelCompactData::RegionData::dc_claimed = 0x8U << dc_shift;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	84
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	85 const ParallelCompactData::RegionData::region_sz_t
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	86 ParallelCompactData::RegionData::dc_completed = 0xcU << dc_shift;
0 a61af66fc99e Initial load duke parents: diff changeset	87
a61af66fc99e Initial load duke parents: diff changeset	88 SpaceInfo PSParallelCompact::_space_info[PSParallelCompact::last_space_id];
a61af66fc99e Initial load duke parents: diff changeset	89 bool PSParallelCompact::_print_phases = false;
a61af66fc99e Initial load duke parents: diff changeset	90
a61af66fc99e Initial load duke parents: diff changeset	91 ReferenceProcessor* PSParallelCompact::_ref_processor = NULL;
a61af66fc99e Initial load duke parents: diff changeset	92 klassOop PSParallelCompact::_updated_int_array_klass_obj = NULL;
a61af66fc99e Initial load duke parents: diff changeset	93
a61af66fc99e Initial load duke parents: diff changeset	94 double PSParallelCompact::_dwl_mean;
a61af66fc99e Initial load duke parents: diff changeset	95 double PSParallelCompact::_dwl_std_dev;
a61af66fc99e Initial load duke parents: diff changeset	96 double PSParallelCompact::_dwl_first_term;
a61af66fc99e Initial load duke parents: diff changeset	97 double PSParallelCompact::_dwl_adjustment;
a61af66fc99e Initial load duke parents: diff changeset	98 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	99 bool PSParallelCompact::_dwl_initialized = false;
a61af66fc99e Initial load duke parents: diff changeset	100 #endif // #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	101
a61af66fc99e Initial load duke parents: diff changeset	102 #ifdef VALIDATE_MARK_SWEEP
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 79 diff changeset	103 GrowableArray<void> PSParallelCompact::_root_refs_stack = NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	104 GrowableArray<oop> * PSParallelCompact::_live_oops = NULL;
a61af66fc99e Initial load duke parents: diff changeset	105 GrowableArray<oop> * PSParallelCompact::_live_oops_moved_to = NULL;
a61af66fc99e Initial load duke parents: diff changeset	106 GrowableArray<size_t>* PSParallelCompact::_live_oops_size = NULL;
a61af66fc99e Initial load duke parents: diff changeset	107 size_t PSParallelCompact::_live_oops_index = 0;
a61af66fc99e Initial load duke parents: diff changeset	108 size_t PSParallelCompact::_live_oops_index_at_perm = 0;
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 79 diff changeset	109 GrowableArray<void> PSParallelCompact::_other_refs_stack = NULL;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 79 diff changeset	110 GrowableArray<void> PSParallelCompact::_adjusted_pointers = NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	111 bool PSParallelCompact::_pointer_tracking = false;
a61af66fc99e Initial load duke parents: diff changeset	112 bool PSParallelCompact::_root_tracking = true;
a61af66fc99e Initial load duke parents: diff changeset	113
a61af66fc99e Initial load duke parents: diff changeset	114 GrowableArray<HeapWord> PSParallelCompact::_cur_gc_live_oops = NULL;
a61af66fc99e Initial load duke parents: diff changeset	115 GrowableArray<HeapWord> PSParallelCompact::_cur_gc_live_oops_moved_to = NULL;
a61af66fc99e Initial load duke parents: diff changeset	116 GrowableArray<size_t> * PSParallelCompact::_cur_gc_live_oops_size = NULL;
a61af66fc99e Initial load duke parents: diff changeset	117 GrowableArray<HeapWord> PSParallelCompact::_last_gc_live_oops = NULL;
a61af66fc99e Initial load duke parents: diff changeset	118 GrowableArray<HeapWord> PSParallelCompact::_last_gc_live_oops_moved_to = NULL;
a61af66fc99e Initial load duke parents: diff changeset	119 GrowableArray<size_t> * PSParallelCompact::_last_gc_live_oops_size = NULL;
a61af66fc99e Initial load duke parents: diff changeset	120 #endif
a61af66fc99e Initial load duke parents: diff changeset	121
482 7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	122 void SplitInfo::record(size_t src_region_idx, size_t partial_obj_size,
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	123 HeapWord* destination)
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	124 {
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	125 assert(src_region_idx != 0, "invalid src_region_idx");
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	126 assert(partial_obj_size != 0, "invalid partial_obj_size argument");
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	127 assert(destination != NULL, "invalid destination argument");
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	128
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	129 _src_region_idx = src_region_idx;
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	130 _partial_obj_size = partial_obj_size;
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	131 _destination = destination;
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	132
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	133 // These fields may not be updated below, so make sure they're clear.
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	134 assert(_dest_region_addr == NULL, "should have been cleared");
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	135 assert(_first_src_addr == NULL, "should have been cleared");
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	136
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	137 // Determine the number of destination regions for the partial object.
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	138 HeapWord* const last_word = destination + partial_obj_size - 1;
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	139 const ParallelCompactData& sd = PSParallelCompact::summary_data();
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	140 HeapWord* const beg_region_addr = sd.region_align_down(destination);
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	141 HeapWord* const end_region_addr = sd.region_align_down(last_word);
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	142
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	143 if (beg_region_addr == end_region_addr) {
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	144 // One destination region.
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	145 _destination_count = 1;
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	146 if (end_region_addr == destination) {
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	147 // The destination falls on a region boundary, thus the first word of the
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	148 // partial object will be the first word copied to the destination region.
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	149 _dest_region_addr = end_region_addr;
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	150 _first_src_addr = sd.region_to_addr(src_region_idx);
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	151 }
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	152 } else {
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	153 // Two destination regions. When copied, the partial object will cross a
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	154 // destination region boundary, so a word somewhere within the partial
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	155 // object will be the first word copied to the second destination region.
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	156 _destination_count = 2;
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	157 _dest_region_addr = end_region_addr;
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	158 const size_t ofs = pointer_delta(end_region_addr, destination);
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	159 assert(ofs < _partial_obj_size, "sanity");
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	160 _first_src_addr = sd.region_to_addr(src_region_idx) + ofs;
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	161 }
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	162 }
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	163
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	164 void SplitInfo::clear()
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	165 {
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	166 _src_region_idx = 0;
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	167 _partial_obj_size = 0;
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	168 _destination = NULL;
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	169 _destination_count = 0;
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	170 _dest_region_addr = NULL;
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	171 _first_src_addr = NULL;
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	172 assert(!is_valid(), "sanity");
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	173 }
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	174
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	175 #ifdef ASSERT
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	176 void SplitInfo::verify_clear()
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	177 {
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	178 assert(_src_region_idx == 0, "not clear");
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	179 assert(_partial_obj_size == 0, "not clear");
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	180 assert(_destination == NULL, "not clear");
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	181 assert(_destination_count == 0, "not clear");
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	182 assert(_dest_region_addr == NULL, "not clear");
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	183 assert(_first_src_addr == NULL, "not clear");
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	184 }
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	185 #endif // #ifdef ASSERT
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	186
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	187
0 a61af66fc99e Initial load duke parents: diff changeset	188 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	189 const char* PSParallelCompact::space_names[] = {
a61af66fc99e Initial load duke parents: diff changeset	190 "perm", "old ", "eden", "from", "to "
a61af66fc99e Initial load duke parents: diff changeset	191 };
a61af66fc99e Initial load duke parents: diff changeset	192
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	193 void PSParallelCompact::print_region_ranges()
0 a61af66fc99e Initial load duke parents: diff changeset	194 {
a61af66fc99e Initial load duke parents: diff changeset	195 tty->print_cr("space bottom top end new_top");
a61af66fc99e Initial load duke parents: diff changeset	196 tty->print_cr("------ ---------- ---------- ---------- ----------");
a61af66fc99e Initial load duke parents: diff changeset	197
a61af66fc99e Initial load duke parents: diff changeset	198 for (unsigned int id = 0; id < last_space_id; ++id) {
a61af66fc99e Initial load duke parents: diff changeset	199 const MutableSpace* space = _space_info[id].space();
a61af66fc99e Initial load duke parents: diff changeset	200 tty->print_cr("%u %s "
264 15dd2594d08e 6718283: existing uses of _FORMAT_W() were broken by 6521491 jcoomes* parents: 263 diff changeset	201 SIZE_FORMAT_W(10) " " SIZE_FORMAT_W(10) " "
15dd2594d08e 6718283: existing uses of _FORMAT_W() were broken by 6521491 jcoomes* parents: 263 diff changeset	202 SIZE_FORMAT_W(10) " " SIZE_FORMAT_W(10) " ",
0 a61af66fc99e Initial load duke parents: diff changeset	203 id, space_names[id],
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	204 summary_data().addr_to_region_idx(space->bottom()),
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	205 summary_data().addr_to_region_idx(space->top()),
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	206 summary_data().addr_to_region_idx(space->end()),
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	207 summary_data().addr_to_region_idx(_space_info[id].new_top()));
0 a61af66fc99e Initial load duke parents: diff changeset	208 }
a61af66fc99e Initial load duke parents: diff changeset	209 }
a61af66fc99e Initial load duke parents: diff changeset	210
a61af66fc99e Initial load duke parents: diff changeset	211 void
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	212 print_generic_summary_region(size_t i, const ParallelCompactData::RegionData* c)
0 a61af66fc99e Initial load duke parents: diff changeset	213 {
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	214 #define REGION_IDX_FORMAT SIZE_FORMAT_W(7)
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	215 #define REGION_DATA_FORMAT SIZE_FORMAT_W(5)
0 a61af66fc99e Initial load duke parents: diff changeset	216
a61af66fc99e Initial load duke parents: diff changeset	217 ParallelCompactData& sd = PSParallelCompact::summary_data();
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	218 size_t dci = c->destination() ? sd.addr_to_region_idx(c->destination()) : 0;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	219 tty->print_cr(REGION_IDX_FORMAT " " PTR_FORMAT " "
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	220 REGION_IDX_FORMAT " " PTR_FORMAT " "
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	221 REGION_DATA_FORMAT " " REGION_DATA_FORMAT " "
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	222 REGION_DATA_FORMAT " " REGION_IDX_FORMAT " %d",
0 a61af66fc99e Initial load duke parents: diff changeset	223 i, c->data_location(), dci, c->destination(),
a61af66fc99e Initial load duke parents: diff changeset	224 c->partial_obj_size(), c->live_obj_size(),
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	225 c->data_size(), c->source_region(), c->destination_count());
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	226
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	227 #undef REGION_IDX_FORMAT
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	228 #undef REGION_DATA_FORMAT
0 a61af66fc99e Initial load duke parents: diff changeset	229 }
a61af66fc99e Initial load duke parents: diff changeset	230
a61af66fc99e Initial load duke parents: diff changeset	231 void
a61af66fc99e Initial load duke parents: diff changeset	232 print_generic_summary_data(ParallelCompactData& summary_data,
a61af66fc99e Initial load duke parents: diff changeset	233 HeapWord* const beg_addr,
a61af66fc99e Initial load duke parents: diff changeset	234 HeapWord* const end_addr)
a61af66fc99e Initial load duke parents: diff changeset	235 {
a61af66fc99e Initial load duke parents: diff changeset	236 size_t total_words = 0;
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	237 size_t i = summary_data.addr_to_region_idx(beg_addr);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	238 const size_t last = summary_data.addr_to_region_idx(end_addr);
0 a61af66fc99e Initial load duke parents: diff changeset	239 HeapWord* pdest = 0;
a61af66fc99e Initial load duke parents: diff changeset	240
a61af66fc99e Initial load duke parents: diff changeset	241 while (i <= last) {
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	242 ParallelCompactData::RegionData* c = summary_data.region(i);
0 a61af66fc99e Initial load duke parents: diff changeset	243 if (c->data_size() != 0 \|\| c->destination() != pdest) {
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	244 print_generic_summary_region(i, c);
0 a61af66fc99e Initial load duke parents: diff changeset	245 total_words += c->data_size();
a61af66fc99e Initial load duke parents: diff changeset	246 pdest = c->destination();
a61af66fc99e Initial load duke parents: diff changeset	247 }
a61af66fc99e Initial load duke parents: diff changeset	248 ++i;
a61af66fc99e Initial load duke parents: diff changeset	249 }
a61af66fc99e Initial load duke parents: diff changeset	250
a61af66fc99e Initial load duke parents: diff changeset	251 tty->print_cr("summary_data_bytes=" SIZE_FORMAT, total_words * HeapWordSize);
a61af66fc99e Initial load duke parents: diff changeset	252 }
a61af66fc99e Initial load duke parents: diff changeset	253
a61af66fc99e Initial load duke parents: diff changeset	254 void
a61af66fc99e Initial load duke parents: diff changeset	255 print_generic_summary_data(ParallelCompactData& summary_data,
a61af66fc99e Initial load duke parents: diff changeset	256 SpaceInfo* space_info)
a61af66fc99e Initial load duke parents: diff changeset	257 {
a61af66fc99e Initial load duke parents: diff changeset	258 for (unsigned int id = 0; id < PSParallelCompact::last_space_id; ++id) {
a61af66fc99e Initial load duke parents: diff changeset	259 const MutableSpace* space = space_info[id].space();
a61af66fc99e Initial load duke parents: diff changeset	260 print_generic_summary_data(summary_data, space->bottom(),
a61af66fc99e Initial load duke parents: diff changeset	261 MAX2(space->top(), space_info[id].new_top()));
a61af66fc99e Initial load duke parents: diff changeset	262 }
a61af66fc99e Initial load duke parents: diff changeset	263 }
a61af66fc99e Initial load duke parents: diff changeset	264
a61af66fc99e Initial load duke parents: diff changeset	265 void
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	266 print_initial_summary_region(size_t i,
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	267 const ParallelCompactData::RegionData* c,
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	268 bool newline = true)
0 a61af66fc99e Initial load duke parents: diff changeset	269 {
264 15dd2594d08e 6718283: existing uses of _FORMAT_W() were broken by 6521491 jcoomes* parents: 263 diff changeset	270 tty->print(SIZE_FORMAT_W(5) " " PTR_FORMAT " "
15dd2594d08e 6718283: existing uses of _FORMAT_W() were broken by 6521491 jcoomes* parents: 263 diff changeset	271 SIZE_FORMAT_W(5) " " SIZE_FORMAT_W(5) " "
15dd2594d08e 6718283: existing uses of _FORMAT_W() were broken by 6521491 jcoomes* parents: 263 diff changeset	272 SIZE_FORMAT_W(5) " " SIZE_FORMAT_W(5) " %d",
0 a61af66fc99e Initial load duke parents: diff changeset	273 i, c->destination(),
a61af66fc99e Initial load duke parents: diff changeset	274 c->partial_obj_size(), c->live_obj_size(),
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	275 c->data_size(), c->source_region(), c->destination_count());
0 a61af66fc99e Initial load duke parents: diff changeset	276 if (newline) tty->cr();
a61af66fc99e Initial load duke parents: diff changeset	277 }
a61af66fc99e Initial load duke parents: diff changeset	278
a61af66fc99e Initial load duke parents: diff changeset	279 void
a61af66fc99e Initial load duke parents: diff changeset	280 print_initial_summary_data(ParallelCompactData& summary_data,
a61af66fc99e Initial load duke parents: diff changeset	281 const MutableSpace* space) {
a61af66fc99e Initial load duke parents: diff changeset	282 if (space->top() == space->bottom()) {
a61af66fc99e Initial load duke parents: diff changeset	283 return;
a61af66fc99e Initial load duke parents: diff changeset	284 }
a61af66fc99e Initial load duke parents: diff changeset	285
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	286 const size_t region_size = ParallelCompactData::RegionSize;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	287 typedef ParallelCompactData::RegionData RegionData;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	288 HeapWord* const top_aligned_up = summary_data.region_align_up(space->top());
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	289 const size_t end_region = summary_data.addr_to_region_idx(top_aligned_up);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	290 const RegionData* c = summary_data.region(end_region - 1);
0 a61af66fc99e Initial load duke parents: diff changeset	291 HeapWord* end_addr = c->destination() + c->data_size();
a61af66fc99e Initial load duke parents: diff changeset	292 const size_t live_in_space = pointer_delta(end_addr, space->bottom());
a61af66fc99e Initial load duke parents: diff changeset	293
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	294 // Print (and count) the full regions at the beginning of the space.
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	295 size_t full_region_count = 0;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	296 size_t i = summary_data.addr_to_region_idx(space->bottom());
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	297 while (i < end_region && summary_data.region(i)->data_size() == region_size) {
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	298 print_initial_summary_region(i, summary_data.region(i));
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	299 ++full_region_count;
0 a61af66fc99e Initial load duke parents: diff changeset	300 ++i;
a61af66fc99e Initial load duke parents: diff changeset	301 }
a61af66fc99e Initial load duke parents: diff changeset	302
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	303 size_t live_to_right = live_in_space - full_region_count * region_size;
0 a61af66fc99e Initial load duke parents: diff changeset	304
a61af66fc99e Initial load duke parents: diff changeset	305 double max_reclaimed_ratio = 0.0;
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	306 size_t max_reclaimed_ratio_region = 0;
0 a61af66fc99e Initial load duke parents: diff changeset	307 size_t max_dead_to_right = 0;
a61af66fc99e Initial load duke parents: diff changeset	308 size_t max_live_to_right = 0;
a61af66fc99e Initial load duke parents: diff changeset	309
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	310 // Print the 'reclaimed ratio' for regions while there is something live in
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	311 // the region or to the right of it. The remaining regions are empty (and
0 a61af66fc99e Initial load duke parents: diff changeset	312 // uninteresting), and computing the ratio will result in division by 0.
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	313 while (i < end_region && live_to_right > 0) {
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	314 c = summary_data.region(i);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	315 HeapWord* const region_addr = summary_data.region_to_addr(i);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	316 const size_t used_to_right = pointer_delta(space->top(), region_addr);
0 a61af66fc99e Initial load duke parents: diff changeset	317 const size_t dead_to_right = used_to_right - live_to_right;
a61af66fc99e Initial load duke parents: diff changeset	318 const double reclaimed_ratio = double(dead_to_right) / live_to_right;
a61af66fc99e Initial load duke parents: diff changeset	319
a61af66fc99e Initial load duke parents: diff changeset	320 if (reclaimed_ratio > max_reclaimed_ratio) {
a61af66fc99e Initial load duke parents: diff changeset	321 max_reclaimed_ratio = reclaimed_ratio;
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	322 max_reclaimed_ratio_region = i;
0 a61af66fc99e Initial load duke parents: diff changeset	323 max_dead_to_right = dead_to_right;
a61af66fc99e Initial load duke parents: diff changeset	324 max_live_to_right = live_to_right;
a61af66fc99e Initial load duke parents: diff changeset	325 }
a61af66fc99e Initial load duke parents: diff changeset	326
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	327 print_initial_summary_region(i, c, false);
264 15dd2594d08e 6718283: existing uses of _FORMAT_W() were broken by 6521491 jcoomes* parents: 263 diff changeset	328 tty->print_cr(" %12.10f " SIZE_FORMAT_W(10) " " SIZE_FORMAT_W(10),
0 a61af66fc99e Initial load duke parents: diff changeset	329 reclaimed_ratio, dead_to_right, live_to_right);
a61af66fc99e Initial load duke parents: diff changeset	330
a61af66fc99e Initial load duke parents: diff changeset	331 live_to_right -= c->data_size();
a61af66fc99e Initial load duke parents: diff changeset	332 ++i;
a61af66fc99e Initial load duke parents: diff changeset	333 }
a61af66fc99e Initial load duke parents: diff changeset	334
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	335 // Any remaining regions are empty. Print one more if there is one.
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	336 if (i < end_region) {
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	337 print_initial_summary_region(i, summary_data.region(i));
0 a61af66fc99e Initial load duke parents: diff changeset	338 }
a61af66fc99e Initial load duke parents: diff changeset	339
264 15dd2594d08e 6718283: existing uses of _FORMAT_W() were broken by 6521491 jcoomes* parents: 263 diff changeset	340 tty->print_cr("max: " SIZE_FORMAT_W(4) " d2r=" SIZE_FORMAT_W(10) " "
15dd2594d08e 6718283: existing uses of _FORMAT_W() were broken by 6521491 jcoomes* parents: 263 diff changeset	341 "l2r=" SIZE_FORMAT_W(10) " max_ratio=%14.12f",
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	342 max_reclaimed_ratio_region, max_dead_to_right,
0 a61af66fc99e Initial load duke parents: diff changeset	343 max_live_to_right, max_reclaimed_ratio);
a61af66fc99e Initial load duke parents: diff changeset	344 }
a61af66fc99e Initial load duke parents: diff changeset	345
a61af66fc99e Initial load duke parents: diff changeset	346 void
a61af66fc99e Initial load duke parents: diff changeset	347 print_initial_summary_data(ParallelCompactData& summary_data,
a61af66fc99e Initial load duke parents: diff changeset	348 SpaceInfo* space_info) {
a61af66fc99e Initial load duke parents: diff changeset	349 unsigned int id = PSParallelCompact::perm_space_id;
a61af66fc99e Initial load duke parents: diff changeset	350 const MutableSpace* space;
a61af66fc99e Initial load duke parents: diff changeset	351 do {
a61af66fc99e Initial load duke parents: diff changeset	352 space = space_info[id].space();
a61af66fc99e Initial load duke parents: diff changeset	353 print_initial_summary_data(summary_data, space);
a61af66fc99e Initial load duke parents: diff changeset	354 } while (++id < PSParallelCompact::eden_space_id);
a61af66fc99e Initial load duke parents: diff changeset	355
a61af66fc99e Initial load duke parents: diff changeset	356 do {
a61af66fc99e Initial load duke parents: diff changeset	357 space = space_info[id].space();
a61af66fc99e Initial load duke parents: diff changeset	358 print_generic_summary_data(summary_data, space->bottom(), space->top());
a61af66fc99e Initial load duke parents: diff changeset	359 } while (++id < PSParallelCompact::last_space_id);
a61af66fc99e Initial load duke parents: diff changeset	360 }
a61af66fc99e Initial load duke parents: diff changeset	361 #endif // #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	362
a61af66fc99e Initial load duke parents: diff changeset	363 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	364 size_t add_obj_count;
a61af66fc99e Initial load duke parents: diff changeset	365 size_t add_obj_size;
a61af66fc99e Initial load duke parents: diff changeset	366 size_t mark_bitmap_count;
a61af66fc99e Initial load duke parents: diff changeset	367 size_t mark_bitmap_size;
a61af66fc99e Initial load duke parents: diff changeset	368 #endif // #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	369
a61af66fc99e Initial load duke parents: diff changeset	370 ParallelCompactData::ParallelCompactData()
a61af66fc99e Initial load duke parents: diff changeset	371 {
a61af66fc99e Initial load duke parents: diff changeset	372 _region_start = 0;
a61af66fc99e Initial load duke parents: diff changeset	373
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	374 _region_vspace = 0;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	375 _region_data = 0;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	376 _region_count = 0;
0 a61af66fc99e Initial load duke parents: diff changeset	377 }
a61af66fc99e Initial load duke parents: diff changeset	378
a61af66fc99e Initial load duke parents: diff changeset	379 bool ParallelCompactData::initialize(MemRegion covered_region)
a61af66fc99e Initial load duke parents: diff changeset	380 {
a61af66fc99e Initial load duke parents: diff changeset	381 _region_start = covered_region.start();
a61af66fc99e Initial load duke parents: diff changeset	382 const size_t region_size = covered_region.word_size();
a61af66fc99e Initial load duke parents: diff changeset	383 DEBUG_ONLY(_region_end = _region_start + region_size;)
a61af66fc99e Initial load duke parents: diff changeset	384
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	385 assert(region_align_down(_region_start) == _region_start,
0 a61af66fc99e Initial load duke parents: diff changeset	386 "region start not aligned");
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	387 assert((region_size & RegionSizeOffsetMask) == 0,
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	388 "region size not a multiple of RegionSize");
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	389
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	390 bool result = initialize_region_data(region_size);
0 a61af66fc99e Initial load duke parents: diff changeset	391
a61af66fc99e Initial load duke parents: diff changeset	392 return result;
a61af66fc99e Initial load duke parents: diff changeset	393 }
a61af66fc99e Initial load duke parents: diff changeset	394
a61af66fc99e Initial load duke parents: diff changeset	395 PSVirtualSpace*
a61af66fc99e Initial load duke parents: diff changeset	396 ParallelCompactData::create_vspace(size_t count, size_t element_size)
a61af66fc99e Initial load duke parents: diff changeset	397 {
a61af66fc99e Initial load duke parents: diff changeset	398 const size_t raw_bytes = count * element_size;
a61af66fc99e Initial load duke parents: diff changeset	399 const size_t page_sz = os::page_size_for_region(raw_bytes, raw_bytes, 10);
a61af66fc99e Initial load duke parents: diff changeset	400 const size_t granularity = os::vm_allocation_granularity();
a61af66fc99e Initial load duke parents: diff changeset	401 const size_t bytes = align_size_up(raw_bytes, MAX2(page_sz, granularity));
a61af66fc99e Initial load duke parents: diff changeset	402
a61af66fc99e Initial load duke parents: diff changeset	403 const size_t rs_align = page_sz == (size_t) os::vm_page_size() ? 0 :
a61af66fc99e Initial load duke parents: diff changeset	404 MAX2(page_sz, granularity);
79 82db0859acbe 6642862: Code cache allocation fails with large pages after 6588638 jcoomes parents: 0 diff changeset	405 ReservedSpace rs(bytes, rs_align, rs_align > 0);
0 a61af66fc99e Initial load duke parents: diff changeset	406 os::trace_page_sizes("par compact", raw_bytes, raw_bytes, page_sz, rs.base(),
a61af66fc99e Initial load duke parents: diff changeset	407 rs.size());
a61af66fc99e Initial load duke parents: diff changeset	408 PSVirtualSpace* vspace = new PSVirtualSpace(rs, page_sz);
a61af66fc99e Initial load duke parents: diff changeset	409 if (vspace != 0) {
a61af66fc99e Initial load duke parents: diff changeset	410 if (vspace->expand_by(bytes)) {
a61af66fc99e Initial load duke parents: diff changeset	411 return vspace;
a61af66fc99e Initial load duke parents: diff changeset	412 }
a61af66fc99e Initial load duke parents: diff changeset	413 delete vspace;
237 1fdb98a17101 6716785: implicit null checks not triggering with CompressedOops coleenp parents: 235 diff changeset	414 // Release memory reserved in the space.
1fdb98a17101 6716785: implicit null checks not triggering with CompressedOops coleenp parents: 235 diff changeset	415 rs.release();
0 a61af66fc99e Initial load duke parents: diff changeset	416 }
a61af66fc99e Initial load duke parents: diff changeset	417
a61af66fc99e Initial load duke parents: diff changeset	418 return 0;
a61af66fc99e Initial load duke parents: diff changeset	419 }
a61af66fc99e Initial load duke parents: diff changeset	420
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	421 bool ParallelCompactData::initialize_region_data(size_t region_size)
0 a61af66fc99e Initial load duke parents: diff changeset	422 {
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	423 const size_t count = (region_size + RegionSizeOffsetMask) >> Log2RegionSize;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	424 _region_vspace = create_vspace(count, sizeof(RegionData));
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	425 if (_region_vspace != 0) {
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	426 _region_data = (RegionData*)_region_vspace->reserved_low_addr();
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	427 _region_count = count;
0 a61af66fc99e Initial load duke parents: diff changeset	428 return true;
a61af66fc99e Initial load duke parents: diff changeset	429 }
a61af66fc99e Initial load duke parents: diff changeset	430 return false;
a61af66fc99e Initial load duke parents: diff changeset	431 }
a61af66fc99e Initial load duke parents: diff changeset	432
a61af66fc99e Initial load duke parents: diff changeset	433 void ParallelCompactData::clear()
a61af66fc99e Initial load duke parents: diff changeset	434 {
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	435 memset(_region_data, 0, _region_vspace->committed_size());
0 a61af66fc99e Initial load duke parents: diff changeset	436 }
a61af66fc99e Initial load duke parents: diff changeset	437
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	438 void ParallelCompactData::clear_range(size_t beg_region, size_t end_region) {
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	439 assert(beg_region <= _region_count, "beg_region out of range");
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	440 assert(end_region <= _region_count, "end_region out of range");
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	441
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	442 const size_t region_cnt = end_region - beg_region;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	443 memset(_region_data + beg_region, 0, region_cnt * sizeof(RegionData));
0 a61af66fc99e Initial load duke parents: diff changeset	444 }
a61af66fc99e Initial load duke parents: diff changeset	445
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	446 HeapWord* ParallelCompactData::partial_obj_end(size_t region_idx) const
0 a61af66fc99e Initial load duke parents: diff changeset	447 {
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	448 const RegionData* cur_cp = region(region_idx);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	449 const RegionData* const end_cp = region(region_count() - 1);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	450
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	451 HeapWord* result = region_to_addr(region_idx);
0 a61af66fc99e Initial load duke parents: diff changeset	452 if (cur_cp < end_cp) {
a61af66fc99e Initial load duke parents: diff changeset	453 do {
a61af66fc99e Initial load duke parents: diff changeset	454 result += cur_cp->partial_obj_size();
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	455 } while (cur_cp->partial_obj_size() == RegionSize && ++cur_cp < end_cp);
0 a61af66fc99e Initial load duke parents: diff changeset	456 }
a61af66fc99e Initial load duke parents: diff changeset	457 return result;
a61af66fc99e Initial load duke parents: diff changeset	458 }
a61af66fc99e Initial load duke parents: diff changeset	459
a61af66fc99e Initial load duke parents: diff changeset	460 void ParallelCompactData::add_obj(HeapWord* addr, size_t len)
a61af66fc99e Initial load duke parents: diff changeset	461 {
a61af66fc99e Initial load duke parents: diff changeset	462 const size_t obj_ofs = pointer_delta(addr, _region_start);
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	463 const size_t beg_region = obj_ofs >> Log2RegionSize;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	464 const size_t end_region = (obj_ofs + len - 1) >> Log2RegionSize;
0 a61af66fc99e Initial load duke parents: diff changeset	465
a61af66fc99e Initial load duke parents: diff changeset	466 DEBUG_ONLY(Atomic::inc_ptr(&add_obj_count);)
a61af66fc99e Initial load duke parents: diff changeset	467 DEBUG_ONLY(Atomic::add_ptr(len, &add_obj_size);)
a61af66fc99e Initial load duke parents: diff changeset	468
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	469 if (beg_region == end_region) {
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	470 // All in one region.
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	471 _region_data[beg_region].add_live_obj(len);
0 a61af66fc99e Initial load duke parents: diff changeset	472 return;
a61af66fc99e Initial load duke parents: diff changeset	473 }
a61af66fc99e Initial load duke parents: diff changeset	474
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	475 // First region.
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	476 const size_t beg_ofs = region_offset(addr);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	477 _region_data[beg_region].add_live_obj(RegionSize - beg_ofs);
0 a61af66fc99e Initial load duke parents: diff changeset	478
a61af66fc99e Initial load duke parents: diff changeset	479 klassOop klass = ((oop)addr)->klass();
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	480 // Middle regions--completely spanned by this object.
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	481 for (size_t region = beg_region + 1; region < end_region; ++region) {
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	482 _region_data[region].set_partial_obj_size(RegionSize);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	483 _region_data[region].set_partial_obj_addr(addr);
0 a61af66fc99e Initial load duke parents: diff changeset	484 }
a61af66fc99e Initial load duke parents: diff changeset	485
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	486 // Last region.
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	487 const size_t end_ofs = region_offset(addr + len - 1);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	488 _region_data[end_region].set_partial_obj_size(end_ofs + 1);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	489 _region_data[end_region].set_partial_obj_addr(addr);
0 a61af66fc99e Initial load duke parents: diff changeset	490 }
a61af66fc99e Initial load duke parents: diff changeset	491
a61af66fc99e Initial load duke parents: diff changeset	492 void
a61af66fc99e Initial load duke parents: diff changeset	493 ParallelCompactData::summarize_dense_prefix(HeapWord* beg, HeapWord* end)
a61af66fc99e Initial load duke parents: diff changeset	494 {
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	495 assert(region_offset(beg) == 0, "not RegionSize aligned");
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	496 assert(region_offset(end) == 0, "not RegionSize aligned");
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	497
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	498 size_t cur_region = addr_to_region_idx(beg);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	499 const size_t end_region = addr_to_region_idx(end);
0 a61af66fc99e Initial load duke parents: diff changeset	500 HeapWord* addr = beg;
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	501 while (cur_region < end_region) {
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	502 _region_data[cur_region].set_destination(addr);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	503 _region_data[cur_region].set_destination_count(0);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	504 _region_data[cur_region].set_source_region(cur_region);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	505 _region_data[cur_region].set_data_location(addr);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	506
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	507 // Update live_obj_size so the region appears completely full.
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	508 size_t live_size = RegionSize - _region_data[cur_region].partial_obj_size();
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	509 _region_data[cur_region].set_live_obj_size(live_size);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	510
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	511 ++cur_region;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	512 addr += RegionSize;
0 a61af66fc99e Initial load duke parents: diff changeset	513 }
a61af66fc99e Initial load duke parents: diff changeset	514 }
a61af66fc99e Initial load duke parents: diff changeset	515
482 7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	516 // Find the point at which a space can be split and, if necessary, record the
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	517 // split point.
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	518 //
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	519 // If the current src region (which overflowed the destination space) doesn't
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	520 // have a partial object, the split point is at the beginning of the current src
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	521 // region (an "easy" split, no extra bookkeeping required).
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	522 //
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	523 // If the current src region has a partial object, the split point is in the
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	524 // region where that partial object starts (call it the split_region). If
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	525 // split_region has a partial object, then the split point is just after that
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	526 // partial object (a "hard" split where we have to record the split data and
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	527 // zero the partial_obj_size field). With a "hard" split, we know that the
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	528 // partial_obj ends within split_region because the partial object that caused
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	529 // the overflow starts in split_region. If split_region doesn't have a partial
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	530 // obj, then the split is at the beginning of split_region (another "easy"
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	531 // split).
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	532 HeapWord*
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	533 ParallelCompactData::summarize_split_space(size_t src_region,
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	534 SplitInfo& split_info,
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	535 HeapWord* destination,
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	536 HeapWord* target_end,
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	537 HeapWord** target_next)
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	538 {
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	539 assert(destination <= target_end, "sanity");
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	540 assert(destination + _region_data[src_region].data_size() > target_end,
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	541 "region should not fit into target space");
696 f18338cf04b0 6810474: par compact - crash in summary_phase with very full heap jcoomes parents: 628 diff changeset	542 assert(is_region_aligned(target_end), "sanity");
482 7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	543
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	544 size_t split_region = src_region;
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	545 HeapWord* split_destination = destination;
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	546 size_t partial_obj_size = _region_data[src_region].partial_obj_size();
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	547
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	548 if (destination + partial_obj_size > target_end) {
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	549 // The split point is just after the partial object (if any) in the
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	550 // src_region that contains the start of the object that overflowed the
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	551 // destination space.
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	552 //
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	553 // Find the start of the "overflow" object and set split_region to the
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	554 // region containing it.
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	555 HeapWord* const overflow_obj = _region_data[src_region].partial_obj_addr();
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	556 split_region = addr_to_region_idx(overflow_obj);
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	557
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	558 // Clear the source_region field of all destination regions whose first word
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	559 // came from data after the split point (a non-null source_region field
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	560 // implies a region must be filled).
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	561 //
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	562 // An alternative to the simple loop below: clear during post_compact(),
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	563 // which uses memcpy instead of individual stores, and is easy to
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	564 // parallelize. (The downside is that it clears the entire RegionData
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	565 // object as opposed to just one field.)
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	566 //
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	567 // post_compact() would have to clear the summary data up to the highest
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	568 // address that was written during the summary phase, which would be
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	569 //
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	570 // max(top, max(new_top, clear_top))
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	571 //
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	572 // where clear_top is a new field in SpaceInfo. Would have to set clear_top
696 f18338cf04b0 6810474: par compact - crash in summary_phase with very full heap jcoomes parents: 628 diff changeset	573 // to target_end.
482 7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	574 const RegionData* const sr = region(split_region);
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	575 const size_t beg_idx =
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	576 addr_to_region_idx(region_align_up(sr->destination() +
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	577 sr->partial_obj_size()));
696 f18338cf04b0 6810474: par compact - crash in summary_phase with very full heap jcoomes parents: 628 diff changeset	578 const size_t end_idx = addr_to_region_idx(target_end);
482 7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	579
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	580 if (TraceParallelOldGCSummaryPhase) {
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	581 gclog_or_tty->print_cr("split: clearing source_region field in ["
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	582 SIZE_FORMAT ", " SIZE_FORMAT ")",
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	583 beg_idx, end_idx);
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	584 }
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	585 for (size_t idx = beg_idx; idx < end_idx; ++idx) {
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	586 _region_data[idx].set_source_region(0);
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	587 }
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	588
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	589 // Set split_destination and partial_obj_size to reflect the split region.
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	590 split_destination = sr->destination();
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	591 partial_obj_size = sr->partial_obj_size();
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	592 }
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	593
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	594 // The split is recorded only if a partial object extends onto the region.
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	595 if (partial_obj_size != 0) {
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	596 _region_data[split_region].set_partial_obj_size(0);
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	597 split_info.record(split_region, partial_obj_size, split_destination);
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	598 }
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	599
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	600 // Setup the continuation addresses.
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	601 *target_next = split_destination + partial_obj_size;
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	602 HeapWord* const source_next = region_to_addr(split_region) + partial_obj_size;
0 a61af66fc99e Initial load duke parents: diff changeset	603
a61af66fc99e Initial load duke parents: diff changeset	604 if (TraceParallelOldGCSummaryPhase) {
482 7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	605 const char * split_type = partial_obj_size == 0 ? "easy" : "hard";
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	606 gclog_or_tty->print_cr("%s split: src=" PTR_FORMAT " src_c=" SIZE_FORMAT
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	607 " pos=" SIZE_FORMAT,
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	608 split_type, source_next, split_region,
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	609 partial_obj_size);
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	610 gclog_or_tty->print_cr("%s split: dst=" PTR_FORMAT " dst_c=" SIZE_FORMAT
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	611 " tn=" PTR_FORMAT,
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	612 split_type, split_destination,
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	613 addr_to_region_idx(split_destination),
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	614 *target_next);
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	615
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	616 if (partial_obj_size != 0) {
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	617 HeapWord* const po_beg = split_info.destination();
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	618 HeapWord* const po_end = po_beg + split_info.partial_obj_size();
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	619 gclog_or_tty->print_cr("%s split: "
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	620 "po_beg=" PTR_FORMAT " " SIZE_FORMAT " "
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	621 "po_end=" PTR_FORMAT " " SIZE_FORMAT,
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	622 split_type,
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	623 po_beg, addr_to_region_idx(po_beg),
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	624 po_end, addr_to_region_idx(po_end));
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	625 }
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	626 }
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	627
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	628 return source_next;
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	629 }
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	630
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	631 bool ParallelCompactData::summarize(SplitInfo& split_info,
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	632 HeapWord* source_beg, HeapWord* source_end,
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	633 HeapWord** source_next,
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	634 HeapWord* target_beg, HeapWord* target_end,
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	635 HeapWord** target_next)
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	636 {
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	637 if (TraceParallelOldGCSummaryPhase) {
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	638 HeapWord* const source_next_val = source_next == NULL ? NULL : *source_next;
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	639 tty->print_cr("sb=" PTR_FORMAT " se=" PTR_FORMAT " sn=" PTR_FORMAT
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	640 "tb=" PTR_FORMAT " te=" PTR_FORMAT " tn=" PTR_FORMAT,
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	641 source_beg, source_end, source_next_val,
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	642 target_beg, target_end, *target_next);
0 a61af66fc99e Initial load duke parents: diff changeset	643 }
a61af66fc99e Initial load duke parents: diff changeset	644
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	645 size_t cur_region = addr_to_region_idx(source_beg);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	646 const size_t end_region = addr_to_region_idx(region_align_up(source_end));
0 a61af66fc99e Initial load duke parents: diff changeset	647
a61af66fc99e Initial load duke parents: diff changeset	648 HeapWord *dest_addr = target_beg;
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	649 while (cur_region < end_region) {
482 7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	650 // The destination must be set even if the region has no data.
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	651 _region_data[cur_region].set_destination(dest_addr);
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	652
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	653 size_t words = _region_data[cur_region].data_size();
0 a61af66fc99e Initial load duke parents: diff changeset	654 if (words > 0) {
482 7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	655 // If cur_region does not fit entirely into the target space, find a point
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	656 // at which the source space can be 'split' so that part is copied to the
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	657 // target space and the rest is copied elsewhere.
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	658 if (dest_addr + words > target_end) {
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	659 assert(source_next != NULL, "source_next is NULL when splitting");
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	660 *source_next = summarize_split_space(cur_region, split_info, dest_addr,
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	661 target_end, target_next);
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	662 return false;
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	663 }
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	664
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	665 // Compute the destination_count for cur_region, and if necessary, update
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	666 // source_region for a destination region. The source_region field is
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	667 // updated if cur_region is the first (left-most) region to be copied to a
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	668 // destination region.
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	669 //
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	670 // The destination_count calculation is a bit subtle. A region that has
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	671 // data that compacts into itself does not count itself as a destination.
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	672 // This maintains the invariant that a zero count means the region is
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	673 // available and can be claimed and then filled.
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	674 uint destination_count = 0;
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	675 if (split_info.is_split(cur_region)) {
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	676 // The current region has been split: the partial object will be copied
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	677 // to one destination space and the remaining data will be copied to
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	678 // another destination space. Adjust the initial destination_count and,
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	679 // if necessary, set the source_region field if the partial object will
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	680 // cross a destination region boundary.
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	681 destination_count = split_info.destination_count();
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	682 if (destination_count == 2) {
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	683 size_t dest_idx = addr_to_region_idx(split_info.dest_region_addr());
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	684 _region_data[dest_idx].set_source_region(cur_region);
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	685 }
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	686 }
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	687
0 a61af66fc99e Initial load duke parents: diff changeset	688 HeapWord* const last_addr = dest_addr + words - 1;
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	689 const size_t dest_region_1 = addr_to_region_idx(dest_addr);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	690 const size_t dest_region_2 = addr_to_region_idx(last_addr);
482 7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	691
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	692 // Initially assume that the destination regions will be the same and
0 a61af66fc99e Initial load duke parents: diff changeset	693 // adjust the value below if necessary. Under this assumption, if
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	694 // cur_region == dest_region_2, then cur_region will be compacted
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	695 // completely into itself.
482 7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	696 destination_count += cur_region == dest_region_2 ? 0 : 1;
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	697 if (dest_region_1 != dest_region_2) {
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	698 // Destination regions differ; adjust destination_count.
0 a61af66fc99e Initial load duke parents: diff changeset	699 destination_count += 1;
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	700 // Data from cur_region will be copied to the start of dest_region_2.
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	701 _region_data[dest_region_2].set_source_region(cur_region);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	702 } else if (region_offset(dest_addr) == 0) {
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	703 // Data from cur_region will be copied to the start of the destination
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	704 // region.
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	705 _region_data[dest_region_1].set_source_region(cur_region);
0 a61af66fc99e Initial load duke parents: diff changeset	706 }
a61af66fc99e Initial load duke parents: diff changeset	707
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	708 _region_data[cur_region].set_destination_count(destination_count);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	709 _region_data[cur_region].set_data_location(region_to_addr(cur_region));
0 a61af66fc99e Initial load duke parents: diff changeset	710 dest_addr += words;
a61af66fc99e Initial load duke parents: diff changeset	711 }
a61af66fc99e Initial load duke parents: diff changeset	712
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	713 ++cur_region;
0 a61af66fc99e Initial load duke parents: diff changeset	714 }
a61af66fc99e Initial load duke parents: diff changeset	715
a61af66fc99e Initial load duke parents: diff changeset	716 *target_next = dest_addr;
a61af66fc99e Initial load duke parents: diff changeset	717 return true;
a61af66fc99e Initial load duke parents: diff changeset	718 }
a61af66fc99e Initial load duke parents: diff changeset	719
a61af66fc99e Initial load duke parents: diff changeset	720 HeapWord* ParallelCompactData::calc_new_pointer(HeapWord* addr) {
a61af66fc99e Initial load duke parents: diff changeset	721 assert(addr != NULL, "Should detect NULL oop earlier");
a61af66fc99e Initial load duke parents: diff changeset	722 assert(PSParallelCompact::gc_heap()->is_in(addr), "addr not in heap");
a61af66fc99e Initial load duke parents: diff changeset	723 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	724 if (PSParallelCompact::mark_bitmap()->is_unmarked(addr)) {
a61af66fc99e Initial load duke parents: diff changeset	725 gclog_or_tty->print_cr("calc_new_pointer:: addr " PTR_FORMAT, addr);
a61af66fc99e Initial load duke parents: diff changeset	726 }
a61af66fc99e Initial load duke parents: diff changeset	727 #endif
a61af66fc99e Initial load duke parents: diff changeset	728 assert(PSParallelCompact::mark_bitmap()->is_marked(addr), "obj not marked");
a61af66fc99e Initial load duke parents: diff changeset	729
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	730 // Region covering the object.
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	731 size_t region_index = addr_to_region_idx(addr);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	732 const RegionData* const region_ptr = region(region_index);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	733 HeapWord* const region_addr = region_align_down(addr);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	734
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	735 assert(addr < region_addr + RegionSize, "Region does not cover object");
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	736 assert(addr_to_region_ptr(region_addr) == region_ptr, "sanity check");
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	737
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	738 HeapWord* result = region_ptr->destination();
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	739
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	740 // If all the data in the region is live, then the new location of the object
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	741 // can be calculated from the destination of the region plus the offset of the
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	742 // object in the region.
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	743 if (region_ptr->data_size() == RegionSize) {
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	744 result += pointer_delta(addr, region_addr);
1571 2d127394260e 6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb kvn parents: 1489 diff changeset	745 DEBUG_ONLY(PSParallelCompact::check_new_location(addr, result);)
0 a61af66fc99e Initial load duke parents: diff changeset	746 return result;
a61af66fc99e Initial load duke parents: diff changeset	747 }
a61af66fc99e Initial load duke parents: diff changeset	748
a61af66fc99e Initial load duke parents: diff changeset	749 // The new location of the object is
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	750 // region destination +
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	751 // size of the partial object extending onto the region +
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	752 // sizes of the live objects in the Region that are to the left of addr
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	753 const size_t partial_obj_size = region_ptr->partial_obj_size();
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	754 HeapWord* const search_start = region_addr + partial_obj_size;
0 a61af66fc99e Initial load duke parents: diff changeset	755
a61af66fc99e Initial load duke parents: diff changeset	756 const ParMarkBitMap* bitmap = PSParallelCompact::mark_bitmap();
a61af66fc99e Initial load duke parents: diff changeset	757 size_t live_to_left = bitmap->live_words_in_range(search_start, oop(addr));
a61af66fc99e Initial load duke parents: diff changeset	758
a61af66fc99e Initial load duke parents: diff changeset	759 result += partial_obj_size + live_to_left;
495 234c22e54b98 6784849: par compact - can fail when to_space is non-empty jcoomes parents: 483 diff changeset	760 DEBUG_ONLY(PSParallelCompact::check_new_location(addr, result);)
0 a61af66fc99e Initial load duke parents: diff changeset	761 return result;
a61af66fc99e Initial load duke parents: diff changeset	762 }
a61af66fc99e Initial load duke parents: diff changeset	763
a61af66fc99e Initial load duke parents: diff changeset	764 klassOop ParallelCompactData::calc_new_klass(klassOop old_klass) {
a61af66fc99e Initial load duke parents: diff changeset	765 klassOop updated_klass;
a61af66fc99e Initial load duke parents: diff changeset	766 if (PSParallelCompact::should_update_klass(old_klass)) {
a61af66fc99e Initial load duke parents: diff changeset	767 updated_klass = (klassOop) calc_new_pointer(old_klass);
a61af66fc99e Initial load duke parents: diff changeset	768 } else {
a61af66fc99e Initial load duke parents: diff changeset	769 updated_klass = old_klass;
a61af66fc99e Initial load duke parents: diff changeset	770 }
a61af66fc99e Initial load duke parents: diff changeset	771
a61af66fc99e Initial load duke parents: diff changeset	772 return updated_klass;
a61af66fc99e Initial load duke parents: diff changeset	773 }
a61af66fc99e Initial load duke parents: diff changeset	774
a61af66fc99e Initial load duke parents: diff changeset	775 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	776 void ParallelCompactData::verify_clear(const PSVirtualSpace* vspace)
a61af66fc99e Initial load duke parents: diff changeset	777 {
a61af66fc99e Initial load duke parents: diff changeset	778 const size_t* const beg = (const size_t*)vspace->committed_low_addr();
a61af66fc99e Initial load duke parents: diff changeset	779 const size_t* const end = (const size_t*)vspace->committed_high_addr();
a61af66fc99e Initial load duke parents: diff changeset	780 for (const size_t* p = beg; p < end; ++p) {
a61af66fc99e Initial load duke parents: diff changeset	781 assert(*p == 0, "not zero");
a61af66fc99e Initial load duke parents: diff changeset	782 }
a61af66fc99e Initial load duke parents: diff changeset	783 }
a61af66fc99e Initial load duke parents: diff changeset	784
a61af66fc99e Initial load duke parents: diff changeset	785 void ParallelCompactData::verify_clear()
a61af66fc99e Initial load duke parents: diff changeset	786 {
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	787 verify_clear(_region_vspace);
0 a61af66fc99e Initial load duke parents: diff changeset	788 }
a61af66fc99e Initial load duke parents: diff changeset	789 #endif // #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	790
a61af66fc99e Initial load duke parents: diff changeset	791 #ifdef NOT_PRODUCT
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	792 ParallelCompactData::RegionData* debug_region(size_t region_index) {
0 a61af66fc99e Initial load duke parents: diff changeset	793 ParallelCompactData& sd = PSParallelCompact::summary_data();
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	794 return sd.region(region_index);
0 a61af66fc99e Initial load duke parents: diff changeset	795 }
a61af66fc99e Initial load duke parents: diff changeset	796 #endif
a61af66fc99e Initial load duke parents: diff changeset	797
a61af66fc99e Initial load duke parents: diff changeset	798 elapsedTimer PSParallelCompact::_accumulated_time;
a61af66fc99e Initial load duke parents: diff changeset	799 unsigned int PSParallelCompact::_total_invocations = 0;
a61af66fc99e Initial load duke parents: diff changeset	800 unsigned int PSParallelCompact::_maximum_compaction_gc_num = 0;
a61af66fc99e Initial load duke parents: diff changeset	801 jlong PSParallelCompact::_time_of_last_gc = 0;
a61af66fc99e Initial load duke parents: diff changeset	802 CollectorCounters* PSParallelCompact::_counters = NULL;
a61af66fc99e Initial load duke parents: diff changeset	803 ParMarkBitMap PSParallelCompact::_mark_bitmap;
a61af66fc99e Initial load duke parents: diff changeset	804 ParallelCompactData PSParallelCompact::_summary_data;
a61af66fc99e Initial load duke parents: diff changeset	805
a61af66fc99e Initial load duke parents: diff changeset	806 PSParallelCompact::IsAliveClosure PSParallelCompact::_is_alive_closure;
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 79 diff changeset	807
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 79 diff changeset	808 void PSParallelCompact::IsAliveClosure::do_object(oop p) { ShouldNotReachHere(); }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 79 diff changeset	809 bool PSParallelCompact::IsAliveClosure::do_object_b(oop p) { return mark_bitmap()->is_marked(p); }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 79 diff changeset	810
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 79 diff changeset	811 void PSParallelCompact::KeepAliveClosure::do_oop(oop* p) { PSParallelCompact::KeepAliveClosure::do_oop_work(p); }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 79 diff changeset	812 void PSParallelCompact::KeepAliveClosure::do_oop(narrowOop* p) { PSParallelCompact::KeepAliveClosure::do_oop_work(p); }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 79 diff changeset	813
0 a61af66fc99e Initial load duke parents: diff changeset	814 PSParallelCompact::AdjustPointerClosure PSParallelCompact::_adjust_root_pointer_closure(true);
a61af66fc99e Initial load duke parents: diff changeset	815 PSParallelCompact::AdjustPointerClosure PSParallelCompact::_adjust_pointer_closure(false);
a61af66fc99e Initial load duke parents: diff changeset	816
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 79 diff changeset	817 void PSParallelCompact::AdjustPointerClosure::do_oop(oop* p) { adjust_pointer(p, _is_root); }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 79 diff changeset	818 void PSParallelCompact::AdjustPointerClosure::do_oop(narrowOop* p) { adjust_pointer(p, _is_root); }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 79 diff changeset	819
1311 2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 997 diff changeset	820 void PSParallelCompact::FollowStackClosure::do_void() { _compaction_manager->follow_marking_stacks(); }
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 79 diff changeset	821
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 79 diff changeset	822 void PSParallelCompact::MarkAndPushClosure::do_oop(oop* p) { mark_and_push(_compaction_manager, p); }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 79 diff changeset	823 void PSParallelCompact::MarkAndPushClosure::do_oop(narrowOop* p) { mark_and_push(_compaction_manager, p); }
0 a61af66fc99e Initial load duke parents: diff changeset	824
a61af66fc99e Initial load duke parents: diff changeset	825 void PSParallelCompact::post_initialize() {
a61af66fc99e Initial load duke parents: diff changeset	826 ParallelScavengeHeap* heap = gc_heap();
a61af66fc99e Initial load duke parents: diff changeset	827 assert(heap->kind() == CollectedHeap::ParallelScavengeHeap, "Sanity");
a61af66fc99e Initial load duke parents: diff changeset	828
a61af66fc99e Initial load duke parents: diff changeset	829 MemRegion mr = heap->reserved_region();
2369 92da084fefc9 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads ysr parents: 2177 diff changeset	830 _ref_processor =
92da084fefc9 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads ysr parents: 2177 diff changeset	831 new ReferenceProcessor(mr, // span
92da084fefc9 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads ysr parents: 2177 diff changeset	832 ParallelRefProcEnabled && (ParallelGCThreads > 1), // mt processing
92da084fefc9 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads ysr parents: 2177 diff changeset	833 (int) ParallelGCThreads, // mt processing degree
92da084fefc9 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads ysr parents: 2177 diff changeset	834 true, // mt discovery
92da084fefc9 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads ysr parents: 2177 diff changeset	835 (int) ParallelGCThreads, // mt discovery degree
92da084fefc9 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads ysr parents: 2177 diff changeset	836 true, // atomic_discovery
92da084fefc9 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads ysr parents: 2177 diff changeset	837 &_is_alive_closure, // non-header is alive closure
92da084fefc9 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads ysr parents: 2177 diff changeset	838 false); // write barrier for next field updates
0 a61af66fc99e Initial load duke parents: diff changeset	839 _counters = new CollectorCounters("PSParallelCompact", 1);
a61af66fc99e Initial load duke parents: diff changeset	840
a61af66fc99e Initial load duke parents: diff changeset	841 // Initialize static fields in ParCompactionManager.
a61af66fc99e Initial load duke parents: diff changeset	842 ParCompactionManager::initialize(mark_bitmap());
a61af66fc99e Initial load duke parents: diff changeset	843 }
a61af66fc99e Initial load duke parents: diff changeset	844
a61af66fc99e Initial load duke parents: diff changeset	845 bool PSParallelCompact::initialize() {
a61af66fc99e Initial load duke parents: diff changeset	846 ParallelScavengeHeap* heap = gc_heap();
a61af66fc99e Initial load duke parents: diff changeset	847 assert(heap->kind() == CollectedHeap::ParallelScavengeHeap, "Sanity");
a61af66fc99e Initial load duke parents: diff changeset	848 MemRegion mr = heap->reserved_region();
a61af66fc99e Initial load duke parents: diff changeset	849
a61af66fc99e Initial load duke parents: diff changeset	850 // Was the old gen get allocated successfully?
a61af66fc99e Initial load duke parents: diff changeset	851 if (!heap->old_gen()->is_allocated()) {
a61af66fc99e Initial load duke parents: diff changeset	852 return false;
a61af66fc99e Initial load duke parents: diff changeset	853 }
a61af66fc99e Initial load duke parents: diff changeset	854
a61af66fc99e Initial load duke parents: diff changeset	855 initialize_space_info();
a61af66fc99e Initial load duke parents: diff changeset	856 initialize_dead_wood_limiter();
a61af66fc99e Initial load duke parents: diff changeset	857
a61af66fc99e Initial load duke parents: diff changeset	858 if (!_mark_bitmap.initialize(mr)) {
a61af66fc99e Initial load duke parents: diff changeset	859 vm_shutdown_during_initialization("Unable to allocate bit map for "
a61af66fc99e Initial load duke parents: diff changeset	860 "parallel garbage collection for the requested heap size.");
a61af66fc99e Initial load duke parents: diff changeset	861 return false;
a61af66fc99e Initial load duke parents: diff changeset	862 }
a61af66fc99e Initial load duke parents: diff changeset	863
a61af66fc99e Initial load duke parents: diff changeset	864 if (!_summary_data.initialize(mr)) {
a61af66fc99e Initial load duke parents: diff changeset	865 vm_shutdown_during_initialization("Unable to allocate tables for "
a61af66fc99e Initial load duke parents: diff changeset	866 "parallel garbage collection for the requested heap size.");
a61af66fc99e Initial load duke parents: diff changeset	867 return false;
a61af66fc99e Initial load duke parents: diff changeset	868 }
a61af66fc99e Initial load duke parents: diff changeset	869
a61af66fc99e Initial load duke parents: diff changeset	870 return true;
a61af66fc99e Initial load duke parents: diff changeset	871 }
a61af66fc99e Initial load duke parents: diff changeset	872
a61af66fc99e Initial load duke parents: diff changeset	873 void PSParallelCompact::initialize_space_info()
a61af66fc99e Initial load duke parents: diff changeset	874 {
a61af66fc99e Initial load duke parents: diff changeset	875 memset(&_space_info, 0, sizeof(_space_info));
a61af66fc99e Initial load duke parents: diff changeset	876
a61af66fc99e Initial load duke parents: diff changeset	877 ParallelScavengeHeap* heap = gc_heap();
a61af66fc99e Initial load duke parents: diff changeset	878 PSYoungGen* young_gen = heap->young_gen();
a61af66fc99e Initial load duke parents: diff changeset	879 MutableSpace* perm_space = heap->perm_gen()->object_space();
a61af66fc99e Initial load duke parents: diff changeset	880
a61af66fc99e Initial load duke parents: diff changeset	881 _space_info[perm_space_id].set_space(perm_space);
a61af66fc99e Initial load duke parents: diff changeset	882 _space_info[old_space_id].set_space(heap->old_gen()->object_space());
a61af66fc99e Initial load duke parents: diff changeset	883 _space_info[eden_space_id].set_space(young_gen->eden_space());
a61af66fc99e Initial load duke parents: diff changeset	884 _space_info[from_space_id].set_space(young_gen->from_space());
a61af66fc99e Initial load duke parents: diff changeset	885 _space_info[to_space_id].set_space(young_gen->to_space());
a61af66fc99e Initial load duke parents: diff changeset	886
a61af66fc99e Initial load duke parents: diff changeset	887 _space_info[perm_space_id].set_start_array(heap->perm_gen()->start_array());
a61af66fc99e Initial load duke parents: diff changeset	888 _space_info[old_space_id].set_start_array(heap->old_gen()->start_array());
a61af66fc99e Initial load duke parents: diff changeset	889
a61af66fc99e Initial load duke parents: diff changeset	890 _space_info[perm_space_id].set_min_dense_prefix(perm_space->top());
a61af66fc99e Initial load duke parents: diff changeset	891 if (TraceParallelOldGCDensePrefix) {
a61af66fc99e Initial load duke parents: diff changeset	892 tty->print_cr("perm min_dense_prefix=" PTR_FORMAT,
a61af66fc99e Initial load duke parents: diff changeset	893 _space_info[perm_space_id].min_dense_prefix());
a61af66fc99e Initial load duke parents: diff changeset	894 }
a61af66fc99e Initial load duke parents: diff changeset	895 }
a61af66fc99e Initial load duke parents: diff changeset	896
a61af66fc99e Initial load duke parents: diff changeset	897 void PSParallelCompact::initialize_dead_wood_limiter()
a61af66fc99e Initial load duke parents: diff changeset	898 {
a61af66fc99e Initial load duke parents: diff changeset	899 const size_t max = 100;
a61af66fc99e Initial load duke parents: diff changeset	900 _dwl_mean = double(MIN2(ParallelOldDeadWoodLimiterMean, max)) / 100.0;
a61af66fc99e Initial load duke parents: diff changeset	901 _dwl_std_dev = double(MIN2(ParallelOldDeadWoodLimiterStdDev, max)) / 100.0;
a61af66fc99e Initial load duke parents: diff changeset	902 _dwl_first_term = 1.0 / (sqrt(2.0 * M_PI) * _dwl_std_dev);
a61af66fc99e Initial load duke parents: diff changeset	903 DEBUG_ONLY(_dwl_initialized = true;)
a61af66fc99e Initial load duke parents: diff changeset	904 _dwl_adjustment = normal_distribution(1.0);
a61af66fc99e Initial load duke parents: diff changeset	905 }
a61af66fc99e Initial load duke parents: diff changeset	906
a61af66fc99e Initial load duke parents: diff changeset	907 // Simple class for storing info about the heap at the start of GC, to be used
a61af66fc99e Initial load duke parents: diff changeset	908 // after GC for comparison/printing.
a61af66fc99e Initial load duke parents: diff changeset	909 class PreGCValues {
a61af66fc99e Initial load duke parents: diff changeset	910 public:
a61af66fc99e Initial load duke parents: diff changeset	911 PreGCValues() { }
a61af66fc99e Initial load duke parents: diff changeset	912 PreGCValues(ParallelScavengeHeap* heap) { fill(heap); }
a61af66fc99e Initial load duke parents: diff changeset	913
a61af66fc99e Initial load duke parents: diff changeset	914 void fill(ParallelScavengeHeap* heap) {
a61af66fc99e Initial load duke parents: diff changeset	915 _heap_used = heap->used();
a61af66fc99e Initial load duke parents: diff changeset	916 _young_gen_used = heap->young_gen()->used_in_bytes();
a61af66fc99e Initial load duke parents: diff changeset	917 _old_gen_used = heap->old_gen()->used_in_bytes();
a61af66fc99e Initial load duke parents: diff changeset	918 _perm_gen_used = heap->perm_gen()->used_in_bytes();
a61af66fc99e Initial load duke parents: diff changeset	919 };
a61af66fc99e Initial load duke parents: diff changeset	920
a61af66fc99e Initial load duke parents: diff changeset	921 size_t heap_used() const { return _heap_used; }
a61af66fc99e Initial load duke parents: diff changeset	922 size_t young_gen_used() const { return _young_gen_used; }
a61af66fc99e Initial load duke parents: diff changeset	923 size_t old_gen_used() const { return _old_gen_used; }
a61af66fc99e Initial load duke parents: diff changeset	924 size_t perm_gen_used() const { return _perm_gen_used; }
a61af66fc99e Initial load duke parents: diff changeset	925
a61af66fc99e Initial load duke parents: diff changeset	926 private:
a61af66fc99e Initial load duke parents: diff changeset	927 size_t _heap_used;
a61af66fc99e Initial load duke parents: diff changeset	928 size_t _young_gen_used;
a61af66fc99e Initial load duke parents: diff changeset	929 size_t _old_gen_used;
a61af66fc99e Initial load duke parents: diff changeset	930 size_t _perm_gen_used;
a61af66fc99e Initial load duke parents: diff changeset	931 };
a61af66fc99e Initial load duke parents: diff changeset	932
a61af66fc99e Initial load duke parents: diff changeset	933 void
a61af66fc99e Initial load duke parents: diff changeset	934 PSParallelCompact::clear_data_covering_space(SpaceId id)
a61af66fc99e Initial load duke parents: diff changeset	935 {
a61af66fc99e Initial load duke parents: diff changeset	936 // At this point, top is the value before GC, new_top() is the value that will
a61af66fc99e Initial load duke parents: diff changeset	937 // be set at the end of GC. The marking bitmap is cleared to top; nothing
a61af66fc99e Initial load duke parents: diff changeset	938 // should be marked above top. The summary data is cleared to the larger of
a61af66fc99e Initial load duke parents: diff changeset	939 // top & new_top.
a61af66fc99e Initial load duke parents: diff changeset	940 MutableSpace* const space = _space_info[id].space();
a61af66fc99e Initial load duke parents: diff changeset	941 HeapWord* const bot = space->bottom();
a61af66fc99e Initial load duke parents: diff changeset	942 HeapWord* const top = space->top();
a61af66fc99e Initial load duke parents: diff changeset	943 HeapWord* const max_top = MAX2(top, _space_info[id].new_top());
a61af66fc99e Initial load duke parents: diff changeset	944
a61af66fc99e Initial load duke parents: diff changeset	945 const idx_t beg_bit = _mark_bitmap.addr_to_bit(bot);
a61af66fc99e Initial load duke parents: diff changeset	946 const idx_t end_bit = BitMap::word_align_up(_mark_bitmap.addr_to_bit(top));
a61af66fc99e Initial load duke parents: diff changeset	947 _mark_bitmap.clear_range(beg_bit, end_bit);
a61af66fc99e Initial load duke parents: diff changeset	948
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	949 const size_t beg_region = _summary_data.addr_to_region_idx(bot);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	950 const size_t end_region =
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	951 _summary_data.addr_to_region_idx(_summary_data.region_align_up(max_top));
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	952 _summary_data.clear_range(beg_region, end_region);
482 7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	953
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	954 // Clear the data used to 'split' regions.
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	955 SplitInfo& split_info = _space_info[id].split_info();
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	956 if (split_info.is_valid()) {
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	957 split_info.clear();
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	958 }
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	959 DEBUG_ONLY(split_info.verify_clear();)
0 a61af66fc99e Initial load duke parents: diff changeset	960 }
a61af66fc99e Initial load duke parents: diff changeset	961
a61af66fc99e Initial load duke parents: diff changeset	962 void PSParallelCompact::pre_compact(PreGCValues* pre_gc_values)
a61af66fc99e Initial load duke parents: diff changeset	963 {
a61af66fc99e Initial load duke parents: diff changeset	964 // Update the from & to space pointers in space_info, since they are swapped
a61af66fc99e Initial load duke parents: diff changeset	965 // at each young gen gc. Do the update unconditionally (even though a
a61af66fc99e Initial load duke parents: diff changeset	966 // promotion failure does not swap spaces) because an unknown number of minor
a61af66fc99e Initial load duke parents: diff changeset	967 // collections will have swapped the spaces an unknown number of times.
a61af66fc99e Initial load duke parents: diff changeset	968 TraceTime tm("pre compact", print_phases(), true, gclog_or_tty);
a61af66fc99e Initial load duke parents: diff changeset	969 ParallelScavengeHeap* heap = gc_heap();
a61af66fc99e Initial load duke parents: diff changeset	970 _space_info[from_space_id].set_space(heap->young_gen()->from_space());
a61af66fc99e Initial load duke parents: diff changeset	971 _space_info[to_space_id].set_space(heap->young_gen()->to_space());
a61af66fc99e Initial load duke parents: diff changeset	972
a61af66fc99e Initial load duke parents: diff changeset	973 pre_gc_values->fill(heap);
a61af66fc99e Initial load duke parents: diff changeset	974
a61af66fc99e Initial load duke parents: diff changeset	975 ParCompactionManager::reset();
a61af66fc99e Initial load duke parents: diff changeset	976 NOT_PRODUCT(_mark_bitmap.reset_counters());
a61af66fc99e Initial load duke parents: diff changeset	977 DEBUG_ONLY(add_obj_count = add_obj_size = 0;)
a61af66fc99e Initial load duke parents: diff changeset	978 DEBUG_ONLY(mark_bitmap_count = mark_bitmap_size = 0;)
a61af66fc99e Initial load duke parents: diff changeset	979
a61af66fc99e Initial load duke parents: diff changeset	980 // Increment the invocation count
139 c0492d52d55b 6539517: CR 6186200 should be extended to perm gen allocation to prevent spurious OOM's from perm gen apetrusenko parents: 0 diff changeset	981 heap->increment_total_collections(true);
0 a61af66fc99e Initial load duke parents: diff changeset	982
a61af66fc99e Initial load duke parents: diff changeset	983 // We need to track unique mark sweep invocations as well.
a61af66fc99e Initial load duke parents: diff changeset	984 _total_invocations++;
a61af66fc99e Initial load duke parents: diff changeset	985
a61af66fc99e Initial load duke parents: diff changeset	986 if (PrintHeapAtGC) {
a61af66fc99e Initial load duke parents: diff changeset	987 Universe::print_heap_before_gc();
a61af66fc99e Initial load duke parents: diff changeset	988 }
a61af66fc99e Initial load duke parents: diff changeset	989
a61af66fc99e Initial load duke parents: diff changeset	990 // Fill in TLABs
a61af66fc99e Initial load duke parents: diff changeset	991 heap->accumulate_statistics_all_tlabs();
a61af66fc99e Initial load duke parents: diff changeset	992 heap->ensure_parsability(true); // retire TLABs
a61af66fc99e Initial load duke parents: diff changeset	993
a61af66fc99e Initial load duke parents: diff changeset	994 if (VerifyBeforeGC && heap->total_collections() >= VerifyGCStartAt) {
a61af66fc99e Initial load duke parents: diff changeset	995 HandleMark hm; // Discard invalid handles created during verification
a61af66fc99e Initial load duke parents: diff changeset	996 gclog_or_tty->print(" VerifyBeforeGC:");
a61af66fc99e Initial load duke parents: diff changeset	997 Universe::verify(true);
a61af66fc99e Initial load duke parents: diff changeset	998 }
a61af66fc99e Initial load duke parents: diff changeset	999
a61af66fc99e Initial load duke parents: diff changeset	1000 // Verify object start arrays
a61af66fc99e Initial load duke parents: diff changeset	1001 if (VerifyObjectStartArray &&
a61af66fc99e Initial load duke parents: diff changeset	1002 VerifyBeforeGC) {
a61af66fc99e Initial load duke parents: diff changeset	1003 heap->old_gen()->verify_object_start_array();
a61af66fc99e Initial load duke parents: diff changeset	1004 heap->perm_gen()->verify_object_start_array();
a61af66fc99e Initial load duke parents: diff changeset	1005 }
a61af66fc99e Initial load duke parents: diff changeset	1006
a61af66fc99e Initial load duke parents: diff changeset	1007 DEBUG_ONLY(mark_bitmap()->verify_clear();)
a61af66fc99e Initial load duke parents: diff changeset	1008 DEBUG_ONLY(summary_data().verify_clear();)
210 05712c37c828 6676016: ParallelOldGC leaks memory jcoomes parents: 142 diff changeset	1009
05712c37c828 6676016: ParallelOldGC leaks memory jcoomes parents: 142 diff changeset	1010 // Have worker threads release resources the next time they run a task.
05712c37c828 6676016: ParallelOldGC leaks memory jcoomes parents: 142 diff changeset	1011 gc_task_manager()->release_all_resources();
0 a61af66fc99e Initial load duke parents: diff changeset	1012 }
a61af66fc99e Initial load duke parents: diff changeset	1013
a61af66fc99e Initial load duke parents: diff changeset	1014 void PSParallelCompact::post_compact()
a61af66fc99e Initial load duke parents: diff changeset	1015 {
a61af66fc99e Initial load duke parents: diff changeset	1016 TraceTime tm("post compact", print_phases(), true, gclog_or_tty);
a61af66fc99e Initial load duke parents: diff changeset	1017
a61af66fc99e Initial load duke parents: diff changeset	1018 for (unsigned int id = perm_space_id; id < last_space_id; ++id) {
482 7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1019 // Clear the marking bitmap, summary data and split info.
0 a61af66fc99e Initial load duke parents: diff changeset	1020 clear_data_covering_space(SpaceId(id));
482 7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1021 // Update top(). Must be done after clearing the bitmap and summary data.
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1022 _space_info[id].publish_new_top();
0 a61af66fc99e Initial load duke parents: diff changeset	1023 }
a61af66fc99e Initial load duke parents: diff changeset	1024
a61af66fc99e Initial load duke parents: diff changeset	1025 MutableSpace* const eden_space = _space_info[eden_space_id].space();
a61af66fc99e Initial load duke parents: diff changeset	1026 MutableSpace* const from_space = _space_info[from_space_id].space();
a61af66fc99e Initial load duke parents: diff changeset	1027 MutableSpace* const to_space = _space_info[to_space_id].space();
a61af66fc99e Initial load duke parents: diff changeset	1028
a61af66fc99e Initial load duke parents: diff changeset	1029 ParallelScavengeHeap* heap = gc_heap();
a61af66fc99e Initial load duke parents: diff changeset	1030 bool eden_empty = eden_space->is_empty();
a61af66fc99e Initial load duke parents: diff changeset	1031 if (!eden_empty) {
a61af66fc99e Initial load duke parents: diff changeset	1032 eden_empty = absorb_live_data_from_eden(heap->size_policy(),
a61af66fc99e Initial load duke parents: diff changeset	1033 heap->young_gen(), heap->old_gen());
a61af66fc99e Initial load duke parents: diff changeset	1034 }
a61af66fc99e Initial load duke parents: diff changeset	1035
a61af66fc99e Initial load duke parents: diff changeset	1036 // Update heap occupancy information which is used as input to the soft ref
a61af66fc99e Initial load duke parents: diff changeset	1037 // clearing policy at the next gc.
a61af66fc99e Initial load duke parents: diff changeset	1038 Universe::update_heap_info_at_gc();
a61af66fc99e Initial load duke parents: diff changeset	1039
a61af66fc99e Initial load duke parents: diff changeset	1040 bool young_gen_empty = eden_empty && from_space->is_empty() &&
a61af66fc99e Initial load duke parents: diff changeset	1041 to_space->is_empty();
a61af66fc99e Initial load duke parents: diff changeset	1042
a61af66fc99e Initial load duke parents: diff changeset	1043 BarrierSet* bs = heap->barrier_set();
a61af66fc99e Initial load duke parents: diff changeset	1044 if (bs->is_a(BarrierSet::ModRef)) {
a61af66fc99e Initial load duke parents: diff changeset	1045 ModRefBarrierSet* modBS = (ModRefBarrierSet*)bs;
a61af66fc99e Initial load duke parents: diff changeset	1046 MemRegion old_mr = heap->old_gen()->reserved();
a61af66fc99e Initial load duke parents: diff changeset	1047 MemRegion perm_mr = heap->perm_gen()->reserved();
a61af66fc99e Initial load duke parents: diff changeset	1048 assert(perm_mr.end() <= old_mr.start(), "Generations out of order");
a61af66fc99e Initial load duke parents: diff changeset	1049
a61af66fc99e Initial load duke parents: diff changeset	1050 if (young_gen_empty) {
a61af66fc99e Initial load duke parents: diff changeset	1051 modBS->clear(MemRegion(perm_mr.start(), old_mr.end()));
a61af66fc99e Initial load duke parents: diff changeset	1052 } else {
a61af66fc99e Initial load duke parents: diff changeset	1053 modBS->invalidate(MemRegion(perm_mr.start(), old_mr.end()));
a61af66fc99e Initial load duke parents: diff changeset	1054 }
a61af66fc99e Initial load duke parents: diff changeset	1055 }
a61af66fc99e Initial load duke parents: diff changeset	1056
a61af66fc99e Initial load duke parents: diff changeset	1057 Threads::gc_epilogue();
a61af66fc99e Initial load duke parents: diff changeset	1058 CodeCache::gc_epilogue();
2147 9afee0b9fc1d 7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220) kamg parents: 1972 diff changeset	1059 JvmtiExport::gc_epilogue();
0 a61af66fc99e Initial load duke parents: diff changeset	1060
a61af66fc99e Initial load duke parents: diff changeset	1061 COMPILER2_PRESENT(DerivedPointerTable::update_pointers());
a61af66fc99e Initial load duke parents: diff changeset	1062
a61af66fc99e Initial load duke parents: diff changeset	1063 ref_processor()->enqueue_discovered_references(NULL);
a61af66fc99e Initial load duke parents: diff changeset	1064
263 12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 210 diff changeset	1065 if (ZapUnusedHeapArea) {
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 210 diff changeset	1066 heap->gen_mangle_unused_area();
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 210 diff changeset	1067 }
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 210 diff changeset	1068
0 a61af66fc99e Initial load duke parents: diff changeset	1069 // Update time of last GC
a61af66fc99e Initial load duke parents: diff changeset	1070 reset_millis_since_last_gc();
a61af66fc99e Initial load duke parents: diff changeset	1071 }
a61af66fc99e Initial load duke parents: diff changeset	1072
a61af66fc99e Initial load duke parents: diff changeset	1073 HeapWord*
a61af66fc99e Initial load duke parents: diff changeset	1074 PSParallelCompact::compute_dense_prefix_via_density(const SpaceId id,
a61af66fc99e Initial load duke parents: diff changeset	1075 bool maximum_compaction)
a61af66fc99e Initial load duke parents: diff changeset	1076 {
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1077 const size_t region_size = ParallelCompactData::RegionSize;
0 a61af66fc99e Initial load duke parents: diff changeset	1078 const ParallelCompactData& sd = summary_data();
a61af66fc99e Initial load duke parents: diff changeset	1079
a61af66fc99e Initial load duke parents: diff changeset	1080 const MutableSpace* const space = _space_info[id].space();
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1081 HeapWord* const top_aligned_up = sd.region_align_up(space->top());
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1082 const RegionData* const beg_cp = sd.addr_to_region_ptr(space->bottom());
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1083 const RegionData* const end_cp = sd.addr_to_region_ptr(top_aligned_up);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1084
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1085 // Skip full regions at the beginning of the space--they are necessarily part
0 a61af66fc99e Initial load duke parents: diff changeset	1086 // of the dense prefix.
a61af66fc99e Initial load duke parents: diff changeset	1087 size_t full_count = 0;
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1088 const RegionData* cp;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1089 for (cp = beg_cp; cp < end_cp && cp->data_size() == region_size; ++cp) {
0 a61af66fc99e Initial load duke parents: diff changeset	1090 ++full_count;
a61af66fc99e Initial load duke parents: diff changeset	1091 }
a61af66fc99e Initial load duke parents: diff changeset	1092
a61af66fc99e Initial load duke parents: diff changeset	1093 assert(total_invocations() >= _maximum_compaction_gc_num, "sanity");
a61af66fc99e Initial load duke parents: diff changeset	1094 const size_t gcs_since_max = total_invocations() - _maximum_compaction_gc_num;
a61af66fc99e Initial load duke parents: diff changeset	1095 const bool interval_ended = gcs_since_max > HeapMaximumCompactionInterval;
a61af66fc99e Initial load duke parents: diff changeset	1096 if (maximum_compaction \|\| cp == end_cp \|\| interval_ended) {
a61af66fc99e Initial load duke parents: diff changeset	1097 _maximum_compaction_gc_num = total_invocations();
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1098 return sd.region_to_addr(cp);
0 a61af66fc99e Initial load duke parents: diff changeset	1099 }
a61af66fc99e Initial load duke parents: diff changeset	1100
a61af66fc99e Initial load duke parents: diff changeset	1101 HeapWord* const new_top = _space_info[id].new_top();
a61af66fc99e Initial load duke parents: diff changeset	1102 const size_t space_live = pointer_delta(new_top, space->bottom());
a61af66fc99e Initial load duke parents: diff changeset	1103 const size_t space_used = space->used_in_words();
a61af66fc99e Initial load duke parents: diff changeset	1104 const size_t space_capacity = space->capacity_in_words();
a61af66fc99e Initial load duke parents: diff changeset	1105
a61af66fc99e Initial load duke parents: diff changeset	1106 const double cur_density = double(space_live) / space_capacity;
a61af66fc99e Initial load duke parents: diff changeset	1107 const double deadwood_density =
a61af66fc99e Initial load duke parents: diff changeset	1108 (1.0 - cur_density) * (1.0 - cur_density) * cur_density * cur_density;
a61af66fc99e Initial load duke parents: diff changeset	1109 const size_t deadwood_goal = size_t(space_capacity * deadwood_density);
a61af66fc99e Initial load duke parents: diff changeset	1110
a61af66fc99e Initial load duke parents: diff changeset	1111 if (TraceParallelOldGCDensePrefix) {
a61af66fc99e Initial load duke parents: diff changeset	1112 tty->print_cr("cur_dens=%5.3f dw_dens=%5.3f dw_goal=" SIZE_FORMAT,
a61af66fc99e Initial load duke parents: diff changeset	1113 cur_density, deadwood_density, deadwood_goal);
a61af66fc99e Initial load duke parents: diff changeset	1114 tty->print_cr("space_live=" SIZE_FORMAT " " "space_used=" SIZE_FORMAT " "
a61af66fc99e Initial load duke parents: diff changeset	1115 "space_cap=" SIZE_FORMAT,
a61af66fc99e Initial load duke parents: diff changeset	1116 space_live, space_used,
a61af66fc99e Initial load duke parents: diff changeset	1117 space_capacity);
a61af66fc99e Initial load duke parents: diff changeset	1118 }
a61af66fc99e Initial load duke parents: diff changeset	1119
a61af66fc99e Initial load duke parents: diff changeset	1120 // XXX - Use binary search?
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1121 HeapWord* dense_prefix = sd.region_to_addr(cp);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1122 const RegionData* full_cp = cp;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1123 const RegionData* const top_cp = sd.addr_to_region_ptr(space->top() - 1);
0 a61af66fc99e Initial load duke parents: diff changeset	1124 while (cp < end_cp) {
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1125 HeapWord* region_destination = cp->destination();
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1126 const size_t cur_deadwood = pointer_delta(dense_prefix, region_destination);
0 a61af66fc99e Initial load duke parents: diff changeset	1127 if (TraceParallelOldGCDensePrefix && Verbose) {
264 15dd2594d08e 6718283: existing uses of _FORMAT_W() were broken by 6521491 jcoomes* parents: 263 diff changeset	1128 tty->print_cr("c#=" SIZE_FORMAT_W(4) " dst=" PTR_FORMAT " "
15dd2594d08e 6718283: existing uses of _FORMAT_W() were broken by 6521491 jcoomes* parents: 263 diff changeset	1129 "dp=" SIZE_FORMAT_W(8) " " "cdw=" SIZE_FORMAT_W(8),
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1130 sd.region(cp), region_destination,
0 a61af66fc99e Initial load duke parents: diff changeset	1131 dense_prefix, cur_deadwood);
a61af66fc99e Initial load duke parents: diff changeset	1132 }
a61af66fc99e Initial load duke parents: diff changeset	1133
a61af66fc99e Initial load duke parents: diff changeset	1134 if (cur_deadwood >= deadwood_goal) {
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1135 // Found the region that has the correct amount of deadwood to the left.
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1136 // This typically occurs after crossing a fairly sparse set of regions, so
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1137 // iterate backwards over those sparse regions, looking for the region
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1138 // that has the lowest density of live objects 'to the right.'
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1139 size_t space_to_left = sd.region(cp) * region_size;
0 a61af66fc99e Initial load duke parents: diff changeset	1140 size_t live_to_left = space_to_left - cur_deadwood;
a61af66fc99e Initial load duke parents: diff changeset	1141 size_t space_to_right = space_capacity - space_to_left;
a61af66fc99e Initial load duke parents: diff changeset	1142 size_t live_to_right = space_live - live_to_left;
a61af66fc99e Initial load duke parents: diff changeset	1143 double density_to_right = double(live_to_right) / space_to_right;
a61af66fc99e Initial load duke parents: diff changeset	1144 while (cp > full_cp) {
a61af66fc99e Initial load duke parents: diff changeset	1145 --cp;
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1146 const size_t prev_region_live_to_right = live_to_right -
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1147 cp->data_size();
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1148 const size_t prev_region_space_to_right = space_to_right + region_size;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1149 double prev_region_density_to_right =
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1150 double(prev_region_live_to_right) / prev_region_space_to_right;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1151 if (density_to_right <= prev_region_density_to_right) {
0 a61af66fc99e Initial load duke parents: diff changeset	1152 return dense_prefix;
a61af66fc99e Initial load duke parents: diff changeset	1153 }
a61af66fc99e Initial load duke parents: diff changeset	1154 if (TraceParallelOldGCDensePrefix && Verbose) {
264 15dd2594d08e 6718283: existing uses of _FORMAT_W() were broken by 6521491 jcoomes* parents: 263 diff changeset	1155 tty->print_cr("backing up from c=" SIZE_FORMAT_W(4) " d2r=%10.8f "
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1156 "pc_d2r=%10.8f", sd.region(cp), density_to_right,
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1157 prev_region_density_to_right);
0 a61af66fc99e Initial load duke parents: diff changeset	1158 }
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1159 dense_prefix -= region_size;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1160 live_to_right = prev_region_live_to_right;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1161 space_to_right = prev_region_space_to_right;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1162 density_to_right = prev_region_density_to_right;
0 a61af66fc99e Initial load duke parents: diff changeset	1163 }
a61af66fc99e Initial load duke parents: diff changeset	1164 return dense_prefix;
a61af66fc99e Initial load duke parents: diff changeset	1165 }
a61af66fc99e Initial load duke parents: diff changeset	1166
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1167 dense_prefix += region_size;
0 a61af66fc99e Initial load duke parents: diff changeset	1168 ++cp;
a61af66fc99e Initial load duke parents: diff changeset	1169 }
a61af66fc99e Initial load duke parents: diff changeset	1170
a61af66fc99e Initial load duke parents: diff changeset	1171 return dense_prefix;
a61af66fc99e Initial load duke parents: diff changeset	1172 }
a61af66fc99e Initial load duke parents: diff changeset	1173
a61af66fc99e Initial load duke parents: diff changeset	1174 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	1175 void PSParallelCompact::print_dense_prefix_stats(const char* const algorithm,
a61af66fc99e Initial load duke parents: diff changeset	1176 const SpaceId id,
a61af66fc99e Initial load duke parents: diff changeset	1177 const bool maximum_compaction,
a61af66fc99e Initial load duke parents: diff changeset	1178 HeapWord* const addr)
a61af66fc99e Initial load duke parents: diff changeset	1179 {
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1180 const size_t region_idx = summary_data().addr_to_region_idx(addr);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1181 RegionData* const cp = summary_data().region(region_idx);
0 a61af66fc99e Initial load duke parents: diff changeset	1182 const MutableSpace* const space = _space_info[id].space();
a61af66fc99e Initial load duke parents: diff changeset	1183 HeapWord* const new_top = _space_info[id].new_top();
a61af66fc99e Initial load duke parents: diff changeset	1184
a61af66fc99e Initial load duke parents: diff changeset	1185 const size_t space_live = pointer_delta(new_top, space->bottom());
a61af66fc99e Initial load duke parents: diff changeset	1186 const size_t dead_to_left = pointer_delta(addr, cp->destination());
a61af66fc99e Initial load duke parents: diff changeset	1187 const size_t space_cap = space->capacity_in_words();
a61af66fc99e Initial load duke parents: diff changeset	1188 const double dead_to_left_pct = double(dead_to_left) / space_cap;
a61af66fc99e Initial load duke parents: diff changeset	1189 const size_t live_to_right = new_top - cp->destination();
a61af66fc99e Initial load duke parents: diff changeset	1190 const size_t dead_to_right = space->top() - addr - live_to_right;
a61af66fc99e Initial load duke parents: diff changeset	1191
264 15dd2594d08e 6718283: existing uses of _FORMAT_W() were broken by 6521491 jcoomes* parents: 263 diff changeset	1192 tty->print_cr("%s=" PTR_FORMAT " dpc=" SIZE_FORMAT_W(5) " "
0 a61af66fc99e Initial load duke parents: diff changeset	1193 "spl=" SIZE_FORMAT " "
a61af66fc99e Initial load duke parents: diff changeset	1194 "d2l=" SIZE_FORMAT " d2l%%=%6.4f "
a61af66fc99e Initial load duke parents: diff changeset	1195 "d2r=" SIZE_FORMAT " l2r=" SIZE_FORMAT
a61af66fc99e Initial load duke parents: diff changeset	1196 " ratio=%10.8f",
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1197 algorithm, addr, region_idx,
0 a61af66fc99e Initial load duke parents: diff changeset	1198 space_live,
a61af66fc99e Initial load duke parents: diff changeset	1199 dead_to_left, dead_to_left_pct,
a61af66fc99e Initial load duke parents: diff changeset	1200 dead_to_right, live_to_right,
a61af66fc99e Initial load duke parents: diff changeset	1201 double(dead_to_right) / live_to_right);
a61af66fc99e Initial load duke parents: diff changeset	1202 }
a61af66fc99e Initial load duke parents: diff changeset	1203 #endif // #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	1204
a61af66fc99e Initial load duke parents: diff changeset	1205 // Return a fraction indicating how much of the generation can be treated as
a61af66fc99e Initial load duke parents: diff changeset	1206 // "dead wood" (i.e., not reclaimed). The function uses a normal distribution
a61af66fc99e Initial load duke parents: diff changeset	1207 // based on the density of live objects in the generation to determine a limit,
a61af66fc99e Initial load duke parents: diff changeset	1208 // which is then adjusted so the return value is min_percent when the density is
a61af66fc99e Initial load duke parents: diff changeset	1209 // 1.
a61af66fc99e Initial load duke parents: diff changeset	1210 //
a61af66fc99e Initial load duke parents: diff changeset	1211 // The following table shows some return values for a different values of the
a61af66fc99e Initial load duke parents: diff changeset	1212 // standard deviation (ParallelOldDeadWoodLimiterStdDev); the mean is 0.5 and
a61af66fc99e Initial load duke parents: diff changeset	1213 // min_percent is 1.
a61af66fc99e Initial load duke parents: diff changeset	1214 //
a61af66fc99e Initial load duke parents: diff changeset	1215 // fraction allowed as dead wood
a61af66fc99e Initial load duke parents: diff changeset	1216 // -----------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	1217 // density std_dev=70 std_dev=75 std_dev=80 std_dev=85 std_dev=90 std_dev=95
a61af66fc99e Initial load duke parents: diff changeset	1218 // ------- ---------- ---------- ---------- ---------- ---------- ----------
a61af66fc99e Initial load duke parents: diff changeset	1219 // 0.00000 0.01000000 0.01000000 0.01000000 0.01000000 0.01000000 0.01000000
a61af66fc99e Initial load duke parents: diff changeset	1220 // 0.05000 0.03193096 0.02836880 0.02550828 0.02319280 0.02130337 0.01974941
a61af66fc99e Initial load duke parents: diff changeset	1221 // 0.10000 0.05247504 0.04547452 0.03988045 0.03537016 0.03170171 0.02869272
a61af66fc99e Initial load duke parents: diff changeset	1222 // 0.15000 0.07135702 0.06111390 0.05296419 0.04641639 0.04110601 0.03676066
a61af66fc99e Initial load duke parents: diff changeset	1223 // 0.20000 0.08831616 0.07509618 0.06461766 0.05622444 0.04943437 0.04388975
a61af66fc99e Initial load duke parents: diff changeset	1224 // 0.25000 0.10311208 0.08724696 0.07471205 0.06469760 0.05661313 0.05002313
a61af66fc99e Initial load duke parents: diff changeset	1225 // 0.30000 0.11553050 0.09741183 0.08313394 0.07175114 0.06257797 0.05511132
a61af66fc99e Initial load duke parents: diff changeset	1226 // 0.35000 0.12538832 0.10545958 0.08978741 0.07731366 0.06727491 0.05911289
a61af66fc99e Initial load duke parents: diff changeset	1227 // 0.40000 0.13253818 0.11128511 0.09459590 0.08132834 0.07066107 0.06199500
a61af66fc99e Initial load duke parents: diff changeset	1228 // 0.45000 0.13687208 0.11481163 0.09750361 0.08375387 0.07270534 0.06373386
a61af66fc99e Initial load duke parents: diff changeset	1229 // 0.50000 0.13832410 0.11599237 0.09847664 0.08456518 0.07338887 0.06431510
a61af66fc99e Initial load duke parents: diff changeset	1230 // 0.55000 0.13687208 0.11481163 0.09750361 0.08375387 0.07270534 0.06373386
a61af66fc99e Initial load duke parents: diff changeset	1231 // 0.60000 0.13253818 0.11128511 0.09459590 0.08132834 0.07066107 0.06199500
a61af66fc99e Initial load duke parents: diff changeset	1232 // 0.65000 0.12538832 0.10545958 0.08978741 0.07731366 0.06727491 0.05911289
a61af66fc99e Initial load duke parents: diff changeset	1233 // 0.70000 0.11553050 0.09741183 0.08313394 0.07175114 0.06257797 0.05511132
a61af66fc99e Initial load duke parents: diff changeset	1234 // 0.75000 0.10311208 0.08724696 0.07471205 0.06469760 0.05661313 0.05002313
a61af66fc99e Initial load duke parents: diff changeset	1235 // 0.80000 0.08831616 0.07509618 0.06461766 0.05622444 0.04943437 0.04388975
a61af66fc99e Initial load duke parents: diff changeset	1236 // 0.85000 0.07135702 0.06111390 0.05296419 0.04641639 0.04110601 0.03676066
a61af66fc99e Initial load duke parents: diff changeset	1237 // 0.90000 0.05247504 0.04547452 0.03988045 0.03537016 0.03170171 0.02869272
a61af66fc99e Initial load duke parents: diff changeset	1238 // 0.95000 0.03193096 0.02836880 0.02550828 0.02319280 0.02130337 0.01974941
a61af66fc99e Initial load duke parents: diff changeset	1239 // 1.00000 0.01000000 0.01000000 0.01000000 0.01000000 0.01000000 0.01000000
a61af66fc99e Initial load duke parents: diff changeset	1240
a61af66fc99e Initial load duke parents: diff changeset	1241 double PSParallelCompact::dead_wood_limiter(double density, size_t min_percent)
a61af66fc99e Initial load duke parents: diff changeset	1242 {
a61af66fc99e Initial load duke parents: diff changeset	1243 assert(_dwl_initialized, "uninitialized");
a61af66fc99e Initial load duke parents: diff changeset	1244
a61af66fc99e Initial load duke parents: diff changeset	1245 // The raw limit is the value of the normal distribution at x = density.
a61af66fc99e Initial load duke parents: diff changeset	1246 const double raw_limit = normal_distribution(density);
a61af66fc99e Initial load duke parents: diff changeset	1247
a61af66fc99e Initial load duke parents: diff changeset	1248 // Adjust the raw limit so it becomes the minimum when the density is 1.
a61af66fc99e Initial load duke parents: diff changeset	1249 //
a61af66fc99e Initial load duke parents: diff changeset	1250 // First subtract the adjustment value (which is simply the precomputed value
a61af66fc99e Initial load duke parents: diff changeset	1251 // normal_distribution(1.0)); this yields a value of 0 when the density is 1.
a61af66fc99e Initial load duke parents: diff changeset	1252 // Then add the minimum value, so the minimum is returned when the density is
a61af66fc99e Initial load duke parents: diff changeset	1253 // 1. Finally, prevent negative values, which occur when the mean is not 0.5.
a61af66fc99e Initial load duke parents: diff changeset	1254 const double min = double(min_percent) / 100.0;
a61af66fc99e Initial load duke parents: diff changeset	1255 const double limit = raw_limit - _dwl_adjustment + min;
a61af66fc99e Initial load duke parents: diff changeset	1256 return MAX2(limit, 0.0);
a61af66fc99e Initial load duke parents: diff changeset	1257 }
a61af66fc99e Initial load duke parents: diff changeset	1258
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1259 ParallelCompactData::RegionData*
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1260 PSParallelCompact::first_dead_space_region(const RegionData* beg,
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1261 const RegionData* end)
0 a61af66fc99e Initial load duke parents: diff changeset	1262 {
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1263 const size_t region_size = ParallelCompactData::RegionSize;
0 a61af66fc99e Initial load duke parents: diff changeset	1264 ParallelCompactData& sd = summary_data();
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1265 size_t left = sd.region(beg);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1266 size_t right = end > beg ? sd.region(end) - 1 : left;
0 a61af66fc99e Initial load duke parents: diff changeset	1267
a61af66fc99e Initial load duke parents: diff changeset	1268 // Binary search.
a61af66fc99e Initial load duke parents: diff changeset	1269 while (left < right) {
a61af66fc99e Initial load duke parents: diff changeset	1270 // Equivalent to (left + right) / 2, but does not overflow.
a61af66fc99e Initial load duke parents: diff changeset	1271 const size_t middle = left + (right - left) / 2;
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1272 RegionData* const middle_ptr = sd.region(middle);
0 a61af66fc99e Initial load duke parents: diff changeset	1273 HeapWord* const dest = middle_ptr->destination();
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1274 HeapWord* const addr = sd.region_to_addr(middle);
0 a61af66fc99e Initial load duke parents: diff changeset	1275 assert(dest != NULL, "sanity");
a61af66fc99e Initial load duke parents: diff changeset	1276 assert(dest <= addr, "must move left");
a61af66fc99e Initial load duke parents: diff changeset	1277
a61af66fc99e Initial load duke parents: diff changeset	1278 if (middle > left && dest < addr) {
a61af66fc99e Initial load duke parents: diff changeset	1279 right = middle - 1;
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1280 } else if (middle < right && middle_ptr->data_size() == region_size) {
0 a61af66fc99e Initial load duke parents: diff changeset	1281 left = middle + 1;
a61af66fc99e Initial load duke parents: diff changeset	1282 } else {
a61af66fc99e Initial load duke parents: diff changeset	1283 return middle_ptr;
a61af66fc99e Initial load duke parents: diff changeset	1284 }
a61af66fc99e Initial load duke parents: diff changeset	1285 }
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1286 return sd.region(left);
0 a61af66fc99e Initial load duke parents: diff changeset	1287 }
a61af66fc99e Initial load duke parents: diff changeset	1288
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1289 ParallelCompactData::RegionData*
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1290 PSParallelCompact::dead_wood_limit_region(const RegionData* beg,
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1291 const RegionData* end,
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1292 size_t dead_words)
0 a61af66fc99e Initial load duke parents: diff changeset	1293 {
a61af66fc99e Initial load duke parents: diff changeset	1294 ParallelCompactData& sd = summary_data();
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1295 size_t left = sd.region(beg);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1296 size_t right = end > beg ? sd.region(end) - 1 : left;
0 a61af66fc99e Initial load duke parents: diff changeset	1297
a61af66fc99e Initial load duke parents: diff changeset	1298 // Binary search.
a61af66fc99e Initial load duke parents: diff changeset	1299 while (left < right) {
a61af66fc99e Initial load duke parents: diff changeset	1300 // Equivalent to (left + right) / 2, but does not overflow.
a61af66fc99e Initial load duke parents: diff changeset	1301 const size_t middle = left + (right - left) / 2;
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1302 RegionData* const middle_ptr = sd.region(middle);
0 a61af66fc99e Initial load duke parents: diff changeset	1303 HeapWord* const dest = middle_ptr->destination();
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1304 HeapWord* const addr = sd.region_to_addr(middle);
0 a61af66fc99e Initial load duke parents: diff changeset	1305 assert(dest != NULL, "sanity");
a61af66fc99e Initial load duke parents: diff changeset	1306 assert(dest <= addr, "must move left");
a61af66fc99e Initial load duke parents: diff changeset	1307
a61af66fc99e Initial load duke parents: diff changeset	1308 const size_t dead_to_left = pointer_delta(addr, dest);
a61af66fc99e Initial load duke parents: diff changeset	1309 if (middle > left && dead_to_left > dead_words) {
a61af66fc99e Initial load duke parents: diff changeset	1310 right = middle - 1;
a61af66fc99e Initial load duke parents: diff changeset	1311 } else if (middle < right && dead_to_left < dead_words) {
a61af66fc99e Initial load duke parents: diff changeset	1312 left = middle + 1;
a61af66fc99e Initial load duke parents: diff changeset	1313 } else {
a61af66fc99e Initial load duke parents: diff changeset	1314 return middle_ptr;
a61af66fc99e Initial load duke parents: diff changeset	1315 }
a61af66fc99e Initial load duke parents: diff changeset	1316 }
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1317 return sd.region(left);
0 a61af66fc99e Initial load duke parents: diff changeset	1318 }
a61af66fc99e Initial load duke parents: diff changeset	1319
a61af66fc99e Initial load duke parents: diff changeset	1320 // The result is valid during the summary phase, after the initial summarization
a61af66fc99e Initial load duke parents: diff changeset	1321 // of each space into itself, and before final summarization.
a61af66fc99e Initial load duke parents: diff changeset	1322 inline double
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1323 PSParallelCompact::reclaimed_ratio(const RegionData* const cp,
0 a61af66fc99e Initial load duke parents: diff changeset	1324 HeapWord* const bottom,
a61af66fc99e Initial load duke parents: diff changeset	1325 HeapWord* const top,
a61af66fc99e Initial load duke parents: diff changeset	1326 HeapWord* const new_top)
a61af66fc99e Initial load duke parents: diff changeset	1327 {
a61af66fc99e Initial load duke parents: diff changeset	1328 ParallelCompactData& sd = summary_data();
a61af66fc99e Initial load duke parents: diff changeset	1329
a61af66fc99e Initial load duke parents: diff changeset	1330 assert(cp != NULL, "sanity");
a61af66fc99e Initial load duke parents: diff changeset	1331 assert(bottom != NULL, "sanity");
a61af66fc99e Initial load duke parents: diff changeset	1332 assert(top != NULL, "sanity");
a61af66fc99e Initial load duke parents: diff changeset	1333 assert(new_top != NULL, "sanity");
a61af66fc99e Initial load duke parents: diff changeset	1334 assert(top >= new_top, "summary data problem?");
a61af66fc99e Initial load duke parents: diff changeset	1335 assert(new_top > bottom, "space is empty; should not be here");
a61af66fc99e Initial load duke parents: diff changeset	1336 assert(new_top >= cp->destination(), "sanity");
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1337 assert(top >= sd.region_to_addr(cp), "sanity");
0 a61af66fc99e Initial load duke parents: diff changeset	1338
a61af66fc99e Initial load duke parents: diff changeset	1339 HeapWord* const destination = cp->destination();
a61af66fc99e Initial load duke parents: diff changeset	1340 const size_t dense_prefix_live = pointer_delta(destination, bottom);
a61af66fc99e Initial load duke parents: diff changeset	1341 const size_t compacted_region_live = pointer_delta(new_top, destination);
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1342 const size_t compacted_region_used = pointer_delta(top,
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1343 sd.region_to_addr(cp));
0 a61af66fc99e Initial load duke parents: diff changeset	1344 const size_t reclaimable = compacted_region_used - compacted_region_live;
a61af66fc99e Initial load duke parents: diff changeset	1345
a61af66fc99e Initial load duke parents: diff changeset	1346 const double divisor = dense_prefix_live + 1.25 * compacted_region_live;
a61af66fc99e Initial load duke parents: diff changeset	1347 return double(reclaimable) / divisor;
a61af66fc99e Initial load duke parents: diff changeset	1348 }
a61af66fc99e Initial load duke parents: diff changeset	1349
a61af66fc99e Initial load duke parents: diff changeset	1350 // Return the address of the end of the dense prefix, a.k.a. the start of the
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1351 // compacted region. The address is always on a region boundary.
0 a61af66fc99e Initial load duke parents: diff changeset	1352 //
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1353 // Completely full regions at the left are skipped, since no compaction can
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1354 // occur in those regions. Then the maximum amount of dead wood to allow is
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1355 // computed, based on the density (amount live / capacity) of the generation;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1356 // the region with approximately that amount of dead space to the left is
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1357 // identified as the limit region. Regions between the last completely full
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1358 // region and the limit region are scanned and the one that has the best
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1359 // (maximum) reclaimed_ratio() is selected.
0 a61af66fc99e Initial load duke parents: diff changeset	1360 HeapWord*
a61af66fc99e Initial load duke parents: diff changeset	1361 PSParallelCompact::compute_dense_prefix(const SpaceId id,
a61af66fc99e Initial load duke parents: diff changeset	1362 bool maximum_compaction)
a61af66fc99e Initial load duke parents: diff changeset	1363 {
483 0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1364 if (ParallelOldGCSplitALot) {
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1365 if (_space_info[id].dense_prefix() != _space_info[id].space()->bottom()) {
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1366 // The value was chosen to provoke splitting a young gen space; use it.
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1367 return _space_info[id].dense_prefix();
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1368 }
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1369 }
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1370
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1371 const size_t region_size = ParallelCompactData::RegionSize;
0 a61af66fc99e Initial load duke parents: diff changeset	1372 const ParallelCompactData& sd = summary_data();
a61af66fc99e Initial load duke parents: diff changeset	1373
a61af66fc99e Initial load duke parents: diff changeset	1374 const MutableSpace* const space = _space_info[id].space();
a61af66fc99e Initial load duke parents: diff changeset	1375 HeapWord* const top = space->top();
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1376 HeapWord* const top_aligned_up = sd.region_align_up(top);
0 a61af66fc99e Initial load duke parents: diff changeset	1377 HeapWord* const new_top = _space_info[id].new_top();
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1378 HeapWord* const new_top_aligned_up = sd.region_align_up(new_top);
0 a61af66fc99e Initial load duke parents: diff changeset	1379 HeapWord* const bottom = space->bottom();
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1380 const RegionData* const beg_cp = sd.addr_to_region_ptr(bottom);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1381 const RegionData* const top_cp = sd.addr_to_region_ptr(top_aligned_up);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1382 const RegionData* const new_top_cp =
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1383 sd.addr_to_region_ptr(new_top_aligned_up);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1384
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1385 // Skip full regions at the beginning of the space--they are necessarily part
0 a61af66fc99e Initial load duke parents: diff changeset	1386 // of the dense prefix.
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1387 const RegionData* const full_cp = first_dead_space_region(beg_cp, new_top_cp);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1388 assert(full_cp->destination() == sd.region_to_addr(full_cp) \|\|
0 a61af66fc99e Initial load duke parents: diff changeset	1389 space->is_empty(), "no dead space allowed to the left");
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1390 assert(full_cp->data_size() < region_size \|\| full_cp == new_top_cp - 1,
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1391 "region must have dead space");
0 a61af66fc99e Initial load duke parents: diff changeset	1392
a61af66fc99e Initial load duke parents: diff changeset	1393 // The gc number is saved whenever a maximum compaction is done, and used to
a61af66fc99e Initial load duke parents: diff changeset	1394 // determine when the maximum compaction interval has expired. This avoids
a61af66fc99e Initial load duke parents: diff changeset	1395 // successive max compactions for different reasons.
a61af66fc99e Initial load duke parents: diff changeset	1396 assert(total_invocations() >= _maximum_compaction_gc_num, "sanity");
a61af66fc99e Initial load duke parents: diff changeset	1397 const size_t gcs_since_max = total_invocations() - _maximum_compaction_gc_num;
a61af66fc99e Initial load duke parents: diff changeset	1398 const bool interval_ended = gcs_since_max > HeapMaximumCompactionInterval \|\|
a61af66fc99e Initial load duke parents: diff changeset	1399 total_invocations() == HeapFirstMaximumCompactionCount;
a61af66fc99e Initial load duke parents: diff changeset	1400 if (maximum_compaction \|\| full_cp == top_cp \|\| interval_ended) {
a61af66fc99e Initial load duke parents: diff changeset	1401 _maximum_compaction_gc_num = total_invocations();
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1402 return sd.region_to_addr(full_cp);
0 a61af66fc99e Initial load duke parents: diff changeset	1403 }
a61af66fc99e Initial load duke parents: diff changeset	1404
a61af66fc99e Initial load duke parents: diff changeset	1405 const size_t space_live = pointer_delta(new_top, bottom);
a61af66fc99e Initial load duke parents: diff changeset	1406 const size_t space_used = space->used_in_words();
a61af66fc99e Initial load duke parents: diff changeset	1407 const size_t space_capacity = space->capacity_in_words();
a61af66fc99e Initial load duke parents: diff changeset	1408
a61af66fc99e Initial load duke parents: diff changeset	1409 const double density = double(space_live) / double(space_capacity);
a61af66fc99e Initial load duke parents: diff changeset	1410 const size_t min_percent_free =
a61af66fc99e Initial load duke parents: diff changeset	1411 id == perm_space_id ? PermMarkSweepDeadRatio : MarkSweepDeadRatio;
a61af66fc99e Initial load duke parents: diff changeset	1412 const double limiter = dead_wood_limiter(density, min_percent_free);
a61af66fc99e Initial load duke parents: diff changeset	1413 const size_t dead_wood_max = space_used - space_live;
a61af66fc99e Initial load duke parents: diff changeset	1414 const size_t dead_wood_limit = MIN2(size_t(space_capacity * limiter),
a61af66fc99e Initial load duke parents: diff changeset	1415 dead_wood_max);
a61af66fc99e Initial load duke parents: diff changeset	1416
a61af66fc99e Initial load duke parents: diff changeset	1417 if (TraceParallelOldGCDensePrefix) {
a61af66fc99e Initial load duke parents: diff changeset	1418 tty->print_cr("space_live=" SIZE_FORMAT " " "space_used=" SIZE_FORMAT " "
a61af66fc99e Initial load duke parents: diff changeset	1419 "space_cap=" SIZE_FORMAT,
a61af66fc99e Initial load duke parents: diff changeset	1420 space_live, space_used,
a61af66fc99e Initial load duke parents: diff changeset	1421 space_capacity);
a61af66fc99e Initial load duke parents: diff changeset	1422 tty->print_cr("dead_wood_limiter(%6.4f, %d)=%6.4f "
a61af66fc99e Initial load duke parents: diff changeset	1423 "dead_wood_max=" SIZE_FORMAT " dead_wood_limit=" SIZE_FORMAT,
a61af66fc99e Initial load duke parents: diff changeset	1424 density, min_percent_free, limiter,
a61af66fc99e Initial load duke parents: diff changeset	1425 dead_wood_max, dead_wood_limit);
a61af66fc99e Initial load duke parents: diff changeset	1426 }
a61af66fc99e Initial load duke parents: diff changeset	1427
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1428 // Locate the region with the desired amount of dead space to the left.
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1429 const RegionData* const limit_cp =
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1430 dead_wood_limit_region(full_cp, top_cp, dead_wood_limit);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1431
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1432 // Scan from the first region with dead space to the limit region and find the
0 a61af66fc99e Initial load duke parents: diff changeset	1433 // one with the best (largest) reclaimed ratio.
a61af66fc99e Initial load duke parents: diff changeset	1434 double best_ratio = 0.0;
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1435 const RegionData* best_cp = full_cp;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1436 for (const RegionData* cp = full_cp; cp < limit_cp; ++cp) {
0 a61af66fc99e Initial load duke parents: diff changeset	1437 double tmp_ratio = reclaimed_ratio(cp, bottom, top, new_top);
a61af66fc99e Initial load duke parents: diff changeset	1438 if (tmp_ratio > best_ratio) {
a61af66fc99e Initial load duke parents: diff changeset	1439 best_cp = cp;
a61af66fc99e Initial load duke parents: diff changeset	1440 best_ratio = tmp_ratio;
a61af66fc99e Initial load duke parents: diff changeset	1441 }
a61af66fc99e Initial load duke parents: diff changeset	1442 }
a61af66fc99e Initial load duke parents: diff changeset	1443
a61af66fc99e Initial load duke parents: diff changeset	1444 #if 0
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1445 // Something to consider: if the region with the best ratio is 'close to' the
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1446 // first region w/free space, choose the first region with free space
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1447 // ("first-free"). The first-free region is usually near the start of the
0 a61af66fc99e Initial load duke parents: diff changeset	1448 // heap, which means we are copying most of the heap already, so copy a bit
a61af66fc99e Initial load duke parents: diff changeset	1449 // more to get complete compaction.
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1450 if (pointer_delta(best_cp, full_cp, sizeof(RegionData)) < 4) {
0 a61af66fc99e Initial load duke parents: diff changeset	1451 _maximum_compaction_gc_num = total_invocations();
a61af66fc99e Initial load duke parents: diff changeset	1452 best_cp = full_cp;
a61af66fc99e Initial load duke parents: diff changeset	1453 }
a61af66fc99e Initial load duke parents: diff changeset	1454 #endif // #if 0
a61af66fc99e Initial load duke parents: diff changeset	1455
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1456 return sd.region_to_addr(best_cp);
0 a61af66fc99e Initial load duke parents: diff changeset	1457 }
a61af66fc99e Initial load duke parents: diff changeset	1458
483 0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1459 #ifndef PRODUCT
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1460 void
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1461 PSParallelCompact::fill_with_live_objects(SpaceId id, HeapWord* const start,
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1462 size_t words)
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1463 {
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1464 if (TraceParallelOldGCSummaryPhase) {
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1465 tty->print_cr("fill_with_live_objects [" PTR_FORMAT " " PTR_FORMAT ") "
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1466 SIZE_FORMAT, start, start + words, words);
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1467 }
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1468
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1469 ObjectStartArray* const start_array = _space_info[id].start_array();
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1470 CollectedHeap::fill_with_objects(start, words);
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1471 for (HeapWord* p = start; p < start + words; p += oop(p)->size()) {
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1472 _mark_bitmap.mark_obj(p, words);
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1473 _summary_data.add_obj(p, words);
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1474 start_array->allocate_block(p);
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1475 }
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1476 }
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1477
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1478 void
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1479 PSParallelCompact::summarize_new_objects(SpaceId id, HeapWord* start)
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1480 {
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1481 ParallelCompactData& sd = summary_data();
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1482 MutableSpace* space = _space_info[id].space();
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1483
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1484 // Find the source and destination start addresses.
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1485 HeapWord* const src_addr = sd.region_align_down(start);
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1486 HeapWord* dst_addr;
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1487 if (src_addr < start) {
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1488 dst_addr = sd.addr_to_region_ptr(src_addr)->destination();
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1489 } else if (src_addr > space->bottom()) {
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1490 // The start (the original top() value) is aligned to a region boundary so
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1491 // the associated region does not have a destination. Compute the
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1492 // destination from the previous region.
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1493 RegionData* const cp = sd.addr_to_region_ptr(src_addr) - 1;
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1494 dst_addr = cp->destination() + cp->data_size();
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1495 } else {
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1496 // Filling the entire space.
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1497 dst_addr = space->bottom();
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1498 }
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1499 assert(dst_addr != NULL, "sanity");
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1500
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1501 // Update the summary data.
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1502 bool result = _summary_data.summarize(_space_info[id].split_info(),
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1503 src_addr, space->top(), NULL,
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1504 dst_addr, space->end(),
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1505 _space_info[id].new_top_addr());
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1506 assert(result, "should not fail: bad filler object size");
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1507 }
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1508
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1509 void
496 b27c885f75f9 6786188: par compact - "SplitALot" stress mode should fill to_space jcoomes parents: 495 diff changeset	1510 PSParallelCompact::provoke_split_fill_survivor(SpaceId id)
b27c885f75f9 6786188: par compact - "SplitALot" stress mode should fill to_space jcoomes parents: 495 diff changeset	1511 {
b27c885f75f9 6786188: par compact - "SplitALot" stress mode should fill to_space jcoomes parents: 495 diff changeset	1512 if (total_invocations() % (ParallelOldGCSplitInterval * 3) != 0) {
b27c885f75f9 6786188: par compact - "SplitALot" stress mode should fill to_space jcoomes parents: 495 diff changeset	1513 return;
b27c885f75f9 6786188: par compact - "SplitALot" stress mode should fill to_space jcoomes parents: 495 diff changeset	1514 }
b27c885f75f9 6786188: par compact - "SplitALot" stress mode should fill to_space jcoomes parents: 495 diff changeset	1515
b27c885f75f9 6786188: par compact - "SplitALot" stress mode should fill to_space jcoomes parents: 495 diff changeset	1516 MutableSpace* const space = _space_info[id].space();
b27c885f75f9 6786188: par compact - "SplitALot" stress mode should fill to_space jcoomes parents: 495 diff changeset	1517 if (space->is_empty()) {
b27c885f75f9 6786188: par compact - "SplitALot" stress mode should fill to_space jcoomes parents: 495 diff changeset	1518 HeapWord* b = space->bottom();
b27c885f75f9 6786188: par compact - "SplitALot" stress mode should fill to_space jcoomes parents: 495 diff changeset	1519 HeapWord* t = b + space->capacity_in_words() / 2;
b27c885f75f9 6786188: par compact - "SplitALot" stress mode should fill to_space jcoomes parents: 495 diff changeset	1520 space->set_top(t);
b27c885f75f9 6786188: par compact - "SplitALot" stress mode should fill to_space jcoomes parents: 495 diff changeset	1521 if (ZapUnusedHeapArea) {
b27c885f75f9 6786188: par compact - "SplitALot" stress mode should fill to_space jcoomes parents: 495 diff changeset	1522 space->set_top_for_allocations();
b27c885f75f9 6786188: par compact - "SplitALot" stress mode should fill to_space jcoomes parents: 495 diff changeset	1523 }
b27c885f75f9 6786188: par compact - "SplitALot" stress mode should fill to_space jcoomes parents: 495 diff changeset	1524
1571 2d127394260e 6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb kvn parents: 1489 diff changeset	1525 size_t min_size = CollectedHeap::min_fill_size();
2d127394260e 6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb kvn parents: 1489 diff changeset	1526 size_t obj_len = min_size;
496 b27c885f75f9 6786188: par compact - "SplitALot" stress mode should fill to_space jcoomes parents: 495 diff changeset	1527 while (b + obj_len <= t) {
b27c885f75f9 6786188: par compact - "SplitALot" stress mode should fill to_space jcoomes parents: 495 diff changeset	1528 CollectedHeap::fill_with_object(b, obj_len);
b27c885f75f9 6786188: par compact - "SplitALot" stress mode should fill to_space jcoomes parents: 495 diff changeset	1529 mark_bitmap()->mark_obj(b, obj_len);
b27c885f75f9 6786188: par compact - "SplitALot" stress mode should fill to_space jcoomes parents: 495 diff changeset	1530 summary_data().add_obj(b, obj_len);
b27c885f75f9 6786188: par compact - "SplitALot" stress mode should fill to_space jcoomes parents: 495 diff changeset	1531 b += obj_len;
1571 2d127394260e 6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb kvn parents: 1489 diff changeset	1532 obj_len = (obj_len & (min_size*3)) + min_size; // 8 16 24 32 8 16 24 32 ...
496 b27c885f75f9 6786188: par compact - "SplitALot" stress mode should fill to_space jcoomes parents: 495 diff changeset	1533 }
b27c885f75f9 6786188: par compact - "SplitALot" stress mode should fill to_space jcoomes parents: 495 diff changeset	1534 if (b < t) {
b27c885f75f9 6786188: par compact - "SplitALot" stress mode should fill to_space jcoomes parents: 495 diff changeset	1535 // The loop didn't completely fill to t (top); adjust top downward.
b27c885f75f9 6786188: par compact - "SplitALot" stress mode should fill to_space jcoomes parents: 495 diff changeset	1536 space->set_top(b);
b27c885f75f9 6786188: par compact - "SplitALot" stress mode should fill to_space jcoomes parents: 495 diff changeset	1537 if (ZapUnusedHeapArea) {
b27c885f75f9 6786188: par compact - "SplitALot" stress mode should fill to_space jcoomes parents: 495 diff changeset	1538 space->set_top_for_allocations();
b27c885f75f9 6786188: par compact - "SplitALot" stress mode should fill to_space jcoomes parents: 495 diff changeset	1539 }
b27c885f75f9 6786188: par compact - "SplitALot" stress mode should fill to_space jcoomes parents: 495 diff changeset	1540 }
b27c885f75f9 6786188: par compact - "SplitALot" stress mode should fill to_space jcoomes parents: 495 diff changeset	1541
b27c885f75f9 6786188: par compact - "SplitALot" stress mode should fill to_space jcoomes parents: 495 diff changeset	1542 HeapWord** nta = _space_info[id].new_top_addr();
b27c885f75f9 6786188: par compact - "SplitALot" stress mode should fill to_space jcoomes parents: 495 diff changeset	1543 bool result = summary_data().summarize(_space_info[id].split_info(),
b27c885f75f9 6786188: par compact - "SplitALot" stress mode should fill to_space jcoomes parents: 495 diff changeset	1544 space->bottom(), space->top(), NULL,
b27c885f75f9 6786188: par compact - "SplitALot" stress mode should fill to_space jcoomes parents: 495 diff changeset	1545 space->bottom(), space->end(), nta);
b27c885f75f9 6786188: par compact - "SplitALot" stress mode should fill to_space jcoomes parents: 495 diff changeset	1546 assert(result, "space must fit into itself");
b27c885f75f9 6786188: par compact - "SplitALot" stress mode should fill to_space jcoomes parents: 495 diff changeset	1547 }
b27c885f75f9 6786188: par compact - "SplitALot" stress mode should fill to_space jcoomes parents: 495 diff changeset	1548 }
b27c885f75f9 6786188: par compact - "SplitALot" stress mode should fill to_space jcoomes parents: 495 diff changeset	1549
b27c885f75f9 6786188: par compact - "SplitALot" stress mode should fill to_space jcoomes parents: 495 diff changeset	1550 void
483 0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1551 PSParallelCompact::provoke_split(bool & max_compaction)
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1552 {
496 b27c885f75f9 6786188: par compact - "SplitALot" stress mode should fill to_space jcoomes parents: 495 diff changeset	1553 if (total_invocations() % ParallelOldGCSplitInterval != 0) {
b27c885f75f9 6786188: par compact - "SplitALot" stress mode should fill to_space jcoomes parents: 495 diff changeset	1554 return;
b27c885f75f9 6786188: par compact - "SplitALot" stress mode should fill to_space jcoomes parents: 495 diff changeset	1555 }
b27c885f75f9 6786188: par compact - "SplitALot" stress mode should fill to_space jcoomes parents: 495 diff changeset	1556
483 0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1557 const size_t region_size = ParallelCompactData::RegionSize;
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1558 ParallelCompactData& sd = summary_data();
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1559
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1560 MutableSpace* const eden_space = _space_info[eden_space_id].space();
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1561 MutableSpace* const from_space = _space_info[from_space_id].space();
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1562 const size_t eden_live = pointer_delta(eden_space->top(),
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1563 _space_info[eden_space_id].new_top());
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1564 const size_t from_live = pointer_delta(from_space->top(),
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1565 _space_info[from_space_id].new_top());
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1566
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1567 const size_t min_fill_size = CollectedHeap::min_fill_size();
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1568 const size_t eden_free = pointer_delta(eden_space->end(), eden_space->top());
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1569 const size_t eden_fillable = eden_free >= min_fill_size ? eden_free : 0;
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1570 const size_t from_free = pointer_delta(from_space->end(), from_space->top());
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1571 const size_t from_fillable = from_free >= min_fill_size ? from_free : 0;
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1572
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1573 // Choose the space to split; need at least 2 regions live (or fillable).
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1574 SpaceId id;
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1575 MutableSpace* space;
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1576 size_t live_words;
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1577 size_t fill_words;
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1578 if (eden_live + eden_fillable >= region_size * 2) {
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1579 id = eden_space_id;
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1580 space = eden_space;
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1581 live_words = eden_live;
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1582 fill_words = eden_fillable;
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1583 } else if (from_live + from_fillable >= region_size * 2) {
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1584 id = from_space_id;
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1585 space = from_space;
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1586 live_words = from_live;
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1587 fill_words = from_fillable;
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1588 } else {
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1589 return; // Give up.
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1590 }
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1591 assert(fill_words == 0 \|\| fill_words >= min_fill_size, "sanity");
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1592
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1593 if (live_words < region_size * 2) {
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1594 // Fill from top() to end() w/live objects of mixed sizes.
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1595 HeapWord* const fill_start = space->top();
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1596 live_words += fill_words;
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1597
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1598 space->set_top(fill_start + fill_words);
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1599 if (ZapUnusedHeapArea) {
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1600 space->set_top_for_allocations();
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1601 }
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1602
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1603 HeapWord* cur_addr = fill_start;
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1604 while (fill_words > 0) {
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1605 const size_t r = (size_t)os::random() % (region_size / 2) + min_fill_size;
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1606 size_t cur_size = MIN2(align_object_size_(r), fill_words);
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1607 if (fill_words - cur_size < min_fill_size) {
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1608 cur_size = fill_words; // Avoid leaving a fragment too small to fill.
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1609 }
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1610
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1611 CollectedHeap::fill_with_object(cur_addr, cur_size);
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1612 mark_bitmap()->mark_obj(cur_addr, cur_size);
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1613 sd.add_obj(cur_addr, cur_size);
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1614
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1615 cur_addr += cur_size;
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1616 fill_words -= cur_size;
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1617 }
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1618
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1619 summarize_new_objects(id, fill_start);
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1620 }
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1621
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1622 max_compaction = false;
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1623
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1624 // Manipulate the old gen so that it has room for about half of the live data
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1625 // in the target young gen space (live_words / 2).
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1626 id = old_space_id;
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1627 space = _space_info[id].space();
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1628 const size_t free_at_end = space->free_in_words();
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1629 const size_t free_target = align_object_size(live_words / 2);
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1630 const size_t dead = pointer_delta(space->top(), _space_info[id].new_top());
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1631
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1632 if (free_at_end >= free_target + min_fill_size) {
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1633 // Fill space above top() and set the dense prefix so everything survives.
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1634 HeapWord* const fill_start = space->top();
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1635 const size_t fill_size = free_at_end - free_target;
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1636 space->set_top(space->top() + fill_size);
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1637 if (ZapUnusedHeapArea) {
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1638 space->set_top_for_allocations();
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1639 }
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1640 fill_with_live_objects(id, fill_start, fill_size);
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1641 summarize_new_objects(id, fill_start);
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1642 _space_info[id].set_dense_prefix(sd.region_align_down(space->top()));
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1643 } else if (dead + free_at_end > free_target) {
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1644 // Find a dense prefix that makes the right amount of space available.
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1645 HeapWord* cur = sd.region_align_down(space->top());
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1646 HeapWord* cur_destination = sd.addr_to_region_ptr(cur)->destination();
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1647 size_t dead_to_right = pointer_delta(space->end(), cur_destination);
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1648 while (dead_to_right < free_target) {
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1649 cur -= region_size;
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1650 cur_destination = sd.addr_to_region_ptr(cur)->destination();
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1651 dead_to_right = pointer_delta(space->end(), cur_destination);
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1652 }
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1653 _space_info[id].set_dense_prefix(cur);
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1654 }
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1655 }
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1656 #endif // #ifndef PRODUCT
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1657
0 a61af66fc99e Initial load duke parents: diff changeset	1658 void PSParallelCompact::summarize_spaces_quick()
a61af66fc99e Initial load duke parents: diff changeset	1659 {
a61af66fc99e Initial load duke parents: diff changeset	1660 for (unsigned int i = 0; i < last_space_id; ++i) {
a61af66fc99e Initial load duke parents: diff changeset	1661 const MutableSpace* space = _space_info[i].space();
482 7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1662 HeapWord** nta = _space_info[i].new_top_addr();
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1663 bool result = _summary_data.summarize(_space_info[i].split_info(),
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1664 space->bottom(), space->top(), NULL,
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1665 space->bottom(), space->end(), nta);
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1666 assert(result, "space must fit into itself");
0 a61af66fc99e Initial load duke parents: diff changeset	1667 _space_info[i].set_dense_prefix(space->bottom());
a61af66fc99e Initial load duke parents: diff changeset	1668 }
496 b27c885f75f9 6786188: par compact - "SplitALot" stress mode should fill to_space jcoomes parents: 495 diff changeset	1669
b27c885f75f9 6786188: par compact - "SplitALot" stress mode should fill to_space jcoomes parents: 495 diff changeset	1670 #ifndef PRODUCT
b27c885f75f9 6786188: par compact - "SplitALot" stress mode should fill to_space jcoomes parents: 495 diff changeset	1671 if (ParallelOldGCSplitALot) {
b27c885f75f9 6786188: par compact - "SplitALot" stress mode should fill to_space jcoomes parents: 495 diff changeset	1672 provoke_split_fill_survivor(to_space_id);
b27c885f75f9 6786188: par compact - "SplitALot" stress mode should fill to_space jcoomes parents: 495 diff changeset	1673 }
b27c885f75f9 6786188: par compact - "SplitALot" stress mode should fill to_space jcoomes parents: 495 diff changeset	1674 #endif // #ifndef PRODUCT
0 a61af66fc99e Initial load duke parents: diff changeset	1675 }
a61af66fc99e Initial load duke parents: diff changeset	1676
a61af66fc99e Initial load duke parents: diff changeset	1677 void PSParallelCompact::fill_dense_prefix_end(SpaceId id)
a61af66fc99e Initial load duke parents: diff changeset	1678 {
a61af66fc99e Initial load duke parents: diff changeset	1679 HeapWord* const dense_prefix_end = dense_prefix(id);
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1680 const RegionData* region = _summary_data.addr_to_region_ptr(dense_prefix_end);
0 a61af66fc99e Initial load duke parents: diff changeset	1681 const idx_t dense_prefix_bit = _mark_bitmap.addr_to_bit(dense_prefix_end);
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1682 if (dead_space_crosses_boundary(region, dense_prefix_bit)) {
0 a61af66fc99e Initial load duke parents: diff changeset	1683 // Only enough dead space is filled so that any remaining dead space to the
a61af66fc99e Initial load duke parents: diff changeset	1684 // left is larger than the minimum filler object. (The remainder is filled
a61af66fc99e Initial load duke parents: diff changeset	1685 // during the copy/update phase.)
a61af66fc99e Initial load duke parents: diff changeset	1686 //
a61af66fc99e Initial load duke parents: diff changeset	1687 // The size of the dead space to the right of the boundary is not a
a61af66fc99e Initial load duke parents: diff changeset	1688 // concern, since compaction will be able to use whatever space is
a61af66fc99e Initial load duke parents: diff changeset	1689 // available.
a61af66fc99e Initial load duke parents: diff changeset	1690 //
a61af66fc99e Initial load duke parents: diff changeset	1691 // Here '\|\|' is the boundary, 'x' represents a don't care bit and a box
a61af66fc99e Initial load duke parents: diff changeset	1692 // surrounds the space to be filled with an object.
a61af66fc99e Initial load duke parents: diff changeset	1693 //
a61af66fc99e Initial load duke parents: diff changeset	1694 // In the 32-bit VM, each bit represents two 32-bit words:
a61af66fc99e Initial load duke parents: diff changeset	1695 // +---+
a61af66fc99e Initial load duke parents: diff changeset	1696 // a) beg_bits: ... x x x \| 0 \| \|\| 0 x x ...
a61af66fc99e Initial load duke parents: diff changeset	1697 // end_bits: ... x x x \| 0 \| \|\| 0 x x ...
a61af66fc99e Initial load duke parents: diff changeset	1698 // +---+
a61af66fc99e Initial load duke parents: diff changeset	1699 //
a61af66fc99e Initial load duke parents: diff changeset	1700 // In the 64-bit VM, each bit represents one 64-bit word:
a61af66fc99e Initial load duke parents: diff changeset	1701 // +------------+
a61af66fc99e Initial load duke parents: diff changeset	1702 // b) beg_bits: ... x x x \| 0 \|\| 0 \| x x ...
a61af66fc99e Initial load duke parents: diff changeset	1703 // end_bits: ... x x 1 \| 0 \|\| 0 \| x x ...
a61af66fc99e Initial load duke parents: diff changeset	1704 // +------------+
a61af66fc99e Initial load duke parents: diff changeset	1705 // +-------+
a61af66fc99e Initial load duke parents: diff changeset	1706 // c) beg_bits: ... x x \| 0 0 \| \|\| 0 x x ...
a61af66fc99e Initial load duke parents: diff changeset	1707 // end_bits: ... x 1 \| 0 0 \| \|\| 0 x x ...
a61af66fc99e Initial load duke parents: diff changeset	1708 // +-------+
a61af66fc99e Initial load duke parents: diff changeset	1709 // +-----------+
a61af66fc99e Initial load duke parents: diff changeset	1710 // d) beg_bits: ... x \| 0 0 0 \| \|\| 0 x x ...
a61af66fc99e Initial load duke parents: diff changeset	1711 // end_bits: ... 1 \| 0 0 0 \| \|\| 0 x x ...
a61af66fc99e Initial load duke parents: diff changeset	1712 // +-----------+
a61af66fc99e Initial load duke parents: diff changeset	1713 // +-------+
a61af66fc99e Initial load duke parents: diff changeset	1714 // e) beg_bits: ... 0 0 \| 0 0 \| \|\| 0 x x ...
a61af66fc99e Initial load duke parents: diff changeset	1715 // end_bits: ... 0 0 \| 0 0 \| \|\| 0 x x ...
a61af66fc99e Initial load duke parents: diff changeset	1716 // +-------+
a61af66fc99e Initial load duke parents: diff changeset	1717
a61af66fc99e Initial load duke parents: diff changeset	1718 // Initially assume case a, c or e will apply.
1571 2d127394260e 6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb kvn parents: 1489 diff changeset	1719 size_t obj_len = CollectedHeap::min_fill_size();
0 a61af66fc99e Initial load duke parents: diff changeset	1720 HeapWord* obj_beg = dense_prefix_end - obj_len;
a61af66fc99e Initial load duke parents: diff changeset	1721
a61af66fc99e Initial load duke parents: diff changeset	1722 #ifdef _LP64
1571 2d127394260e 6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb kvn parents: 1489 diff changeset	1723 if (MinObjAlignment > 1) { // object alignment > heap word size
2d127394260e 6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb kvn parents: 1489 diff changeset	1724 // Cases a, c or e.
2d127394260e 6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb kvn parents: 1489 diff changeset	1725 } else if (_mark_bitmap.is_obj_end(dense_prefix_bit - 2)) {
0 a61af66fc99e Initial load duke parents: diff changeset	1726 // Case b above.
a61af66fc99e Initial load duke parents: diff changeset	1727 obj_beg = dense_prefix_end - 1;
a61af66fc99e Initial load duke parents: diff changeset	1728 } else if (!_mark_bitmap.is_obj_end(dense_prefix_bit - 3) &&
a61af66fc99e Initial load duke parents: diff changeset	1729 _mark_bitmap.is_obj_end(dense_prefix_bit - 4)) {
a61af66fc99e Initial load duke parents: diff changeset	1730 // Case d above.
a61af66fc99e Initial load duke parents: diff changeset	1731 obj_beg = dense_prefix_end - 3;
a61af66fc99e Initial load duke parents: diff changeset	1732 obj_len = 3;
a61af66fc99e Initial load duke parents: diff changeset	1733 }
a61af66fc99e Initial load duke parents: diff changeset	1734 #endif // #ifdef _LP64
a61af66fc99e Initial load duke parents: diff changeset	1735
482 7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1736 CollectedHeap::fill_with_object(obj_beg, obj_len);
0 a61af66fc99e Initial load duke parents: diff changeset	1737 _mark_bitmap.mark_obj(obj_beg, obj_len);
a61af66fc99e Initial load duke parents: diff changeset	1738 _summary_data.add_obj(obj_beg, obj_len);
a61af66fc99e Initial load duke parents: diff changeset	1739 assert(start_array(id) != NULL, "sanity");
a61af66fc99e Initial load duke parents: diff changeset	1740 start_array(id)->allocate_block(obj_beg);
a61af66fc99e Initial load duke parents: diff changeset	1741 }
a61af66fc99e Initial load duke parents: diff changeset	1742 }
a61af66fc99e Initial load duke parents: diff changeset	1743
a61af66fc99e Initial load duke parents: diff changeset	1744 void
482 7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1745 PSParallelCompact::clear_source_region(HeapWord* beg_addr, HeapWord* end_addr)
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1746 {
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1747 RegionData* const beg_ptr = _summary_data.addr_to_region_ptr(beg_addr);
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1748 HeapWord* const end_aligned_up = _summary_data.region_align_up(end_addr);
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1749 RegionData* const end_ptr = _summary_data.addr_to_region_ptr(end_aligned_up);
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1750 for (RegionData* cur = beg_ptr; cur < end_ptr; ++cur) {
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1751 cur->set_source_region(0);
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1752 }
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1753 }
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1754
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1755 void
0 a61af66fc99e Initial load duke parents: diff changeset	1756 PSParallelCompact::summarize_space(SpaceId id, bool maximum_compaction)
a61af66fc99e Initial load duke parents: diff changeset	1757 {
a61af66fc99e Initial load duke parents: diff changeset	1758 assert(id < last_space_id, "id out of range");
483 0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1759 assert(_space_info[id].dense_prefix() == _space_info[id].space()->bottom() \|\|
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1760 ParallelOldGCSplitALot && id == old_space_id,
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1761 "should have been reset in summarize_spaces_quick()");
0 a61af66fc99e Initial load duke parents: diff changeset	1762
a61af66fc99e Initial load duke parents: diff changeset	1763 const MutableSpace* space = _space_info[id].space();
265 f88815ca1af1 6483129: par compact assertion failure (new_top > bottom) jcoomes parents: 264 diff changeset	1764 if (_space_info[id].new_top() != space->bottom()) {
f88815ca1af1 6483129: par compact assertion failure (new_top > bottom) jcoomes parents: 264 diff changeset	1765 HeapWord* dense_prefix_end = compute_dense_prefix(id, maximum_compaction);
f88815ca1af1 6483129: par compact assertion failure (new_top > bottom) jcoomes parents: 264 diff changeset	1766 _space_info[id].set_dense_prefix(dense_prefix_end);
0 a61af66fc99e Initial load duke parents: diff changeset	1767
a61af66fc99e Initial load duke parents: diff changeset	1768 #ifndef PRODUCT
265 f88815ca1af1 6483129: par compact assertion failure (new_top > bottom) jcoomes parents: 264 diff changeset	1769 if (TraceParallelOldGCDensePrefix) {
f88815ca1af1 6483129: par compact assertion failure (new_top > bottom) jcoomes parents: 264 diff changeset	1770 print_dense_prefix_stats("ratio", id, maximum_compaction,
f88815ca1af1 6483129: par compact assertion failure (new_top > bottom) jcoomes parents: 264 diff changeset	1771 dense_prefix_end);
f88815ca1af1 6483129: par compact assertion failure (new_top > bottom) jcoomes parents: 264 diff changeset	1772 HeapWord* addr = compute_dense_prefix_via_density(id, maximum_compaction);
f88815ca1af1 6483129: par compact assertion failure (new_top > bottom) jcoomes parents: 264 diff changeset	1773 print_dense_prefix_stats("density", id, maximum_compaction, addr);
f88815ca1af1 6483129: par compact assertion failure (new_top > bottom) jcoomes parents: 264 diff changeset	1774 }
0 a61af66fc99e Initial load duke parents: diff changeset	1775 #endif // #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	1776
483 0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1777 // Recompute the summary data, taking into account the dense prefix. If
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1778 // every last byte will be reclaimed, then the existing summary data which
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1779 // compacts everything can be left in place.
265 f88815ca1af1 6483129: par compact assertion failure (new_top > bottom) jcoomes parents: 264 diff changeset	1780 if (!maximum_compaction && dense_prefix_end != space->bottom()) {
482 7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1781 // If dead space crosses the dense prefix boundary, it is (at least
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1782 // partially) filled with a dummy object, marked live and added to the
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1783 // summary data. This simplifies the copy/update phase and must be done
483 0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1784 // before the final locations of objects are determined, to prevent
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1785 // leaving a fragment of dead space that is too small to fill.
265 f88815ca1af1 6483129: par compact assertion failure (new_top > bottom) jcoomes parents: 264 diff changeset	1786 fill_dense_prefix_end(id);
482 7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1787
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1788 // Compute the destination of each Region, and thus each object.
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1789 _summary_data.summarize_dense_prefix(space->bottom(), dense_prefix_end);
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1790 _summary_data.summarize(_space_info[id].split_info(),
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1791 dense_prefix_end, space->top(), NULL,
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1792 dense_prefix_end, space->end(),
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1793 _space_info[id].new_top_addr());
265 f88815ca1af1 6483129: par compact assertion failure (new_top > bottom) jcoomes parents: 264 diff changeset	1794 }
0 a61af66fc99e Initial load duke parents: diff changeset	1795 }
a61af66fc99e Initial load duke parents: diff changeset	1796
a61af66fc99e Initial load duke parents: diff changeset	1797 if (TraceParallelOldGCSummaryPhase) {
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1798 const size_t region_size = ParallelCompactData::RegionSize;
265 f88815ca1af1 6483129: par compact assertion failure (new_top > bottom) jcoomes parents: 264 diff changeset	1799 HeapWord* const dense_prefix_end = _space_info[id].dense_prefix();
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1800 const size_t dp_region = _summary_data.addr_to_region_idx(dense_prefix_end);
0 a61af66fc99e Initial load duke parents: diff changeset	1801 const size_t dp_words = pointer_delta(dense_prefix_end, space->bottom());
265 f88815ca1af1 6483129: par compact assertion failure (new_top > bottom) jcoomes parents: 264 diff changeset	1802 HeapWord* const new_top = _space_info[id].new_top();
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1803 const HeapWord* nt_aligned_up = _summary_data.region_align_up(new_top);
0 a61af66fc99e Initial load duke parents: diff changeset	1804 const size_t cr_words = pointer_delta(nt_aligned_up, dense_prefix_end);
a61af66fc99e Initial load duke parents: diff changeset	1805 tty->print_cr("id=%d cap=" SIZE_FORMAT " dp=" PTR_FORMAT " "
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1806 "dp_region=" SIZE_FORMAT " " "dp_count=" SIZE_FORMAT " "
0 a61af66fc99e Initial load duke parents: diff changeset	1807 "cr_count=" SIZE_FORMAT " " "nt=" PTR_FORMAT,
a61af66fc99e Initial load duke parents: diff changeset	1808 id, space->capacity_in_words(), dense_prefix_end,
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1809 dp_region, dp_words / region_size,
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1810 cr_words / region_size, new_top);
0 a61af66fc99e Initial load duke parents: diff changeset	1811 }
a61af66fc99e Initial load duke parents: diff changeset	1812 }
a61af66fc99e Initial load duke parents: diff changeset	1813
482 7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1814 #ifndef PRODUCT
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1815 void PSParallelCompact::summary_phase_msg(SpaceId dst_space_id,
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1816 HeapWord* dst_beg, HeapWord* dst_end,
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1817 SpaceId src_space_id,
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1818 HeapWord* src_beg, HeapWord* src_end)
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1819 {
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1820 if (TraceParallelOldGCSummaryPhase) {
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1821 tty->print_cr("summarizing %d [%s] into %d [%s]: "
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1822 "src=" PTR_FORMAT "-" PTR_FORMAT " "
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1823 SIZE_FORMAT "-" SIZE_FORMAT " "
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1824 "dst=" PTR_FORMAT "-" PTR_FORMAT " "
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1825 SIZE_FORMAT "-" SIZE_FORMAT,
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1826 src_space_id, space_names[src_space_id],
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1827 dst_space_id, space_names[dst_space_id],
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1828 src_beg, src_end,
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1829 _summary_data.addr_to_region_idx(src_beg),
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1830 _summary_data.addr_to_region_idx(src_end),
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1831 dst_beg, dst_end,
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1832 _summary_data.addr_to_region_idx(dst_beg),
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1833 _summary_data.addr_to_region_idx(dst_end));
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1834 }
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1835 }
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1836 #endif // #ifndef PRODUCT
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1837
0 a61af66fc99e Initial load duke parents: diff changeset	1838 void PSParallelCompact::summary_phase(ParCompactionManager* cm,
a61af66fc99e Initial load duke parents: diff changeset	1839 bool maximum_compaction)
a61af66fc99e Initial load duke parents: diff changeset	1840 {
a61af66fc99e Initial load duke parents: diff changeset	1841 EventMark m("2 summarize");
a61af66fc99e Initial load duke parents: diff changeset	1842 TraceTime tm("summary phase", print_phases(), true, gclog_or_tty);
a61af66fc99e Initial load duke parents: diff changeset	1843 // trace("2");
a61af66fc99e Initial load duke parents: diff changeset	1844
a61af66fc99e Initial load duke parents: diff changeset	1845 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	1846 if (TraceParallelOldGCMarkingPhase) {
a61af66fc99e Initial load duke parents: diff changeset	1847 tty->print_cr("add_obj_count=" SIZE_FORMAT " "
a61af66fc99e Initial load duke parents: diff changeset	1848 "add_obj_bytes=" SIZE_FORMAT,
a61af66fc99e Initial load duke parents: diff changeset	1849 add_obj_count, add_obj_size * HeapWordSize);
a61af66fc99e Initial load duke parents: diff changeset	1850 tty->print_cr("mark_bitmap_count=" SIZE_FORMAT " "
a61af66fc99e Initial load duke parents: diff changeset	1851 "mark_bitmap_bytes=" SIZE_FORMAT,
a61af66fc99e Initial load duke parents: diff changeset	1852 mark_bitmap_count, mark_bitmap_size * HeapWordSize);
a61af66fc99e Initial load duke parents: diff changeset	1853 }
a61af66fc99e Initial load duke parents: diff changeset	1854 #endif // #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	1855
a61af66fc99e Initial load duke parents: diff changeset	1856 // Quick summarization of each space into itself, to see how much is live.
a61af66fc99e Initial load duke parents: diff changeset	1857 summarize_spaces_quick();
a61af66fc99e Initial load duke parents: diff changeset	1858
a61af66fc99e Initial load duke parents: diff changeset	1859 if (TraceParallelOldGCSummaryPhase) {
a61af66fc99e Initial load duke parents: diff changeset	1860 tty->print_cr("summary_phase: after summarizing each space to self");
a61af66fc99e Initial load duke parents: diff changeset	1861 Universe::print();
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1862 NOT_PRODUCT(print_region_ranges());
0 a61af66fc99e Initial load duke parents: diff changeset	1863 if (Verbose) {
a61af66fc99e Initial load duke parents: diff changeset	1864 NOT_PRODUCT(print_initial_summary_data(_summary_data, _space_info));
a61af66fc99e Initial load duke parents: diff changeset	1865 }
a61af66fc99e Initial load duke parents: diff changeset	1866 }
a61af66fc99e Initial load duke parents: diff changeset	1867
a61af66fc99e Initial load duke parents: diff changeset	1868 // The amount of live data that will end up in old space (assuming it fits).
a61af66fc99e Initial load duke parents: diff changeset	1869 size_t old_space_total_live = 0;
482 7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1870 assert(perm_space_id < old_space_id, "should not count perm data here");
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1871 for (unsigned int id = old_space_id; id < last_space_id; ++id) {
0 a61af66fc99e Initial load duke parents: diff changeset	1872 old_space_total_live += pointer_delta(_space_info[id].new_top(),
a61af66fc99e Initial load duke parents: diff changeset	1873 _space_info[id].space()->bottom());
a61af66fc99e Initial load duke parents: diff changeset	1874 }
a61af66fc99e Initial load duke parents: diff changeset	1875
482 7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1876 MutableSpace* const old_space = _space_info[old_space_id].space();
483 0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1877 const size_t old_capacity = old_space->capacity_in_words();
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1878 if (old_space_total_live > old_capacity) {
0 a61af66fc99e Initial load duke parents: diff changeset	1879 // XXX - should also try to expand
a61af66fc99e Initial load duke parents: diff changeset	1880 maximum_compaction = true;
a61af66fc99e Initial load duke parents: diff changeset	1881 }
483 0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1882 #ifndef PRODUCT
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1883 if (ParallelOldGCSplitALot && old_space_total_live < old_capacity) {
496 b27c885f75f9 6786188: par compact - "SplitALot" stress mode should fill to_space jcoomes parents: 495 diff changeset	1884 provoke_split(maximum_compaction);
483 0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1885 }
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	1886 #endif // #ifndef PRODUCT
0 a61af66fc99e Initial load duke parents: diff changeset	1887
a61af66fc99e Initial load duke parents: diff changeset	1888 // Permanent and Old generations.
a61af66fc99e Initial load duke parents: diff changeset	1889 summarize_space(perm_space_id, maximum_compaction);
a61af66fc99e Initial load duke parents: diff changeset	1890 summarize_space(old_space_id, maximum_compaction);
a61af66fc99e Initial load duke parents: diff changeset	1891
482 7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1892 // Summarize the remaining spaces in the young gen. The initial target space
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1893 // is the old gen. If a space does not fit entirely into the target, then the
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1894 // remainder is compacted into the space itself and that space becomes the new
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1895 // target.
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1896 SpaceId dst_space_id = old_space_id;
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1897 HeapWord* dst_space_end = old_space->end();
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1898 HeapWord** new_top_addr = _space_info[dst_space_id].new_top_addr();
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1899 for (unsigned int id = eden_space_id; id < last_space_id; ++id) {
0 a61af66fc99e Initial load duke parents: diff changeset	1900 const MutableSpace* space = _space_info[id].space();
a61af66fc99e Initial load duke parents: diff changeset	1901 const size_t live = pointer_delta(_space_info[id].new_top(),
a61af66fc99e Initial load duke parents: diff changeset	1902 space->bottom());
482 7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1903 const size_t available = pointer_delta(dst_space_end, *new_top_addr);
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1904
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1905 NOT_PRODUCT(summary_phase_msg(dst_space_id, *new_top_addr, dst_space_end,
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1906 SpaceId(id), space->bottom(), space->top());)
266 2214b226b7f0 6724367: par compact could clear less young gen summary data jcoomes parents: 265 diff changeset	1907 if (live > 0 && live <= available) {
0 a61af66fc99e Initial load duke parents: diff changeset	1908 // All the live data will fit.
482 7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1909 bool done = _summary_data.summarize(_space_info[id].split_info(),
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1910 space->bottom(), space->top(),
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1911 NULL,
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1912 *new_top_addr, dst_space_end,
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1913 new_top_addr);
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1914 assert(done, "space must fit into old gen");
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1915
266 2214b226b7f0 6724367: par compact could clear less young gen summary data jcoomes parents: 265 diff changeset	1916 // Reset the new_top value for the space.
2214b226b7f0 6724367: par compact could clear less young gen summary data jcoomes parents: 265 diff changeset	1917 _space_info[id].set_new_top(space->bottom());
482 7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1918 } else if (live > 0) {
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1919 // Attempt to fit part of the source space into the target space.
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1920 HeapWord* next_src_addr = NULL;
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1921 bool done = _summary_data.summarize(_space_info[id].split_info(),
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1922 space->bottom(), space->top(),
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1923 &next_src_addr,
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1924 *new_top_addr, dst_space_end,
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1925 new_top_addr);
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1926 assert(!done, "space should not fit into old gen");
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1927 assert(next_src_addr != NULL, "sanity");
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1928
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1929 // The source space becomes the new target, so the remainder is compacted
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1930 // within the space itself.
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1931 dst_space_id = SpaceId(id);
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1932 dst_space_end = space->end();
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1933 new_top_addr = _space_info[id].new_top_addr();
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1934 NOT_PRODUCT(summary_phase_msg(dst_space_id,
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1935 space->bottom(), dst_space_end,
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1936 SpaceId(id), next_src_addr, space->top());)
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1937 done = _summary_data.summarize(_space_info[id].split_info(),
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1938 next_src_addr, space->top(),
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1939 NULL,
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1940 space->bottom(), dst_space_end,
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1941 new_top_addr);
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1942 assert(done, "space must fit when compacted into itself");
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1943 assert(*new_top_addr <= space->top(), "usage should not grow");
0 a61af66fc99e Initial load duke parents: diff changeset	1944 }
a61af66fc99e Initial load duke parents: diff changeset	1945 }
a61af66fc99e Initial load duke parents: diff changeset	1946
a61af66fc99e Initial load duke parents: diff changeset	1947 if (TraceParallelOldGCSummaryPhase) {
a61af66fc99e Initial load duke parents: diff changeset	1948 tty->print_cr("summary_phase: after final summarization");
a61af66fc99e Initial load duke parents: diff changeset	1949 Universe::print();
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1950 NOT_PRODUCT(print_region_ranges());
0 a61af66fc99e Initial load duke parents: diff changeset	1951 if (Verbose) {
a61af66fc99e Initial load duke parents: diff changeset	1952 NOT_PRODUCT(print_generic_summary_data(_summary_data, _space_info));
a61af66fc99e Initial load duke parents: diff changeset	1953 }
a61af66fc99e Initial load duke parents: diff changeset	1954 }
a61af66fc99e Initial load duke parents: diff changeset	1955 }
a61af66fc99e Initial load duke parents: diff changeset	1956
a61af66fc99e Initial load duke parents: diff changeset	1957 // This method should contain all heap-specific policy for invoking a full
a61af66fc99e Initial load duke parents: diff changeset	1958 // collection. invoke_no_policy() will only attempt to compact the heap; it
a61af66fc99e Initial load duke parents: diff changeset	1959 // will do nothing further. If we need to bail out for policy reasons, scavenge
a61af66fc99e Initial load duke parents: diff changeset	1960 // before full gc, or any other specialized behavior, it needs to be added here.
a61af66fc99e Initial load duke parents: diff changeset	1961 //
a61af66fc99e Initial load duke parents: diff changeset	1962 // Note that this method should only be called from the vm_thread while at a
a61af66fc99e Initial load duke parents: diff changeset	1963 // safepoint.
1387 0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1311 diff changeset	1964 //
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1311 diff changeset	1965 // Note that the all_soft_refs_clear flag in the collector policy
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1311 diff changeset	1966 // may be true because this method can be called without intervening
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1311 diff changeset	1967 // activity. For example when the heap space is tight and full measure
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1311 diff changeset	1968 // are being taken to free space.
0 a61af66fc99e Initial load duke parents: diff changeset	1969 void PSParallelCompact::invoke(bool maximum_heap_compaction) {
a61af66fc99e Initial load duke parents: diff changeset	1970 assert(SafepointSynchronize::is_at_safepoint(), "should be at safepoint");
a61af66fc99e Initial load duke parents: diff changeset	1971 assert(Thread::current() == (Thread*)VMThread::vm_thread(),
a61af66fc99e Initial load duke parents: diff changeset	1972 "should be in vm thread");
1387 0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1311 diff changeset	1973
0 a61af66fc99e Initial load duke parents: diff changeset	1974 ParallelScavengeHeap* heap = gc_heap();
a61af66fc99e Initial load duke parents: diff changeset	1975 GCCause::Cause gc_cause = heap->gc_cause();
a61af66fc99e Initial load duke parents: diff changeset	1976 assert(!heap->is_gc_active(), "not reentrant");
a61af66fc99e Initial load duke parents: diff changeset	1977
a61af66fc99e Initial load duke parents: diff changeset	1978 PSAdaptiveSizePolicy* policy = heap->size_policy();
1387 0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1311 diff changeset	1979 IsGCActiveMark mark;
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1311 diff changeset	1980
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1311 diff changeset	1981 if (ScavengeBeforeFullGC) {
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1311 diff changeset	1982 PSScavenge::invoke_no_policy();
0 a61af66fc99e Initial load duke parents: diff changeset	1983 }
1387 0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1311 diff changeset	1984
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1311 diff changeset	1985 const bool clear_all_soft_refs =
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1311 diff changeset	1986 heap->collector_policy()->should_clear_all_soft_refs();
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1311 diff changeset	1987
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1311 diff changeset	1988 PSParallelCompact::invoke_no_policy(clear_all_soft_refs \|\|
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1311 diff changeset	1989 maximum_heap_compaction);
0 a61af66fc99e Initial load duke parents: diff changeset	1990 }
a61af66fc99e Initial load duke parents: diff changeset	1991
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1992 bool ParallelCompactData::region_contains(size_t region_index, HeapWord* addr) {
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1993 size_t addr_region_index = addr_to_region_idx(addr);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	1994 return region_index == addr_region_index;
0 a61af66fc99e Initial load duke parents: diff changeset	1995 }
a61af66fc99e Initial load duke parents: diff changeset	1996
a61af66fc99e Initial load duke parents: diff changeset	1997 // This method contains no policy. You should probably
a61af66fc99e Initial load duke parents: diff changeset	1998 // be calling invoke() instead.
a61af66fc99e Initial load duke parents: diff changeset	1999 void PSParallelCompact::invoke_no_policy(bool maximum_heap_compaction) {
a61af66fc99e Initial load duke parents: diff changeset	2000 assert(SafepointSynchronize::is_at_safepoint(), "must be at a safepoint");
a61af66fc99e Initial load duke parents: diff changeset	2001 assert(ref_processor() != NULL, "Sanity");
a61af66fc99e Initial load duke parents: diff changeset	2002
139 c0492d52d55b 6539517: CR 6186200 should be extended to perm gen allocation to prevent spurious OOM's from perm gen apetrusenko parents: 0 diff changeset	2003 if (GC_locker::check_active_before_gc()) {
0 a61af66fc99e Initial load duke parents: diff changeset	2004 return;
a61af66fc99e Initial load duke parents: diff changeset	2005 }
a61af66fc99e Initial load duke parents: diff changeset	2006
a61af66fc99e Initial load duke parents: diff changeset	2007 TimeStamp marking_start;
a61af66fc99e Initial load duke parents: diff changeset	2008 TimeStamp compaction_start;
a61af66fc99e Initial load duke parents: diff changeset	2009 TimeStamp collection_exit;
a61af66fc99e Initial load duke parents: diff changeset	2010
a61af66fc99e Initial load duke parents: diff changeset	2011 ParallelScavengeHeap* heap = gc_heap();
a61af66fc99e Initial load duke parents: diff changeset	2012 GCCause::Cause gc_cause = heap->gc_cause();
a61af66fc99e Initial load duke parents: diff changeset	2013 PSYoungGen* young_gen = heap->young_gen();
a61af66fc99e Initial load duke parents: diff changeset	2014 PSOldGen* old_gen = heap->old_gen();
a61af66fc99e Initial load duke parents: diff changeset	2015 PSPermGen* perm_gen = heap->perm_gen();
a61af66fc99e Initial load duke parents: diff changeset	2016 PSAdaptiveSizePolicy* size_policy = heap->size_policy();
a61af66fc99e Initial load duke parents: diff changeset	2017
1387 0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1311 diff changeset	2018 // The scope of casr should end after code that can change
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1311 diff changeset	2019 // CollectorPolicy::_should_clear_all_soft_refs.
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1311 diff changeset	2020 ClearedAllSoftRefs casr(maximum_heap_compaction,
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1311 diff changeset	2021 heap->collector_policy());
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1311 diff changeset	2022
263 12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 210 diff changeset	2023 if (ZapUnusedHeapArea) {
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 210 diff changeset	2024 // Save information needed to minimize mangling
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 210 diff changeset	2025 heap->record_gen_tops_before_GC();
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 210 diff changeset	2026 }
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 210 diff changeset	2027
615 c6c601a0f2d6 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC ysr parents: 546 diff changeset	2028 heap->pre_full_gc_dump();
c6c601a0f2d6 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC ysr parents: 546 diff changeset	2029
0 a61af66fc99e Initial load duke parents: diff changeset	2030 _print_phases = PrintGCDetails && PrintParallelOldGCPhaseTimes;
a61af66fc99e Initial load duke parents: diff changeset	2031
a61af66fc99e Initial load duke parents: diff changeset	2032 // Make sure data structures are sane, make the heap parsable, and do other
a61af66fc99e Initial load duke parents: diff changeset	2033 // miscellaneous bookkeeping.
a61af66fc99e Initial load duke parents: diff changeset	2034 PreGCValues pre_gc_values;
a61af66fc99e Initial load duke parents: diff changeset	2035 pre_compact(&pre_gc_values);
a61af66fc99e Initial load duke parents: diff changeset	2036
210 05712c37c828 6676016: ParallelOldGC leaks memory jcoomes parents: 142 diff changeset	2037 // Get the compaction manager reserved for the VM thread.
05712c37c828 6676016: ParallelOldGC leaks memory jcoomes parents: 142 diff changeset	2038 ParCompactionManager* const vmthread_cm =
05712c37c828 6676016: ParallelOldGC leaks memory jcoomes parents: 142 diff changeset	2039 ParCompactionManager::manager_array(gc_task_manager()->workers());
05712c37c828 6676016: ParallelOldGC leaks memory jcoomes parents: 142 diff changeset	2040
0 a61af66fc99e Initial load duke parents: diff changeset	2041 // Place after pre_compact() where the number of invocations is incremented.
a61af66fc99e Initial load duke parents: diff changeset	2042 AdaptiveSizePolicyOutput(size_policy, heap->total_collections());
a61af66fc99e Initial load duke parents: diff changeset	2043
a61af66fc99e Initial load duke parents: diff changeset	2044 {
a61af66fc99e Initial load duke parents: diff changeset	2045 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	2046 HandleMark hm;
a61af66fc99e Initial load duke parents: diff changeset	2047
a61af66fc99e Initial load duke parents: diff changeset	2048 const bool is_system_gc = gc_cause == GCCause::_java_lang_system_gc;
a61af66fc99e Initial load duke parents: diff changeset	2049
a61af66fc99e Initial load duke parents: diff changeset	2050 // This is useful for debugging but don't change the output the
a61af66fc99e Initial load duke parents: diff changeset	2051 // the customer sees.
a61af66fc99e Initial load duke parents: diff changeset	2052 const char* gc_cause_str = "Full GC";
a61af66fc99e Initial load duke parents: diff changeset	2053 if (is_system_gc && PrintGCDetails) {
a61af66fc99e Initial load duke parents: diff changeset	2054 gc_cause_str = "Full GC (System)";
a61af66fc99e Initial load duke parents: diff changeset	2055 }
a61af66fc99e Initial load duke parents: diff changeset	2056 gclog_or_tty->date_stamp(PrintGC && PrintGCDateStamps);
a61af66fc99e Initial load duke parents: diff changeset	2057 TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty);
a61af66fc99e Initial load duke parents: diff changeset	2058 TraceTime t1(gc_cause_str, PrintGC, !PrintGCDetails, gclog_or_tty);
a61af66fc99e Initial load duke parents: diff changeset	2059 TraceCollectorStats tcs(counters());
3356 78542e2b5e35 7036199: Adding a notification to the implementation of GarbageCollectorMXBeans fparain parents: 3251 diff changeset	2060 TraceMemoryManagerStats tms(true /* Full GC */,gc_cause);
0 a61af66fc99e Initial load duke parents: diff changeset	2061
a61af66fc99e Initial load duke parents: diff changeset	2062 if (TraceGen1Time) accumulated_time()->start();
a61af66fc99e Initial load duke parents: diff changeset	2063
a61af66fc99e Initial load duke parents: diff changeset	2064 // Let the size policy know we're starting
a61af66fc99e Initial load duke parents: diff changeset	2065 size_policy->major_collection_begin();
a61af66fc99e Initial load duke parents: diff changeset	2066
a61af66fc99e Initial load duke parents: diff changeset	2067 // When collecting the permanent generation methodOops may be moving,
a61af66fc99e Initial load duke parents: diff changeset	2068 // so we either have to flush all bcp data or convert it into bci.
a61af66fc99e Initial load duke parents: diff changeset	2069 CodeCache::gc_prologue();
a61af66fc99e Initial load duke parents: diff changeset	2070 Threads::gc_prologue();
a61af66fc99e Initial load duke parents: diff changeset	2071
a61af66fc99e Initial load duke parents: diff changeset	2072 COMPILER2_PRESENT(DerivedPointerTable::clear());
a61af66fc99e Initial load duke parents: diff changeset	2073
3979 4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3915 diff changeset	2074 ref_processor()->enable_discovery(true /verify_disabled/, true /verify_no_refs/);
457 27a80744a83b 6778647: snap(), snap_policy() should be renamed setup(), setup_policy() ysr parents: 453 diff changeset	2075 ref_processor()->setup_policy(maximum_heap_compaction);
0 a61af66fc99e Initial load duke parents: diff changeset	2076
a61af66fc99e Initial load duke parents: diff changeset	2077 bool marked_for_unloading = false;
a61af66fc99e Initial load duke parents: diff changeset	2078
a61af66fc99e Initial load duke parents: diff changeset	2079 marking_start.update();
210 05712c37c828 6676016: ParallelOldGC leaks memory jcoomes parents: 142 diff changeset	2080 marking_phase(vmthread_cm, maximum_heap_compaction);
0 a61af66fc99e Initial load duke parents: diff changeset	2081
a61af66fc99e Initial load duke parents: diff changeset	2082 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	2083 if (TraceParallelOldGCMarkingPhase) {
a61af66fc99e Initial load duke parents: diff changeset	2084 gclog_or_tty->print_cr("marking_phase: cas_tries %d cas_retries %d "
a61af66fc99e Initial load duke parents: diff changeset	2085 "cas_by_another %d",
a61af66fc99e Initial load duke parents: diff changeset	2086 mark_bitmap()->cas_tries(), mark_bitmap()->cas_retries(),
a61af66fc99e Initial load duke parents: diff changeset	2087 mark_bitmap()->cas_by_another());
a61af66fc99e Initial load duke parents: diff changeset	2088 }
a61af66fc99e Initial load duke parents: diff changeset	2089 #endif // #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	2090
a61af66fc99e Initial load duke parents: diff changeset	2091 bool max_on_system_gc = UseMaximumCompactionOnSystemGC && is_system_gc;
210 05712c37c828 6676016: ParallelOldGC leaks memory jcoomes parents: 142 diff changeset	2092 summary_phase(vmthread_cm, maximum_heap_compaction \|\| max_on_system_gc);
0 a61af66fc99e Initial load duke parents: diff changeset	2093
a61af66fc99e Initial load duke parents: diff changeset	2094 COMPILER2_PRESENT(assert(DerivedPointerTable::is_active(), "Sanity"));
a61af66fc99e Initial load duke parents: diff changeset	2095 COMPILER2_PRESENT(DerivedPointerTable::set_active(false));
a61af66fc99e Initial load duke parents: diff changeset	2096
a61af66fc99e Initial load duke parents: diff changeset	2097 // adjust_roots() updates Universe::_intArrayKlassObj which is
a61af66fc99e Initial load duke parents: diff changeset	2098 // needed by the compaction for filling holes in the dense prefix.
a61af66fc99e Initial load duke parents: diff changeset	2099 adjust_roots();
a61af66fc99e Initial load duke parents: diff changeset	2100
a61af66fc99e Initial load duke parents: diff changeset	2101 compaction_start.update();
a61af66fc99e Initial load duke parents: diff changeset	2102 // Does the perm gen always have to be done serially because
a61af66fc99e Initial load duke parents: diff changeset	2103 // klasses are used in the update of an object?
210 05712c37c828 6676016: ParallelOldGC leaks memory jcoomes parents: 142 diff changeset	2104 compact_perm(vmthread_cm);
0 a61af66fc99e Initial load duke parents: diff changeset	2105
3251 eda9eb483d29 6841742: par compact - remove unused/unsupported options jcoomes parents: 2369 diff changeset	2106 compact();
0 a61af66fc99e Initial load duke parents: diff changeset	2107
a61af66fc99e Initial load duke parents: diff changeset	2108 // Reset the mark bitmap, summary data, and do other bookkeeping. Must be
a61af66fc99e Initial load duke parents: diff changeset	2109 // done before resizing.
a61af66fc99e Initial load duke parents: diff changeset	2110 post_compact();
a61af66fc99e Initial load duke parents: diff changeset	2111
a61af66fc99e Initial load duke parents: diff changeset	2112 // Let the size policy know we're done
a61af66fc99e Initial load duke parents: diff changeset	2113 size_policy->major_collection_end(old_gen->used_in_bytes(), gc_cause);
a61af66fc99e Initial load duke parents: diff changeset	2114
a61af66fc99e Initial load duke parents: diff changeset	2115 if (UseAdaptiveSizePolicy) {
a61af66fc99e Initial load duke parents: diff changeset	2116 if (PrintAdaptiveSizePolicy) {
a61af66fc99e Initial load duke parents: diff changeset	2117 gclog_or_tty->print("AdaptiveSizeStart: ");
a61af66fc99e Initial load duke parents: diff changeset	2118 gclog_or_tty->stamp();
a61af66fc99e Initial load duke parents: diff changeset	2119 gclog_or_tty->print_cr(" collection: %d ",
a61af66fc99e Initial load duke parents: diff changeset	2120 heap->total_collections());
a61af66fc99e Initial load duke parents: diff changeset	2121 if (Verbose) {
a61af66fc99e Initial load duke parents: diff changeset	2122 gclog_or_tty->print("old_gen_capacity: %d young_gen_capacity: %d"
a61af66fc99e Initial load duke parents: diff changeset	2123 " perm_gen_capacity: %d ",
a61af66fc99e Initial load duke parents: diff changeset	2124 old_gen->capacity_in_bytes(), young_gen->capacity_in_bytes(),
a61af66fc99e Initial load duke parents: diff changeset	2125 perm_gen->capacity_in_bytes());
a61af66fc99e Initial load duke parents: diff changeset	2126 }
a61af66fc99e Initial load duke parents: diff changeset	2127 }
a61af66fc99e Initial load duke parents: diff changeset	2128
a61af66fc99e Initial load duke parents: diff changeset	2129 // Don't check if the size_policy is ready here. Let
a61af66fc99e Initial load duke parents: diff changeset	2130 // the size_policy check that internally.
a61af66fc99e Initial load duke parents: diff changeset	2131 if (UseAdaptiveGenerationSizePolicyAtMajorCollection &&
a61af66fc99e Initial load duke parents: diff changeset	2132 ((gc_cause != GCCause::_java_lang_system_gc) \|\|
a61af66fc99e Initial load duke parents: diff changeset	2133 UseAdaptiveSizePolicyWithSystemGC)) {
a61af66fc99e Initial load duke parents: diff changeset	2134 // Calculate optimal free space amounts
a61af66fc99e Initial load duke parents: diff changeset	2135 assert(young_gen->max_size() >
a61af66fc99e Initial load duke parents: diff changeset	2136 young_gen->from_space()->capacity_in_bytes() +
a61af66fc99e Initial load duke parents: diff changeset	2137 young_gen->to_space()->capacity_in_bytes(),
a61af66fc99e Initial load duke parents: diff changeset	2138 "Sizes of space in young gen are out-of-bounds");
a61af66fc99e Initial load duke parents: diff changeset	2139 size_t max_eden_size = young_gen->max_size() -
a61af66fc99e Initial load duke parents: diff changeset	2140 young_gen->from_space()->capacity_in_bytes() -
a61af66fc99e Initial load duke parents: diff changeset	2141 young_gen->to_space()->capacity_in_bytes();
263 12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 210 diff changeset	2142 size_policy->compute_generation_free_space(
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 210 diff changeset	2143 young_gen->used_in_bytes(),
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 210 diff changeset	2144 young_gen->eden_space()->used_in_bytes(),
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 210 diff changeset	2145 old_gen->used_in_bytes(),
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 210 diff changeset	2146 perm_gen->used_in_bytes(),
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 210 diff changeset	2147 young_gen->eden_space()->capacity_in_bytes(),
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 210 diff changeset	2148 old_gen->max_gen_size(),
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 210 diff changeset	2149 max_eden_size,
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 210 diff changeset	2150 true /* full gc*/,
1387 0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1311 diff changeset	2151 gc_cause,
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1311 diff changeset	2152 heap->collector_policy());
263 12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 210 diff changeset	2153
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 210 diff changeset	2154 heap->resize_old_gen(
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 210 diff changeset	2155 size_policy->calculated_old_free_size_in_bytes());
0 a61af66fc99e Initial load duke parents: diff changeset	2156
a61af66fc99e Initial load duke parents: diff changeset	2157 // Don't resize the young generation at an major collection. A
a61af66fc99e Initial load duke parents: diff changeset	2158 // desired young generation size may have been calculated but
a61af66fc99e Initial load duke parents: diff changeset	2159 // resizing the young generation complicates the code because the
a61af66fc99e Initial load duke parents: diff changeset	2160 // resizing of the old generation may have moved the boundary
a61af66fc99e Initial load duke parents: diff changeset	2161 // between the young generation and the old generation. Let the
a61af66fc99e Initial load duke parents: diff changeset	2162 // young generation resizing happen at the minor collections.
a61af66fc99e Initial load duke parents: diff changeset	2163 }
a61af66fc99e Initial load duke parents: diff changeset	2164 if (PrintAdaptiveSizePolicy) {
a61af66fc99e Initial load duke parents: diff changeset	2165 gclog_or_tty->print_cr("AdaptiveSizeStop: collection: %d ",
a61af66fc99e Initial load duke parents: diff changeset	2166 heap->total_collections());
a61af66fc99e Initial load duke parents: diff changeset	2167 }
a61af66fc99e Initial load duke parents: diff changeset	2168 }
a61af66fc99e Initial load duke parents: diff changeset	2169
a61af66fc99e Initial load duke parents: diff changeset	2170 if (UsePerfData) {
a61af66fc99e Initial load duke parents: diff changeset	2171 PSGCAdaptivePolicyCounters* const counters = heap->gc_policy_counters();
a61af66fc99e Initial load duke parents: diff changeset	2172 counters->update_counters();
a61af66fc99e Initial load duke parents: diff changeset	2173 counters->update_old_capacity(old_gen->capacity_in_bytes());
a61af66fc99e Initial load duke parents: diff changeset	2174 counters->update_young_capacity(young_gen->capacity_in_bytes());
a61af66fc99e Initial load duke parents: diff changeset	2175 }
a61af66fc99e Initial load duke parents: diff changeset	2176
a61af66fc99e Initial load duke parents: diff changeset	2177 heap->resize_all_tlabs();
a61af66fc99e Initial load duke parents: diff changeset	2178
a61af66fc99e Initial load duke parents: diff changeset	2179 // We collected the perm gen, so we'll resize it here.
a61af66fc99e Initial load duke parents: diff changeset	2180 perm_gen->compute_new_size(pre_gc_values.perm_gen_used());
a61af66fc99e Initial load duke parents: diff changeset	2181
a61af66fc99e Initial load duke parents: diff changeset	2182 if (TraceGen1Time) accumulated_time()->stop();
a61af66fc99e Initial load duke parents: diff changeset	2183
a61af66fc99e Initial load duke parents: diff changeset	2184 if (PrintGC) {
a61af66fc99e Initial load duke parents: diff changeset	2185 if (PrintGCDetails) {
a61af66fc99e Initial load duke parents: diff changeset	2186 // No GC timestamp here. This is after GC so it would be confusing.
a61af66fc99e Initial load duke parents: diff changeset	2187 young_gen->print_used_change(pre_gc_values.young_gen_used());
a61af66fc99e Initial load duke parents: diff changeset	2188 old_gen->print_used_change(pre_gc_values.old_gen_used());
a61af66fc99e Initial load duke parents: diff changeset	2189 heap->print_heap_change(pre_gc_values.heap_used());
a61af66fc99e Initial load duke parents: diff changeset	2190 // Print perm gen last (print_heap_change() excludes the perm gen).
a61af66fc99e Initial load duke parents: diff changeset	2191 perm_gen->print_used_change(pre_gc_values.perm_gen_used());
a61af66fc99e Initial load duke parents: diff changeset	2192 } else {
a61af66fc99e Initial load duke parents: diff changeset	2193 heap->print_heap_change(pre_gc_values.heap_used());
a61af66fc99e Initial load duke parents: diff changeset	2194 }
a61af66fc99e Initial load duke parents: diff changeset	2195 }
a61af66fc99e Initial load duke parents: diff changeset	2196
a61af66fc99e Initial load duke parents: diff changeset	2197 // Track memory usage and detect low memory
a61af66fc99e Initial load duke parents: diff changeset	2198 MemoryService::track_memory_usage();
a61af66fc99e Initial load duke parents: diff changeset	2199 heap->update_counters();
a61af66fc99e Initial load duke parents: diff changeset	2200 }
a61af66fc99e Initial load duke parents: diff changeset	2201
1836 894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1833 diff changeset	2202 #ifdef ASSERT
894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1833 diff changeset	2203 for (size_t i = 0; i < ParallelGCThreads + 1; ++i) {
894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1833 diff changeset	2204 ParCompactionManager* const cm =
894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1833 diff changeset	2205 ParCompactionManager::manager_array(int(i));
894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1833 diff changeset	2206 assert(cm->marking_stack()->is_empty(), "should be empty");
894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1833 diff changeset	2207 assert(cm->region_stack()->is_empty(), "should be empty");
894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1833 diff changeset	2208 assert(cm->revisit_klass_stack()->is_empty(), "should be empty");
894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1833 diff changeset	2209 }
894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1833 diff changeset	2210 #endif // ASSERT
894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1833 diff changeset	2211
0 a61af66fc99e Initial load duke parents: diff changeset	2212 if (VerifyAfterGC && heap->total_collections() >= VerifyGCStartAt) {
a61af66fc99e Initial load duke parents: diff changeset	2213 HandleMark hm; // Discard invalid handles created during verification
a61af66fc99e Initial load duke parents: diff changeset	2214 gclog_or_tty->print(" VerifyAfterGC:");
a61af66fc99e Initial load duke parents: diff changeset	2215 Universe::verify(false);
a61af66fc99e Initial load duke parents: diff changeset	2216 }
a61af66fc99e Initial load duke parents: diff changeset	2217
a61af66fc99e Initial load duke parents: diff changeset	2218 // Re-verify object start arrays
a61af66fc99e Initial load duke parents: diff changeset	2219 if (VerifyObjectStartArray &&
a61af66fc99e Initial load duke parents: diff changeset	2220 VerifyAfterGC) {
a61af66fc99e Initial load duke parents: diff changeset	2221 old_gen->verify_object_start_array();
a61af66fc99e Initial load duke parents: diff changeset	2222 perm_gen->verify_object_start_array();
a61af66fc99e Initial load duke parents: diff changeset	2223 }
a61af66fc99e Initial load duke parents: diff changeset	2224
263 12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 210 diff changeset	2225 if (ZapUnusedHeapArea) {
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 210 diff changeset	2226 old_gen->object_space()->check_mangled_unused_area_complete();
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 210 diff changeset	2227 perm_gen->object_space()->check_mangled_unused_area_complete();
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 210 diff changeset	2228 }
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 210 diff changeset	2229
0 a61af66fc99e Initial load duke parents: diff changeset	2230 NOT_PRODUCT(ref_processor()->verify_no_references_recorded());
a61af66fc99e Initial load duke parents: diff changeset	2231
a61af66fc99e Initial load duke parents: diff changeset	2232 collection_exit.update();
a61af66fc99e Initial load duke parents: diff changeset	2233
a61af66fc99e Initial load duke parents: diff changeset	2234 if (PrintHeapAtGC) {
a61af66fc99e Initial load duke parents: diff changeset	2235 Universe::print_heap_after_gc();
a61af66fc99e Initial load duke parents: diff changeset	2236 }
a61af66fc99e Initial load duke parents: diff changeset	2237 if (PrintGCTaskTimeStamps) {
a61af66fc99e Initial load duke parents: diff changeset	2238 gclog_or_tty->print_cr("VM-Thread " INT64_FORMAT " " INT64_FORMAT " "
a61af66fc99e Initial load duke parents: diff changeset	2239 INT64_FORMAT,
a61af66fc99e Initial load duke parents: diff changeset	2240 marking_start.ticks(), compaction_start.ticks(),
a61af66fc99e Initial load duke parents: diff changeset	2241 collection_exit.ticks());
a61af66fc99e Initial load duke parents: diff changeset	2242 gc_task_manager()->print_task_time_stamps();
a61af66fc99e Initial load duke parents: diff changeset	2243 }
546 05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination. jmasa parents: 496 diff changeset	2244
615 c6c601a0f2d6 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC ysr parents: 546 diff changeset	2245 heap->post_full_gc_dump();
c6c601a0f2d6 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC ysr parents: 546 diff changeset	2246
546 05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination. jmasa parents: 496 diff changeset	2247 #ifdef TRACESPINNING
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination. jmasa parents: 496 diff changeset	2248 ParallelTaskTerminator::print_termination_counts();
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination. jmasa parents: 496 diff changeset	2249 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	2250 }
a61af66fc99e Initial load duke parents: diff changeset	2251
a61af66fc99e Initial load duke parents: diff changeset	2252 bool PSParallelCompact::absorb_live_data_from_eden(PSAdaptiveSizePolicy* size_policy,
a61af66fc99e Initial load duke parents: diff changeset	2253 PSYoungGen* young_gen,
a61af66fc99e Initial load duke parents: diff changeset	2254 PSOldGen* old_gen) {
a61af66fc99e Initial load duke parents: diff changeset	2255 MutableSpace* const eden_space = young_gen->eden_space();
a61af66fc99e Initial load duke parents: diff changeset	2256 assert(!eden_space->is_empty(), "eden must be non-empty");
a61af66fc99e Initial load duke parents: diff changeset	2257 assert(young_gen->virtual_space()->alignment() ==
a61af66fc99e Initial load duke parents: diff changeset	2258 old_gen->virtual_space()->alignment(), "alignments do not match");
a61af66fc99e Initial load duke parents: diff changeset	2259
a61af66fc99e Initial load duke parents: diff changeset	2260 if (!(UseAdaptiveSizePolicy && UseAdaptiveGCBoundary)) {
a61af66fc99e Initial load duke parents: diff changeset	2261 return false;
a61af66fc99e Initial load duke parents: diff changeset	2262 }
a61af66fc99e Initial load duke parents: diff changeset	2263
a61af66fc99e Initial load duke parents: diff changeset	2264 // Both generations must be completely committed.
a61af66fc99e Initial load duke parents: diff changeset	2265 if (young_gen->virtual_space()->uncommitted_size() != 0) {
a61af66fc99e Initial load duke parents: diff changeset	2266 return false;
a61af66fc99e Initial load duke parents: diff changeset	2267 }
a61af66fc99e Initial load duke parents: diff changeset	2268 if (old_gen->virtual_space()->uncommitted_size() != 0) {
a61af66fc99e Initial load duke parents: diff changeset	2269 return false;
a61af66fc99e Initial load duke parents: diff changeset	2270 }
a61af66fc99e Initial load duke parents: diff changeset	2271
a61af66fc99e Initial load duke parents: diff changeset	2272 // Figure out how much to take from eden. Include the average amount promoted
a61af66fc99e Initial load duke parents: diff changeset	2273 // in the total; otherwise the next young gen GC will simply bail out to a
a61af66fc99e Initial load duke parents: diff changeset	2274 // full GC.
a61af66fc99e Initial load duke parents: diff changeset	2275 const size_t alignment = old_gen->virtual_space()->alignment();
a61af66fc99e Initial load duke parents: diff changeset	2276 const size_t eden_used = eden_space->used_in_bytes();
a61af66fc99e Initial load duke parents: diff changeset	2277 const size_t promoted = (size_t)size_policy->avg_promoted()->padded_average();
a61af66fc99e Initial load duke parents: diff changeset	2278 const size_t absorb_size = align_size_up(eden_used + promoted, alignment);
a61af66fc99e Initial load duke parents: diff changeset	2279 const size_t eden_capacity = eden_space->capacity_in_bytes();
a61af66fc99e Initial load duke parents: diff changeset	2280
a61af66fc99e Initial load duke parents: diff changeset	2281 if (absorb_size >= eden_capacity) {
a61af66fc99e Initial load duke parents: diff changeset	2282 return false; // Must leave some space in eden.
a61af66fc99e Initial load duke parents: diff changeset	2283 }
a61af66fc99e Initial load duke parents: diff changeset	2284
a61af66fc99e Initial load duke parents: diff changeset	2285 const size_t new_young_size = young_gen->capacity_in_bytes() - absorb_size;
a61af66fc99e Initial load duke parents: diff changeset	2286 if (new_young_size < young_gen->min_gen_size()) {
a61af66fc99e Initial load duke parents: diff changeset	2287 return false; // Respect young gen minimum size.
a61af66fc99e Initial load duke parents: diff changeset	2288 }
a61af66fc99e Initial load duke parents: diff changeset	2289
a61af66fc99e Initial load duke parents: diff changeset	2290 if (TraceAdaptiveGCBoundary && Verbose) {
a61af66fc99e Initial load duke parents: diff changeset	2291 gclog_or_tty->print(" absorbing " SIZE_FORMAT "K: "
a61af66fc99e Initial load duke parents: diff changeset	2292 "eden " SIZE_FORMAT "K->" SIZE_FORMAT "K "
a61af66fc99e Initial load duke parents: diff changeset	2293 "from " SIZE_FORMAT "K, to " SIZE_FORMAT "K "
a61af66fc99e Initial load duke parents: diff changeset	2294 "young_gen " SIZE_FORMAT "K->" SIZE_FORMAT "K ",
a61af66fc99e Initial load duke parents: diff changeset	2295 absorb_size / K,
a61af66fc99e Initial load duke parents: diff changeset	2296 eden_capacity / K, (eden_capacity - absorb_size) / K,
a61af66fc99e Initial load duke parents: diff changeset	2297 young_gen->from_space()->used_in_bytes() / K,
a61af66fc99e Initial load duke parents: diff changeset	2298 young_gen->to_space()->used_in_bytes() / K,
a61af66fc99e Initial load duke parents: diff changeset	2299 young_gen->capacity_in_bytes() / K, new_young_size / K);
a61af66fc99e Initial load duke parents: diff changeset	2300 }
a61af66fc99e Initial load duke parents: diff changeset	2301
a61af66fc99e Initial load duke parents: diff changeset	2302 // Fill the unused part of the old gen.
a61af66fc99e Initial load duke parents: diff changeset	2303 MutableSpace* const old_space = old_gen->object_space();
481 7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 457 diff changeset	2304 HeapWord* const unused_start = old_space->top();
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 457 diff changeset	2305 size_t const unused_words = pointer_delta(old_space->end(), unused_start);
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 457 diff changeset	2306
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 457 diff changeset	2307 if (unused_words > 0) {
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 457 diff changeset	2308 if (unused_words < CollectedHeap::min_fill_size()) {
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 457 diff changeset	2309 return false; // If the old gen cannot be filled, must give up.
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 457 diff changeset	2310 }
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 457 diff changeset	2311 CollectedHeap::fill_with_objects(unused_start, unused_words);
0 a61af66fc99e Initial load duke parents: diff changeset	2312 }
a61af66fc99e Initial load duke parents: diff changeset	2313
a61af66fc99e Initial load duke parents: diff changeset	2314 // Take the live data from eden and set both top and end in the old gen to
a61af66fc99e Initial load duke parents: diff changeset	2315 // eden top. (Need to set end because reset_after_change() mangles the region
a61af66fc99e Initial load duke parents: diff changeset	2316 // from end to virtual_space->high() in debug builds).
a61af66fc99e Initial load duke parents: diff changeset	2317 HeapWord* const new_top = eden_space->top();
a61af66fc99e Initial load duke parents: diff changeset	2318 old_gen->virtual_space()->expand_into(young_gen->virtual_space(),
a61af66fc99e Initial load duke parents: diff changeset	2319 absorb_size);
a61af66fc99e Initial load duke parents: diff changeset	2320 young_gen->reset_after_change();
a61af66fc99e Initial load duke parents: diff changeset	2321 old_space->set_top(new_top);
a61af66fc99e Initial load duke parents: diff changeset	2322 old_space->set_end(new_top);
a61af66fc99e Initial load duke parents: diff changeset	2323 old_gen->reset_after_change();
a61af66fc99e Initial load duke parents: diff changeset	2324
a61af66fc99e Initial load duke parents: diff changeset	2325 // Update the object start array for the filler object and the data from eden.
a61af66fc99e Initial load duke parents: diff changeset	2326 ObjectStartArray* const start_array = old_gen->start_array();
481 7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 457 diff changeset	2327 for (HeapWord* p = unused_start; p < new_top; p += oop(p)->size()) {
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 457 diff changeset	2328 start_array->allocate_block(p);
0 a61af66fc99e Initial load duke parents: diff changeset	2329 }
a61af66fc99e Initial load duke parents: diff changeset	2330
a61af66fc99e Initial load duke parents: diff changeset	2331 // Could update the promoted average here, but it is not typically updated at
a61af66fc99e Initial load duke parents: diff changeset	2332 // full GCs and the value to use is unclear. Something like
a61af66fc99e Initial load duke parents: diff changeset	2333 //
a61af66fc99e Initial load duke parents: diff changeset	2334 // cur_promoted_avg + absorb_size / number_of_scavenges_since_last_full_gc.
a61af66fc99e Initial load duke parents: diff changeset	2335
a61af66fc99e Initial load duke parents: diff changeset	2336 size_policy->set_bytes_absorbed_from_eden(absorb_size);
a61af66fc99e Initial load duke parents: diff changeset	2337 return true;
a61af66fc99e Initial load duke parents: diff changeset	2338 }
a61af66fc99e Initial load duke parents: diff changeset	2339
a61af66fc99e Initial load duke parents: diff changeset	2340 GCTaskManager* const PSParallelCompact::gc_task_manager() {
a61af66fc99e Initial load duke parents: diff changeset	2341 assert(ParallelScavengeHeap::gc_task_manager() != NULL,
a61af66fc99e Initial load duke parents: diff changeset	2342 "shouldn't return NULL");
a61af66fc99e Initial load duke parents: diff changeset	2343 return ParallelScavengeHeap::gc_task_manager();
a61af66fc99e Initial load duke parents: diff changeset	2344 }
a61af66fc99e Initial load duke parents: diff changeset	2345
a61af66fc99e Initial load duke parents: diff changeset	2346 void PSParallelCompact::marking_phase(ParCompactionManager* cm,
a61af66fc99e Initial load duke parents: diff changeset	2347 bool maximum_heap_compaction) {
a61af66fc99e Initial load duke parents: diff changeset	2348 // Recursively traverse all live objects and mark them
a61af66fc99e Initial load duke parents: diff changeset	2349 EventMark m("1 mark object");
a61af66fc99e Initial load duke parents: diff changeset	2350 TraceTime tm("marking phase", print_phases(), true, gclog_or_tty);
a61af66fc99e Initial load duke parents: diff changeset	2351
a61af66fc99e Initial load duke parents: diff changeset	2352 ParallelScavengeHeap* heap = gc_heap();
a61af66fc99e Initial load duke parents: diff changeset	2353 uint parallel_gc_threads = heap->gc_task_manager()->workers();
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2354 TaskQueueSetSuper* qset = ParCompactionManager::region_array();
0 a61af66fc99e Initial load duke parents: diff changeset	2355 ParallelTaskTerminator terminator(parallel_gc_threads, qset);
a61af66fc99e Initial load duke parents: diff changeset	2356
a61af66fc99e Initial load duke parents: diff changeset	2357 PSParallelCompact::MarkAndPushClosure mark_and_push_closure(cm);
a61af66fc99e Initial load duke parents: diff changeset	2358 PSParallelCompact::FollowStackClosure follow_stack_closure(cm);
a61af66fc99e Initial load duke parents: diff changeset	2359
a61af66fc99e Initial load duke parents: diff changeset	2360 {
a61af66fc99e Initial load duke parents: diff changeset	2361 TraceTime tm_m("par mark", print_phases(), true, gclog_or_tty);
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 696 diff changeset	2362 ParallelScavengeHeap::ParStrongRootsScope psrs;
0 a61af66fc99e Initial load duke parents: diff changeset	2363
a61af66fc99e Initial load duke parents: diff changeset	2364 GCTaskQueue* q = GCTaskQueue::create();
a61af66fc99e Initial load duke parents: diff changeset	2365
a61af66fc99e Initial load duke parents: diff changeset	2366 q->enqueue(new MarkFromRootsTask(MarkFromRootsTask::universe));
a61af66fc99e Initial load duke parents: diff changeset	2367 q->enqueue(new MarkFromRootsTask(MarkFromRootsTask::jni_handles));
a61af66fc99e Initial load duke parents: diff changeset	2368 // We scan the thread roots in parallel
a61af66fc99e Initial load duke parents: diff changeset	2369 Threads::create_thread_roots_marking_tasks(q);
a61af66fc99e Initial load duke parents: diff changeset	2370 q->enqueue(new MarkFromRootsTask(MarkFromRootsTask::object_synchronizer));
a61af66fc99e Initial load duke parents: diff changeset	2371 q->enqueue(new MarkFromRootsTask(MarkFromRootsTask::flat_profiler));
a61af66fc99e Initial load duke parents: diff changeset	2372 q->enqueue(new MarkFromRootsTask(MarkFromRootsTask::management));
a61af66fc99e Initial load duke parents: diff changeset	2373 q->enqueue(new MarkFromRootsTask(MarkFromRootsTask::system_dictionary));
a61af66fc99e Initial load duke parents: diff changeset	2374 q->enqueue(new MarkFromRootsTask(MarkFromRootsTask::jvmti));
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 696 diff changeset	2375 q->enqueue(new MarkFromRootsTask(MarkFromRootsTask::code_cache));
0 a61af66fc99e Initial load duke parents: diff changeset	2376
a61af66fc99e Initial load duke parents: diff changeset	2377 if (parallel_gc_threads > 1) {
a61af66fc99e Initial load duke parents: diff changeset	2378 for (uint j = 0; j < parallel_gc_threads; j++) {
a61af66fc99e Initial load duke parents: diff changeset	2379 q->enqueue(new StealMarkingTask(&terminator));
a61af66fc99e Initial load duke parents: diff changeset	2380 }
a61af66fc99e Initial load duke parents: diff changeset	2381 }
a61af66fc99e Initial load duke parents: diff changeset	2382
a61af66fc99e Initial load duke parents: diff changeset	2383 WaitForBarrierGCTask* fin = WaitForBarrierGCTask::create();
a61af66fc99e Initial load duke parents: diff changeset	2384 q->enqueue(fin);
a61af66fc99e Initial load duke parents: diff changeset	2385
a61af66fc99e Initial load duke parents: diff changeset	2386 gc_task_manager()->add_list(q);
a61af66fc99e Initial load duke parents: diff changeset	2387
a61af66fc99e Initial load duke parents: diff changeset	2388 fin->wait_for();
a61af66fc99e Initial load duke parents: diff changeset	2389
a61af66fc99e Initial load duke parents: diff changeset	2390 // We have to release the barrier tasks!
a61af66fc99e Initial load duke parents: diff changeset	2391 WaitForBarrierGCTask::destroy(fin);
a61af66fc99e Initial load duke parents: diff changeset	2392 }
a61af66fc99e Initial load duke parents: diff changeset	2393
a61af66fc99e Initial load duke parents: diff changeset	2394 // Process reference objects found during marking
a61af66fc99e Initial load duke parents: diff changeset	2395 {
a61af66fc99e Initial load duke parents: diff changeset	2396 TraceTime tm_r("reference processing", print_phases(), true, gclog_or_tty);
a61af66fc99e Initial load duke parents: diff changeset	2397 if (ref_processor()->processing_is_mt()) {
a61af66fc99e Initial load duke parents: diff changeset	2398 RefProcTaskExecutor task_executor;
a61af66fc99e Initial load duke parents: diff changeset	2399 ref_processor()->process_discovered_references(
453 c96030fff130 6684579: SoftReference processing can be made more efficient ysr parents: 376 diff changeset	2400 is_alive_closure(), &mark_and_push_closure, &follow_stack_closure,
c96030fff130 6684579: SoftReference processing can be made more efficient ysr parents: 376 diff changeset	2401 &task_executor);
0 a61af66fc99e Initial load duke parents: diff changeset	2402 } else {
a61af66fc99e Initial load duke parents: diff changeset	2403 ref_processor()->process_discovered_references(
453 c96030fff130 6684579: SoftReference processing can be made more efficient ysr parents: 376 diff changeset	2404 is_alive_closure(), &mark_and_push_closure, &follow_stack_closure, NULL);
0 a61af66fc99e Initial load duke parents: diff changeset	2405 }
a61af66fc99e Initial load duke parents: diff changeset	2406 }
a61af66fc99e Initial load duke parents: diff changeset	2407
a61af66fc99e Initial load duke parents: diff changeset	2408 TraceTime tm_c("class unloading", print_phases(), true, gclog_or_tty);
a61af66fc99e Initial load duke parents: diff changeset	2409 // Follow system dictionary roots and unload classes.
a61af66fc99e Initial load duke parents: diff changeset	2410 bool purged_class = SystemDictionary::do_unloading(is_alive_closure());
a61af66fc99e Initial load duke parents: diff changeset	2411
a61af66fc99e Initial load duke parents: diff changeset	2412 // Follow code cache roots.
a61af66fc99e Initial load duke parents: diff changeset	2413 CodeCache::do_unloading(is_alive_closure(), &mark_and_push_closure,
a61af66fc99e Initial load duke parents: diff changeset	2414 purged_class);
1311 2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 997 diff changeset	2415 cm->follow_marking_stacks(); // Flush marking stack.
0 a61af66fc99e Initial load duke parents: diff changeset	2416
a61af66fc99e Initial load duke parents: diff changeset	2417 // Update subklass/sibling/implementor links of live klasses
a61af66fc99e Initial load duke parents: diff changeset	2418 // revisit_klass_stack is used in follow_weak_klass_links().
941 8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 696 diff changeset	2419 follow_weak_klass_links();
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 696 diff changeset	2420
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 696 diff changeset	2421 // Revisit memoized MDO's and clear any unmarked weak refs
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 696 diff changeset	2422 follow_mdo_weak_refs();
0 a61af66fc99e Initial load duke parents: diff changeset	2423
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	2424 // Visit interned string tables and delete unmarked oops
0 a61af66fc99e Initial load duke parents: diff changeset	2425 StringTable::unlink(is_alive_closure());
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	2426 // Clean up unreferenced symbols in symbol table.
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	2427 SymbolTable::unlink();
0 a61af66fc99e Initial load duke parents: diff changeset	2428
1311 2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 997 diff changeset	2429 assert(cm->marking_stacks_empty(), "marking stacks should be empty");
0 a61af66fc99e Initial load duke parents: diff changeset	2430 }
a61af66fc99e Initial load duke parents: diff changeset	2431
a61af66fc99e Initial load duke parents: diff changeset	2432 // This should be moved to the shared markSweep code!
a61af66fc99e Initial load duke parents: diff changeset	2433 class PSAlwaysTrueClosure: public BoolObjectClosure {
a61af66fc99e Initial load duke parents: diff changeset	2434 public:
a61af66fc99e Initial load duke parents: diff changeset	2435 void do_object(oop p) { ShouldNotReachHere(); }
a61af66fc99e Initial load duke parents: diff changeset	2436 bool do_object_b(oop p) { return true; }
a61af66fc99e Initial load duke parents: diff changeset	2437 };
a61af66fc99e Initial load duke parents: diff changeset	2438 static PSAlwaysTrueClosure always_true;
a61af66fc99e Initial load duke parents: diff changeset	2439
a61af66fc99e Initial load duke parents: diff changeset	2440 void PSParallelCompact::adjust_roots() {
a61af66fc99e Initial load duke parents: diff changeset	2441 // Adjust the pointers to reflect the new locations
a61af66fc99e Initial load duke parents: diff changeset	2442 EventMark m("3 adjust roots");
a61af66fc99e Initial load duke parents: diff changeset	2443 TraceTime tm("adjust roots", print_phases(), true, gclog_or_tty);
a61af66fc99e Initial load duke parents: diff changeset	2444
a61af66fc99e Initial load duke parents: diff changeset	2445 // General strong roots.
a61af66fc99e Initial load duke parents: diff changeset	2446 Universe::oops_do(adjust_root_pointer_closure());
a61af66fc99e Initial load duke parents: diff changeset	2447 JNIHandles::oops_do(adjust_root_pointer_closure()); // Global (strong) JNI handles
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 696 diff changeset	2448 Threads::oops_do(adjust_root_pointer_closure(), NULL);
0 a61af66fc99e Initial load duke parents: diff changeset	2449 ObjectSynchronizer::oops_do(adjust_root_pointer_closure());
a61af66fc99e Initial load duke parents: diff changeset	2450 FlatProfiler::oops_do(adjust_root_pointer_closure());
a61af66fc99e Initial load duke parents: diff changeset	2451 Management::oops_do(adjust_root_pointer_closure());
a61af66fc99e Initial load duke parents: diff changeset	2452 JvmtiExport::oops_do(adjust_root_pointer_closure());
a61af66fc99e Initial load duke parents: diff changeset	2453 // SO_AllClasses
a61af66fc99e Initial load duke parents: diff changeset	2454 SystemDictionary::oops_do(adjust_root_pointer_closure());
a61af66fc99e Initial load duke parents: diff changeset	2455
a61af66fc99e Initial load duke parents: diff changeset	2456 // Now adjust pointers in remaining weak roots. (All of which should
a61af66fc99e Initial load duke parents: diff changeset	2457 // have been cleared if they pointed to non-surviving objects.)
a61af66fc99e Initial load duke parents: diff changeset	2458 // Global (weak) JNI handles
a61af66fc99e Initial load duke parents: diff changeset	2459 JNIHandles::weak_oops_do(&always_true, adjust_root_pointer_closure());
a61af66fc99e Initial load duke parents: diff changeset	2460
a61af66fc99e Initial load duke parents: diff changeset	2461 CodeCache::oops_do(adjust_pointer_closure());
a61af66fc99e Initial load duke parents: diff changeset	2462 StringTable::oops_do(adjust_root_pointer_closure());
a61af66fc99e Initial load duke parents: diff changeset	2463 ref_processor()->weak_oops_do(adjust_root_pointer_closure());
a61af66fc99e Initial load duke parents: diff changeset	2464 // Roots were visited so references into the young gen in roots
a61af66fc99e Initial load duke parents: diff changeset	2465 // may have been scanned. Process them also.
a61af66fc99e Initial load duke parents: diff changeset	2466 // Should the reference processor have a span that excludes
a61af66fc99e Initial load duke parents: diff changeset	2467 // young gen objects?
a61af66fc99e Initial load duke parents: diff changeset	2468 PSScavenge::reference_processor()->weak_oops_do(
a61af66fc99e Initial load duke parents: diff changeset	2469 adjust_root_pointer_closure());
a61af66fc99e Initial load duke parents: diff changeset	2470 }
a61af66fc99e Initial load duke parents: diff changeset	2471
a61af66fc99e Initial load duke parents: diff changeset	2472 void PSParallelCompact::compact_perm(ParCompactionManager* cm) {
a61af66fc99e Initial load duke parents: diff changeset	2473 EventMark m("4 compact perm");
a61af66fc99e Initial load duke parents: diff changeset	2474 TraceTime tm("compact perm gen", print_phases(), true, gclog_or_tty);
a61af66fc99e Initial load duke parents: diff changeset	2475 // trace("4");
a61af66fc99e Initial load duke parents: diff changeset	2476
a61af66fc99e Initial load duke parents: diff changeset	2477 gc_heap()->perm_gen()->start_array()->reset();
a61af66fc99e Initial load duke parents: diff changeset	2478 move_and_update(cm, perm_space_id);
a61af66fc99e Initial load duke parents: diff changeset	2479 }
a61af66fc99e Initial load duke parents: diff changeset	2480
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2481 void PSParallelCompact::enqueue_region_draining_tasks(GCTaskQueue* q,
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2482 uint parallel_gc_threads)
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2483 {
0 a61af66fc99e Initial load duke parents: diff changeset	2484 TraceTime tm("drain task setup", print_phases(), true, gclog_or_tty);
a61af66fc99e Initial load duke parents: diff changeset	2485
a61af66fc99e Initial load duke parents: diff changeset	2486 const unsigned int task_count = MAX2(parallel_gc_threads, 1U);
a61af66fc99e Initial load duke parents: diff changeset	2487 for (unsigned int j = 0; j < task_count; j++) {
1833 8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1638 diff changeset	2488 q->enqueue(new DrainStacksCompactionTask(j));
0 a61af66fc99e Initial load duke parents: diff changeset	2489 }
a61af66fc99e Initial load duke parents: diff changeset	2490
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2491 // Find all regions that are available (can be filled immediately) and
0 a61af66fc99e Initial load duke parents: diff changeset	2492 // distribute them to the thread stacks. The iteration is done in reverse
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2493 // order (high to low) so the regions will be removed in ascending order.
0 a61af66fc99e Initial load duke parents: diff changeset	2494
a61af66fc99e Initial load duke parents: diff changeset	2495 const ParallelCompactData& sd = PSParallelCompact::summary_data();
a61af66fc99e Initial load duke parents: diff changeset	2496
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2497 size_t fillable_regions = 0; // A count for diagnostic purposes.
0 a61af66fc99e Initial load duke parents: diff changeset	2498 unsigned int which = 0; // The worker thread number.
a61af66fc99e Initial load duke parents: diff changeset	2499
a61af66fc99e Initial load duke parents: diff changeset	2500 for (unsigned int id = to_space_id; id > perm_space_id; --id) {
a61af66fc99e Initial load duke parents: diff changeset	2501 SpaceInfo* const space_info = _space_info + id;
a61af66fc99e Initial load duke parents: diff changeset	2502 MutableSpace* const space = space_info->space();
a61af66fc99e Initial load duke parents: diff changeset	2503 HeapWord* const new_top = space_info->new_top();
a61af66fc99e Initial load duke parents: diff changeset	2504
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2505 const size_t beg_region = sd.addr_to_region_idx(space_info->dense_prefix());
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2506 const size_t end_region =
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2507 sd.addr_to_region_idx(sd.region_align_up(new_top));
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2508 assert(end_region > 0, "perm gen cannot be empty");
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2509
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2510 for (size_t cur = end_region - 1; cur >= beg_region; --cur) {
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2511 if (sd.region(cur)->claim_unsafe()) {
0 a61af66fc99e Initial load duke parents: diff changeset	2512 ParCompactionManager* cm = ParCompactionManager::manager_array(which);
1638 b2a00dd3117c 6957084: simplify TaskQueue overflow handling jcoomes parents: 1579 diff changeset	2513 cm->push_region(cur);
0 a61af66fc99e Initial load duke parents: diff changeset	2514
a61af66fc99e Initial load duke parents: diff changeset	2515 if (TraceParallelOldGCCompactionPhase && Verbose) {
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2516 const size_t count_mod_8 = fillable_regions & 7;
0 a61af66fc99e Initial load duke parents: diff changeset	2517 if (count_mod_8 == 0) gclog_or_tty->print("fillable: ");
264 15dd2594d08e 6718283: existing uses of _FORMAT_W() were broken by 6521491 jcoomes* parents: 263 diff changeset	2518 gclog_or_tty->print(" " SIZE_FORMAT_W(7), cur);
0 a61af66fc99e Initial load duke parents: diff changeset	2519 if (count_mod_8 == 7) gclog_or_tty->cr();
a61af66fc99e Initial load duke parents: diff changeset	2520 }
a61af66fc99e Initial load duke parents: diff changeset	2521
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2522 NOT_PRODUCT(++fillable_regions;)
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2523
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2524 // Assign regions to threads in round-robin fashion.
0 a61af66fc99e Initial load duke parents: diff changeset	2525 if (++which == task_count) {
a61af66fc99e Initial load duke parents: diff changeset	2526 which = 0;
a61af66fc99e Initial load duke parents: diff changeset	2527 }
a61af66fc99e Initial load duke parents: diff changeset	2528 }
a61af66fc99e Initial load duke parents: diff changeset	2529 }
a61af66fc99e Initial load duke parents: diff changeset	2530 }
a61af66fc99e Initial load duke parents: diff changeset	2531
a61af66fc99e Initial load duke parents: diff changeset	2532 if (TraceParallelOldGCCompactionPhase) {
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2533 if (Verbose && (fillable_regions & 7) != 0) gclog_or_tty->cr();
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2534 gclog_or_tty->print_cr("%u initially fillable regions", fillable_regions);
0 a61af66fc99e Initial load duke parents: diff changeset	2535 }
a61af66fc99e Initial load duke parents: diff changeset	2536 }
a61af66fc99e Initial load duke parents: diff changeset	2537
a61af66fc99e Initial load duke parents: diff changeset	2538 #define PAR_OLD_DENSE_PREFIX_OVER_PARTITIONING 4
a61af66fc99e Initial load duke parents: diff changeset	2539
a61af66fc99e Initial load duke parents: diff changeset	2540 void PSParallelCompact::enqueue_dense_prefix_tasks(GCTaskQueue* q,
a61af66fc99e Initial load duke parents: diff changeset	2541 uint parallel_gc_threads) {
a61af66fc99e Initial load duke parents: diff changeset	2542 TraceTime tm("dense prefix task setup", print_phases(), true, gclog_or_tty);
a61af66fc99e Initial load duke parents: diff changeset	2543
a61af66fc99e Initial load duke parents: diff changeset	2544 ParallelCompactData& sd = PSParallelCompact::summary_data();
a61af66fc99e Initial load duke parents: diff changeset	2545
a61af66fc99e Initial load duke parents: diff changeset	2546 // Iterate over all the spaces adding tasks for updating
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2547 // regions in the dense prefix. Assume that 1 gc thread
0 a61af66fc99e Initial load duke parents: diff changeset	2548 // will work on opening the gaps and the remaining gc threads
a61af66fc99e Initial load duke parents: diff changeset	2549 // will work on the dense prefix.
482 7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	2550 unsigned int space_id;
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	2551 for (space_id = old_space_id; space_id < last_space_id; ++ space_id) {
0 a61af66fc99e Initial load duke parents: diff changeset	2552 HeapWord* const dense_prefix_end = _space_info[space_id].dense_prefix();
a61af66fc99e Initial load duke parents: diff changeset	2553 const MutableSpace* const space = _space_info[space_id].space();
a61af66fc99e Initial load duke parents: diff changeset	2554
a61af66fc99e Initial load duke parents: diff changeset	2555 if (dense_prefix_end == space->bottom()) {
a61af66fc99e Initial load duke parents: diff changeset	2556 // There is no dense prefix for this space.
a61af66fc99e Initial load duke parents: diff changeset	2557 continue;
a61af66fc99e Initial load duke parents: diff changeset	2558 }
a61af66fc99e Initial load duke parents: diff changeset	2559
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2560 // The dense prefix is before this region.
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2561 size_t region_index_end_dense_prefix =
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2562 sd.addr_to_region_idx(dense_prefix_end);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2563 RegionData* const dense_prefix_cp =
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2564 sd.region(region_index_end_dense_prefix);
0 a61af66fc99e Initial load duke parents: diff changeset	2565 assert(dense_prefix_end == space->end() \|\|
a61af66fc99e Initial load duke parents: diff changeset	2566 dense_prefix_cp->available() \|\|
a61af66fc99e Initial load duke parents: diff changeset	2567 dense_prefix_cp->claimed(),
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2568 "The region after the dense prefix should always be ready to fill");
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2569
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2570 size_t region_index_start = sd.addr_to_region_idx(space->bottom());
0 a61af66fc99e Initial load duke parents: diff changeset	2571
a61af66fc99e Initial load duke parents: diff changeset	2572 // Is there dense prefix work?
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2573 size_t total_dense_prefix_regions =
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2574 region_index_end_dense_prefix - region_index_start;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2575 // How many regions of the dense prefix should be given to
0 a61af66fc99e Initial load duke parents: diff changeset	2576 // each thread?
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2577 if (total_dense_prefix_regions > 0) {
0 a61af66fc99e Initial load duke parents: diff changeset	2578 uint tasks_for_dense_prefix = 1;
3251 eda9eb483d29 6841742: par compact - remove unused/unsupported options jcoomes parents: 2369 diff changeset	2579 if (total_dense_prefix_regions <=
eda9eb483d29 6841742: par compact - remove unused/unsupported options jcoomes parents: 2369 diff changeset	2580 (parallel_gc_threads * PAR_OLD_DENSE_PREFIX_OVER_PARTITIONING)) {
eda9eb483d29 6841742: par compact - remove unused/unsupported options jcoomes parents: 2369 diff changeset	2581 // Don't over partition. This assumes that
eda9eb483d29 6841742: par compact - remove unused/unsupported options jcoomes parents: 2369 diff changeset	2582 // PAR_OLD_DENSE_PREFIX_OVER_PARTITIONING is a small integer value
eda9eb483d29 6841742: par compact - remove unused/unsupported options jcoomes parents: 2369 diff changeset	2583 // so there are not many regions to process.
eda9eb483d29 6841742: par compact - remove unused/unsupported options jcoomes parents: 2369 diff changeset	2584 tasks_for_dense_prefix = parallel_gc_threads;
eda9eb483d29 6841742: par compact - remove unused/unsupported options jcoomes parents: 2369 diff changeset	2585 } else {
eda9eb483d29 6841742: par compact - remove unused/unsupported options jcoomes parents: 2369 diff changeset	2586 // Over partition
eda9eb483d29 6841742: par compact - remove unused/unsupported options jcoomes parents: 2369 diff changeset	2587 tasks_for_dense_prefix = parallel_gc_threads *
eda9eb483d29 6841742: par compact - remove unused/unsupported options jcoomes parents: 2369 diff changeset	2588 PAR_OLD_DENSE_PREFIX_OVER_PARTITIONING;
0 a61af66fc99e Initial load duke parents: diff changeset	2589 }
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2590 size_t regions_per_thread = total_dense_prefix_regions /
0 a61af66fc99e Initial load duke parents: diff changeset	2591 tasks_for_dense_prefix;
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2592 // Give each thread at least 1 region.
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2593 if (regions_per_thread == 0) {
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2594 regions_per_thread = 1;
0 a61af66fc99e Initial load duke parents: diff changeset	2595 }
a61af66fc99e Initial load duke parents: diff changeset	2596
a61af66fc99e Initial load duke parents: diff changeset	2597 for (uint k = 0; k < tasks_for_dense_prefix; k++) {
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2598 if (region_index_start >= region_index_end_dense_prefix) {
0 a61af66fc99e Initial load duke parents: diff changeset	2599 break;
a61af66fc99e Initial load duke parents: diff changeset	2600 }
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2601 // region_index_end is not processed
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2602 size_t region_index_end = MIN2(region_index_start + regions_per_thread,
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2603 region_index_end_dense_prefix);
482 7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	2604 q->enqueue(new UpdateDensePrefixTask(SpaceId(space_id),
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	2605 region_index_start,
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	2606 region_index_end));
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2607 region_index_start = region_index_end;
0 a61af66fc99e Initial load duke parents: diff changeset	2608 }
a61af66fc99e Initial load duke parents: diff changeset	2609 }
a61af66fc99e Initial load duke parents: diff changeset	2610 // This gets any part of the dense prefix that did not
a61af66fc99e Initial load duke parents: diff changeset	2611 // fit evenly.
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2612 if (region_index_start < region_index_end_dense_prefix) {
482 7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	2613 q->enqueue(new UpdateDensePrefixTask(SpaceId(space_id),
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	2614 region_index_start,
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	2615 region_index_end_dense_prefix));
0 a61af66fc99e Initial load duke parents: diff changeset	2616 }
482 7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	2617 }
0 a61af66fc99e Initial load duke parents: diff changeset	2618 }
a61af66fc99e Initial load duke parents: diff changeset	2619
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2620 void PSParallelCompact::enqueue_region_stealing_tasks(
0 a61af66fc99e Initial load duke parents: diff changeset	2621 GCTaskQueue* q,
a61af66fc99e Initial load duke parents: diff changeset	2622 ParallelTaskTerminator* terminator_ptr,
a61af66fc99e Initial load duke parents: diff changeset	2623 uint parallel_gc_threads) {
a61af66fc99e Initial load duke parents: diff changeset	2624 TraceTime tm("steal task setup", print_phases(), true, gclog_or_tty);
a61af66fc99e Initial load duke parents: diff changeset	2625
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2626 // Once a thread has drained it's stack, it should try to steal regions from
0 a61af66fc99e Initial load duke parents: diff changeset	2627 // other threads.
a61af66fc99e Initial load duke parents: diff changeset	2628 if (parallel_gc_threads > 1) {
a61af66fc99e Initial load duke parents: diff changeset	2629 for (uint j = 0; j < parallel_gc_threads; j++) {
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2630 q->enqueue(new StealRegionCompactionTask(terminator_ptr));
0 a61af66fc99e Initial load duke parents: diff changeset	2631 }
a61af66fc99e Initial load duke parents: diff changeset	2632 }
a61af66fc99e Initial load duke parents: diff changeset	2633 }
a61af66fc99e Initial load duke parents: diff changeset	2634
a61af66fc99e Initial load duke parents: diff changeset	2635 void PSParallelCompact::compact() {
a61af66fc99e Initial load duke parents: diff changeset	2636 EventMark m("5 compact");
a61af66fc99e Initial load duke parents: diff changeset	2637 // trace("5");
a61af66fc99e Initial load duke parents: diff changeset	2638 TraceTime tm("compaction phase", print_phases(), true, gclog_or_tty);
a61af66fc99e Initial load duke parents: diff changeset	2639
a61af66fc99e Initial load duke parents: diff changeset	2640 ParallelScavengeHeap* heap = (ParallelScavengeHeap*)Universe::heap();
a61af66fc99e Initial load duke parents: diff changeset	2641 assert(heap->kind() == CollectedHeap::ParallelScavengeHeap, "Sanity");
a61af66fc99e Initial load duke parents: diff changeset	2642 PSOldGen* old_gen = heap->old_gen();
a61af66fc99e Initial load duke parents: diff changeset	2643 old_gen->start_array()->reset();
a61af66fc99e Initial load duke parents: diff changeset	2644 uint parallel_gc_threads = heap->gc_task_manager()->workers();
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2645 TaskQueueSetSuper* qset = ParCompactionManager::region_array();
0 a61af66fc99e Initial load duke parents: diff changeset	2646 ParallelTaskTerminator terminator(parallel_gc_threads, qset);
a61af66fc99e Initial load duke parents: diff changeset	2647
a61af66fc99e Initial load duke parents: diff changeset	2648 GCTaskQueue* q = GCTaskQueue::create();
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2649 enqueue_region_draining_tasks(q, parallel_gc_threads);
0 a61af66fc99e Initial load duke parents: diff changeset	2650 enqueue_dense_prefix_tasks(q, parallel_gc_threads);
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2651 enqueue_region_stealing_tasks(q, &terminator, parallel_gc_threads);
0 a61af66fc99e Initial load duke parents: diff changeset	2652
a61af66fc99e Initial load duke parents: diff changeset	2653 {
a61af66fc99e Initial load duke parents: diff changeset	2654 TraceTime tm_pc("par compact", print_phases(), true, gclog_or_tty);
a61af66fc99e Initial load duke parents: diff changeset	2655
a61af66fc99e Initial load duke parents: diff changeset	2656 WaitForBarrierGCTask* fin = WaitForBarrierGCTask::create();
a61af66fc99e Initial load duke parents: diff changeset	2657 q->enqueue(fin);
a61af66fc99e Initial load duke parents: diff changeset	2658
a61af66fc99e Initial load duke parents: diff changeset	2659 gc_task_manager()->add_list(q);
a61af66fc99e Initial load duke parents: diff changeset	2660
a61af66fc99e Initial load duke parents: diff changeset	2661 fin->wait_for();
a61af66fc99e Initial load duke parents: diff changeset	2662
a61af66fc99e Initial load duke parents: diff changeset	2663 // We have to release the barrier tasks!
a61af66fc99e Initial load duke parents: diff changeset	2664 WaitForBarrierGCTask::destroy(fin);
a61af66fc99e Initial load duke parents: diff changeset	2665
a61af66fc99e Initial load duke parents: diff changeset	2666 #ifdef ASSERT
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2667 // Verify that all regions have been processed before the deferred updates.
0 a61af66fc99e Initial load duke parents: diff changeset	2668 // Note that perm_space_id is skipped; this type of verification is not
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2669 // valid until the perm gen is compacted by regions.
0 a61af66fc99e Initial load duke parents: diff changeset	2670 for (unsigned int id = old_space_id; id < last_space_id; ++id) {
a61af66fc99e Initial load duke parents: diff changeset	2671 verify_complete(SpaceId(id));
a61af66fc99e Initial load duke parents: diff changeset	2672 }
a61af66fc99e Initial load duke parents: diff changeset	2673 #endif
a61af66fc99e Initial load duke parents: diff changeset	2674 }
a61af66fc99e Initial load duke parents: diff changeset	2675
a61af66fc99e Initial load duke parents: diff changeset	2676 {
a61af66fc99e Initial load duke parents: diff changeset	2677 // Update the deferred objects, if any. Any compaction manager can be used.
a61af66fc99e Initial load duke parents: diff changeset	2678 TraceTime tm_du("deferred updates", print_phases(), true, gclog_or_tty);
a61af66fc99e Initial load duke parents: diff changeset	2679 ParCompactionManager* cm = ParCompactionManager::manager_array(0);
a61af66fc99e Initial load duke parents: diff changeset	2680 for (unsigned int id = old_space_id; id < last_space_id; ++id) {
a61af66fc99e Initial load duke parents: diff changeset	2681 update_deferred_objects(cm, SpaceId(id));
a61af66fc99e Initial load duke parents: diff changeset	2682 }
a61af66fc99e Initial load duke parents: diff changeset	2683 }
a61af66fc99e Initial load duke parents: diff changeset	2684 }
a61af66fc99e Initial load duke parents: diff changeset	2685
a61af66fc99e Initial load duke parents: diff changeset	2686 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	2687 void PSParallelCompact::verify_complete(SpaceId space_id) {
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2688 // All Regions between space bottom() to new_top() should be marked as filled
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2689 // and all Regions between new_top() and top() should be available (i.e.,
0 a61af66fc99e Initial load duke parents: diff changeset	2690 // should have been emptied).
a61af66fc99e Initial load duke parents: diff changeset	2691 ParallelCompactData& sd = summary_data();
a61af66fc99e Initial load duke parents: diff changeset	2692 SpaceInfo si = _space_info[space_id];
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2693 HeapWord* new_top_addr = sd.region_align_up(si.new_top());
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2694 HeapWord* old_top_addr = sd.region_align_up(si.space()->top());
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2695 const size_t beg_region = sd.addr_to_region_idx(si.space()->bottom());
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2696 const size_t new_top_region = sd.addr_to_region_idx(new_top_addr);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2697 const size_t old_top_region = sd.addr_to_region_idx(old_top_addr);
0 a61af66fc99e Initial load duke parents: diff changeset	2698
a61af66fc99e Initial load duke parents: diff changeset	2699 bool issued_a_warning = false;
a61af66fc99e Initial load duke parents: diff changeset	2700
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2701 size_t cur_region;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2702 for (cur_region = beg_region; cur_region < new_top_region; ++cur_region) {
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2703 const RegionData* const c = sd.region(cur_region);
0 a61af66fc99e Initial load duke parents: diff changeset	2704 if (!c->completed()) {
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2705 warning("region " SIZE_FORMAT " not filled: "
0 a61af66fc99e Initial load duke parents: diff changeset	2706 "destination_count=" SIZE_FORMAT,
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2707 cur_region, c->destination_count());
0 a61af66fc99e Initial load duke parents: diff changeset	2708 issued_a_warning = true;
a61af66fc99e Initial load duke parents: diff changeset	2709 }
a61af66fc99e Initial load duke parents: diff changeset	2710 }
a61af66fc99e Initial load duke parents: diff changeset	2711
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2712 for (cur_region = new_top_region; cur_region < old_top_region; ++cur_region) {
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2713 const RegionData* const c = sd.region(cur_region);
0 a61af66fc99e Initial load duke parents: diff changeset	2714 if (!c->available()) {
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2715 warning("region " SIZE_FORMAT " not empty: "
0 a61af66fc99e Initial load duke parents: diff changeset	2716 "destination_count=" SIZE_FORMAT,
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2717 cur_region, c->destination_count());
0 a61af66fc99e Initial load duke parents: diff changeset	2718 issued_a_warning = true;
a61af66fc99e Initial load duke parents: diff changeset	2719 }
a61af66fc99e Initial load duke parents: diff changeset	2720 }
a61af66fc99e Initial load duke parents: diff changeset	2721
a61af66fc99e Initial load duke parents: diff changeset	2722 if (issued_a_warning) {
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2723 print_region_ranges();
0 a61af66fc99e Initial load duke parents: diff changeset	2724 }
a61af66fc99e Initial load duke parents: diff changeset	2725 }
a61af66fc99e Initial load duke parents: diff changeset	2726 #endif // #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	2727
a61af66fc99e Initial load duke parents: diff changeset	2728 void
941 8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 696 diff changeset	2729 PSParallelCompact::follow_weak_klass_links() {
0 a61af66fc99e Initial load duke parents: diff changeset	2730 // All klasses on the revisit stack are marked at this point.
a61af66fc99e Initial load duke parents: diff changeset	2731 // Update and follow all subklass, sibling and implementor links.
941 8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 696 diff changeset	2732 if (PrintRevisitStats) {
1836 894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1833 diff changeset	2733 gclog_or_tty->print_cr("#classes in system dictionary = %d",
894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1833 diff changeset	2734 SystemDictionary::number_of_classes());
941 8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 696 diff changeset	2735 }
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 696 diff changeset	2736 for (uint i = 0; i < ParallelGCThreads + 1; i++) {
0 a61af66fc99e Initial load duke parents: diff changeset	2737 ParCompactionManager* cm = ParCompactionManager::manager_array(i);
a61af66fc99e Initial load duke parents: diff changeset	2738 KeepAliveClosure keep_alive_closure(cm);
1836 894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1833 diff changeset	2739 Stack<Klass> const rks = cm->revisit_klass_stack();
941 8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 696 diff changeset	2740 if (PrintRevisitStats) {
1836 894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1833 diff changeset	2741 gclog_or_tty->print_cr("Revisit klass stack[%u] length = " SIZE_FORMAT,
894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1833 diff changeset	2742 i, rks->size());
941 8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 696 diff changeset	2743 }
1836 894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1833 diff changeset	2744 while (!rks->is_empty()) {
894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1833 diff changeset	2745 Klass* const k = rks->pop();
894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1833 diff changeset	2746 k->follow_weak_klass_links(is_alive_closure(), &keep_alive_closure);
0 a61af66fc99e Initial load duke parents: diff changeset	2747 }
1836 894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1833 diff changeset	2748
1311 2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 997 diff changeset	2749 cm->follow_marking_stacks();
0 a61af66fc99e Initial load duke parents: diff changeset	2750 }
a61af66fc99e Initial load duke parents: diff changeset	2751 }
a61af66fc99e Initial load duke parents: diff changeset	2752
a61af66fc99e Initial load duke parents: diff changeset	2753 void
a61af66fc99e Initial load duke parents: diff changeset	2754 PSParallelCompact::revisit_weak_klass_link(ParCompactionManager* cm, Klass* k) {
a61af66fc99e Initial load duke parents: diff changeset	2755 cm->revisit_klass_stack()->push(k);
a61af66fc99e Initial load duke parents: diff changeset	2756 }
a61af66fc99e Initial load duke parents: diff changeset	2757
941 8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 696 diff changeset	2758 void PSParallelCompact::revisit_mdo(ParCompactionManager* cm, DataLayout* p) {
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 696 diff changeset	2759 cm->revisit_mdo_stack()->push(p);
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 696 diff changeset	2760 }
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 696 diff changeset	2761
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 696 diff changeset	2762 void PSParallelCompact::follow_mdo_weak_refs() {
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 696 diff changeset	2763 // All strongly reachable oops have been marked at this point;
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 696 diff changeset	2764 // we can visit and clear any weak references from MDO's which
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 696 diff changeset	2765 // we memoized during the strong marking phase.
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 696 diff changeset	2766 if (PrintRevisitStats) {
1836 894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1833 diff changeset	2767 gclog_or_tty->print_cr("#classes in system dictionary = %d",
894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1833 diff changeset	2768 SystemDictionary::number_of_classes());
941 8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 696 diff changeset	2769 }
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 696 diff changeset	2770 for (uint i = 0; i < ParallelGCThreads + 1; i++) {
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 696 diff changeset	2771 ParCompactionManager* cm = ParCompactionManager::manager_array(i);
1836 894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1833 diff changeset	2772 Stack<DataLayout> rms = cm->revisit_mdo_stack();
941 8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 696 diff changeset	2773 if (PrintRevisitStats) {
1836 894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1833 diff changeset	2774 gclog_or_tty->print_cr("Revisit MDO stack[%u] size = " SIZE_FORMAT,
894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1833 diff changeset	2775 i, rms->size());
941 8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 696 diff changeset	2776 }
1836 894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1833 diff changeset	2777 while (!rms->is_empty()) {
894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1833 diff changeset	2778 rms->pop()->follow_weak_refs(is_alive_closure());
941 8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 696 diff changeset	2779 }
1836 894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1833 diff changeset	2780
1311 2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 997 diff changeset	2781 cm->follow_marking_stacks();
941 8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 696 diff changeset	2782 }
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 696 diff changeset	2783 }
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 696 diff changeset	2784
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 696 diff changeset	2785
0 a61af66fc99e Initial load duke parents: diff changeset	2786 #ifdef VALIDATE_MARK_SWEEP
a61af66fc99e Initial load duke parents: diff changeset	2787
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 79 diff changeset	2788 void PSParallelCompact::track_adjusted_pointer(void* p, bool isroot) {
0 a61af66fc99e Initial load duke parents: diff changeset	2789 if (!ValidateMarkSweep)
a61af66fc99e Initial load duke parents: diff changeset	2790 return;
a61af66fc99e Initial load duke parents: diff changeset	2791
a61af66fc99e Initial load duke parents: diff changeset	2792 if (!isroot) {
a61af66fc99e Initial load duke parents: diff changeset	2793 if (_pointer_tracking) {
a61af66fc99e Initial load duke parents: diff changeset	2794 guarantee(_adjusted_pointers->contains(p), "should have seen this pointer");
a61af66fc99e Initial load duke parents: diff changeset	2795 _adjusted_pointers->remove(p);
a61af66fc99e Initial load duke parents: diff changeset	2796 }
a61af66fc99e Initial load duke parents: diff changeset	2797 } else {
a61af66fc99e Initial load duke parents: diff changeset	2798 ptrdiff_t index = _root_refs_stack->find(p);
a61af66fc99e Initial load duke parents: diff changeset	2799 if (index != -1) {
a61af66fc99e Initial load duke parents: diff changeset	2800 int l = _root_refs_stack->length();
a61af66fc99e Initial load duke parents: diff changeset	2801 if (l > 0 && l - 1 != index) {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 79 diff changeset	2802 void* last = _root_refs_stack->pop();
0 a61af66fc99e Initial load duke parents: diff changeset	2803 assert(last != p, "should be different");
a61af66fc99e Initial load duke parents: diff changeset	2804 _root_refs_stack->at_put(index, last);
a61af66fc99e Initial load duke parents: diff changeset	2805 } else {
a61af66fc99e Initial load duke parents: diff changeset	2806 _root_refs_stack->remove(p);
a61af66fc99e Initial load duke parents: diff changeset	2807 }
a61af66fc99e Initial load duke parents: diff changeset	2808 }
a61af66fc99e Initial load duke parents: diff changeset	2809 }
a61af66fc99e Initial load duke parents: diff changeset	2810 }
a61af66fc99e Initial load duke parents: diff changeset	2811
a61af66fc99e Initial load duke parents: diff changeset	2812
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 79 diff changeset	2813 void PSParallelCompact::check_adjust_pointer(void* p) {
0 a61af66fc99e Initial load duke parents: diff changeset	2814 _adjusted_pointers->push(p);
a61af66fc99e Initial load duke parents: diff changeset	2815 }
a61af66fc99e Initial load duke parents: diff changeset	2816
a61af66fc99e Initial load duke parents: diff changeset	2817
a61af66fc99e Initial load duke parents: diff changeset	2818 class AdjusterTracker: public OopClosure {
a61af66fc99e Initial load duke parents: diff changeset	2819 public:
a61af66fc99e Initial load duke parents: diff changeset	2820 AdjusterTracker() {};
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 79 diff changeset	2821 void do_oop(oop* o) { PSParallelCompact::check_adjust_pointer(o); }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 79 diff changeset	2822 void do_oop(narrowOop* o) { PSParallelCompact::check_adjust_pointer(o); }
0 a61af66fc99e Initial load duke parents: diff changeset	2823 };
a61af66fc99e Initial load duke parents: diff changeset	2824
a61af66fc99e Initial load duke parents: diff changeset	2825
a61af66fc99e Initial load duke parents: diff changeset	2826 void PSParallelCompact::track_interior_pointers(oop obj) {
a61af66fc99e Initial load duke parents: diff changeset	2827 if (ValidateMarkSweep) {
a61af66fc99e Initial load duke parents: diff changeset	2828 _adjusted_pointers->clear();
a61af66fc99e Initial load duke parents: diff changeset	2829 _pointer_tracking = true;
a61af66fc99e Initial load duke parents: diff changeset	2830
a61af66fc99e Initial load duke parents: diff changeset	2831 AdjusterTracker checker;
a61af66fc99e Initial load duke parents: diff changeset	2832 obj->oop_iterate(&checker);
a61af66fc99e Initial load duke parents: diff changeset	2833 }
a61af66fc99e Initial load duke parents: diff changeset	2834 }
a61af66fc99e Initial load duke parents: diff changeset	2835
a61af66fc99e Initial load duke parents: diff changeset	2836
a61af66fc99e Initial load duke parents: diff changeset	2837 void PSParallelCompact::check_interior_pointers() {
a61af66fc99e Initial load duke parents: diff changeset	2838 if (ValidateMarkSweep) {
a61af66fc99e Initial load duke parents: diff changeset	2839 _pointer_tracking = false;
a61af66fc99e Initial load duke parents: diff changeset	2840 guarantee(_adjusted_pointers->length() == 0, "should have processed the same pointers");
a61af66fc99e Initial load duke parents: diff changeset	2841 }
a61af66fc99e Initial load duke parents: diff changeset	2842 }
a61af66fc99e Initial load duke parents: diff changeset	2843
a61af66fc99e Initial load duke parents: diff changeset	2844
a61af66fc99e Initial load duke parents: diff changeset	2845 void PSParallelCompact::reset_live_oop_tracking(bool at_perm) {
a61af66fc99e Initial load duke parents: diff changeset	2846 if (ValidateMarkSweep) {
a61af66fc99e Initial load duke parents: diff changeset	2847 guarantee((size_t)_live_oops->length() == _live_oops_index, "should be at end of live oops");
a61af66fc99e Initial load duke parents: diff changeset	2848 _live_oops_index = at_perm ? _live_oops_index_at_perm : 0;
a61af66fc99e Initial load duke parents: diff changeset	2849 }
a61af66fc99e Initial load duke parents: diff changeset	2850 }
a61af66fc99e Initial load duke parents: diff changeset	2851
a61af66fc99e Initial load duke parents: diff changeset	2852
a61af66fc99e Initial load duke parents: diff changeset	2853 void PSParallelCompact::register_live_oop(oop p, size_t size) {
a61af66fc99e Initial load duke parents: diff changeset	2854 if (ValidateMarkSweep) {
a61af66fc99e Initial load duke parents: diff changeset	2855 _live_oops->push(p);
a61af66fc99e Initial load duke parents: diff changeset	2856 _live_oops_size->push(size);
a61af66fc99e Initial load duke parents: diff changeset	2857 _live_oops_index++;
a61af66fc99e Initial load duke parents: diff changeset	2858 }
a61af66fc99e Initial load duke parents: diff changeset	2859 }
a61af66fc99e Initial load duke parents: diff changeset	2860
a61af66fc99e Initial load duke parents: diff changeset	2861 void PSParallelCompact::validate_live_oop(oop p, size_t size) {
a61af66fc99e Initial load duke parents: diff changeset	2862 if (ValidateMarkSweep) {
a61af66fc99e Initial load duke parents: diff changeset	2863 oop obj = _live_oops->at((int)_live_oops_index);
a61af66fc99e Initial load duke parents: diff changeset	2864 guarantee(obj == p, "should be the same object");
a61af66fc99e Initial load duke parents: diff changeset	2865 guarantee(_live_oops_size->at((int)_live_oops_index) == size, "should be the same size");
a61af66fc99e Initial load duke parents: diff changeset	2866 _live_oops_index++;
a61af66fc99e Initial load duke parents: diff changeset	2867 }
a61af66fc99e Initial load duke parents: diff changeset	2868 }
a61af66fc99e Initial load duke parents: diff changeset	2869
a61af66fc99e Initial load duke parents: diff changeset	2870 void PSParallelCompact::live_oop_moved_to(HeapWord* q, size_t size,
a61af66fc99e Initial load duke parents: diff changeset	2871 HeapWord* compaction_top) {
a61af66fc99e Initial load duke parents: diff changeset	2872 assert(oop(q)->forwardee() == NULL \|\| oop(q)->forwardee() == oop(compaction_top),
a61af66fc99e Initial load duke parents: diff changeset	2873 "should be moved to forwarded location");
a61af66fc99e Initial load duke parents: diff changeset	2874 if (ValidateMarkSweep) {
a61af66fc99e Initial load duke parents: diff changeset	2875 PSParallelCompact::validate_live_oop(oop(q), size);
a61af66fc99e Initial load duke parents: diff changeset	2876 _live_oops_moved_to->push(oop(compaction_top));
a61af66fc99e Initial load duke parents: diff changeset	2877 }
a61af66fc99e Initial load duke parents: diff changeset	2878 if (RecordMarkSweepCompaction) {
a61af66fc99e Initial load duke parents: diff changeset	2879 _cur_gc_live_oops->push(q);
a61af66fc99e Initial load duke parents: diff changeset	2880 _cur_gc_live_oops_moved_to->push(compaction_top);
a61af66fc99e Initial load duke parents: diff changeset	2881 _cur_gc_live_oops_size->push(size);
a61af66fc99e Initial load duke parents: diff changeset	2882 }
a61af66fc99e Initial load duke parents: diff changeset	2883 }
a61af66fc99e Initial load duke parents: diff changeset	2884
a61af66fc99e Initial load duke parents: diff changeset	2885
a61af66fc99e Initial load duke parents: diff changeset	2886 void PSParallelCompact::compaction_complete() {
a61af66fc99e Initial load duke parents: diff changeset	2887 if (RecordMarkSweepCompaction) {
a61af66fc99e Initial load duke parents: diff changeset	2888 GrowableArray<HeapWord> _tmp_live_oops = _cur_gc_live_oops;
a61af66fc99e Initial load duke parents: diff changeset	2889 GrowableArray<HeapWord> _tmp_live_oops_moved_to = _cur_gc_live_oops_moved_to;
a61af66fc99e Initial load duke parents: diff changeset	2890 GrowableArray<size_t> * _tmp_live_oops_size = _cur_gc_live_oops_size;
a61af66fc99e Initial load duke parents: diff changeset	2891
a61af66fc99e Initial load duke parents: diff changeset	2892 _cur_gc_live_oops = _last_gc_live_oops;
a61af66fc99e Initial load duke parents: diff changeset	2893 _cur_gc_live_oops_moved_to = _last_gc_live_oops_moved_to;
a61af66fc99e Initial load duke parents: diff changeset	2894 _cur_gc_live_oops_size = _last_gc_live_oops_size;
a61af66fc99e Initial load duke parents: diff changeset	2895 _last_gc_live_oops = _tmp_live_oops;
a61af66fc99e Initial load duke parents: diff changeset	2896 _last_gc_live_oops_moved_to = _tmp_live_oops_moved_to;
a61af66fc99e Initial load duke parents: diff changeset	2897 _last_gc_live_oops_size = _tmp_live_oops_size;
a61af66fc99e Initial load duke parents: diff changeset	2898 }
a61af66fc99e Initial load duke parents: diff changeset	2899 }
a61af66fc99e Initial load duke parents: diff changeset	2900
a61af66fc99e Initial load duke parents: diff changeset	2901
a61af66fc99e Initial load duke parents: diff changeset	2902 void PSParallelCompact::print_new_location_of_heap_address(HeapWord* q) {
a61af66fc99e Initial load duke parents: diff changeset	2903 if (!RecordMarkSweepCompaction) {
a61af66fc99e Initial load duke parents: diff changeset	2904 tty->print_cr("Requires RecordMarkSweepCompaction to be enabled");
a61af66fc99e Initial load duke parents: diff changeset	2905 return;
a61af66fc99e Initial load duke parents: diff changeset	2906 }
a61af66fc99e Initial load duke parents: diff changeset	2907
a61af66fc99e Initial load duke parents: diff changeset	2908 if (_last_gc_live_oops == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	2909 tty->print_cr("No compaction information gathered yet");
a61af66fc99e Initial load duke parents: diff changeset	2910 return;
a61af66fc99e Initial load duke parents: diff changeset	2911 }
a61af66fc99e Initial load duke parents: diff changeset	2912
a61af66fc99e Initial load duke parents: diff changeset	2913 for (int i = 0; i < _last_gc_live_oops->length(); i++) {
a61af66fc99e Initial load duke parents: diff changeset	2914 HeapWord* old_oop = _last_gc_live_oops->at(i);
a61af66fc99e Initial load duke parents: diff changeset	2915 size_t sz = _last_gc_live_oops_size->at(i);
a61af66fc99e Initial load duke parents: diff changeset	2916 if (old_oop <= q && q < (old_oop + sz)) {
a61af66fc99e Initial load duke parents: diff changeset	2917 HeapWord* new_oop = _last_gc_live_oops_moved_to->at(i);
a61af66fc99e Initial load duke parents: diff changeset	2918 size_t offset = (q - old_oop);
a61af66fc99e Initial load duke parents: diff changeset	2919 tty->print_cr("Address " PTR_FORMAT, q);
a61af66fc99e Initial load duke parents: diff changeset	2920 tty->print_cr(" Was in oop " PTR_FORMAT ", size %d, at offset %d", old_oop, sz, offset);
a61af66fc99e Initial load duke parents: diff changeset	2921 tty->print_cr(" Now in oop " PTR_FORMAT ", actual address " PTR_FORMAT, new_oop, new_oop + offset);
a61af66fc99e Initial load duke parents: diff changeset	2922 return;
a61af66fc99e Initial load duke parents: diff changeset	2923 }
a61af66fc99e Initial load duke parents: diff changeset	2924 }
a61af66fc99e Initial load duke parents: diff changeset	2925
a61af66fc99e Initial load duke parents: diff changeset	2926 tty->print_cr("Address " PTR_FORMAT " not found in live oop information from last GC", q);
a61af66fc99e Initial load duke parents: diff changeset	2927 }
a61af66fc99e Initial load duke parents: diff changeset	2928 #endif //VALIDATE_MARK_SWEEP
a61af66fc99e Initial load duke parents: diff changeset	2929
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2930 // Update interior oops in the ranges of regions [beg_region, end_region).
0 a61af66fc99e Initial load duke parents: diff changeset	2931 void
a61af66fc99e Initial load duke parents: diff changeset	2932 PSParallelCompact::update_and_deadwood_in_dense_prefix(ParCompactionManager* cm,
a61af66fc99e Initial load duke parents: diff changeset	2933 SpaceId space_id,
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2934 size_t beg_region,
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2935 size_t end_region) {
0 a61af66fc99e Initial load duke parents: diff changeset	2936 ParallelCompactData& sd = summary_data();
a61af66fc99e Initial load duke parents: diff changeset	2937 ParMarkBitMap* const mbm = mark_bitmap();
a61af66fc99e Initial load duke parents: diff changeset	2938
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2939 HeapWord* beg_addr = sd.region_to_addr(beg_region);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2940 HeapWord* const end_addr = sd.region_to_addr(end_region);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2941 assert(beg_region <= end_region, "bad region range");
0 a61af66fc99e Initial load duke parents: diff changeset	2942 assert(end_addr <= dense_prefix(space_id), "not in the dense prefix");
a61af66fc99e Initial load duke parents: diff changeset	2943
a61af66fc99e Initial load duke parents: diff changeset	2944 #ifdef ASSERT
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2945 // Claim the regions to avoid triggering an assert when they are marked as
0 a61af66fc99e Initial load duke parents: diff changeset	2946 // filled.
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2947 for (size_t claim_region = beg_region; claim_region < end_region; ++claim_region) {
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2948 assert(sd.region(claim_region)->claim_unsafe(), "claim() failed");
0 a61af66fc99e Initial load duke parents: diff changeset	2949 }
a61af66fc99e Initial load duke parents: diff changeset	2950 #endif // #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	2951
a61af66fc99e Initial load duke parents: diff changeset	2952 if (beg_addr != space(space_id)->bottom()) {
a61af66fc99e Initial load duke parents: diff changeset	2953 // Find the first live object or block of dead space that starts in this
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2954 // range of regions. If a partial object crosses onto the region, skip it;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2955 // it will be marked for 'deferred update' when the object head is
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2956 // processed. If dead space crosses onto the region, it is also skipped; it
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2957 // will be filled when the prior region is processed. If neither of those
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2958 // apply, the first word in the region is the start of a live object or dead
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2959 // space.
0 a61af66fc99e Initial load duke parents: diff changeset	2960 assert(beg_addr > space(space_id)->bottom(), "sanity");
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2961 const RegionData* const cp = sd.region(beg_region);
0 a61af66fc99e Initial load duke parents: diff changeset	2962 if (cp->partial_obj_size() != 0) {
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2963 beg_addr = sd.partial_obj_end(beg_region);
0 a61af66fc99e Initial load duke parents: diff changeset	2964 } else if (dead_space_crosses_boundary(cp, mbm->addr_to_bit(beg_addr))) {
a61af66fc99e Initial load duke parents: diff changeset	2965 beg_addr = mbm->find_obj_beg(beg_addr, end_addr);
a61af66fc99e Initial load duke parents: diff changeset	2966 }
a61af66fc99e Initial load duke parents: diff changeset	2967 }
a61af66fc99e Initial load duke parents: diff changeset	2968
a61af66fc99e Initial load duke parents: diff changeset	2969 if (beg_addr < end_addr) {
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2970 // A live object or block of dead space starts in this range of Regions.
0 a61af66fc99e Initial load duke parents: diff changeset	2971 HeapWord* const dense_prefix_end = dense_prefix(space_id);
a61af66fc99e Initial load duke parents: diff changeset	2972
a61af66fc99e Initial load duke parents: diff changeset	2973 // Create closures and iterate.
a61af66fc99e Initial load duke parents: diff changeset	2974 UpdateOnlyClosure update_closure(mbm, cm, space_id);
a61af66fc99e Initial load duke parents: diff changeset	2975 FillClosure fill_closure(cm, space_id);
a61af66fc99e Initial load duke parents: diff changeset	2976 ParMarkBitMap::IterationStatus status;
a61af66fc99e Initial load duke parents: diff changeset	2977 status = mbm->iterate(&update_closure, &fill_closure, beg_addr, end_addr,
a61af66fc99e Initial load duke parents: diff changeset	2978 dense_prefix_end);
a61af66fc99e Initial load duke parents: diff changeset	2979 if (status == ParMarkBitMap::incomplete) {
a61af66fc99e Initial load duke parents: diff changeset	2980 update_closure.do_addr(update_closure.source());
a61af66fc99e Initial load duke parents: diff changeset	2981 }
a61af66fc99e Initial load duke parents: diff changeset	2982 }
a61af66fc99e Initial load duke parents: diff changeset	2983
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2984 // Mark the regions as filled.
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2985 RegionData* const beg_cp = sd.region(beg_region);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2986 RegionData* const end_cp = sd.region(end_region);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	2987 for (RegionData* cp = beg_cp; cp < end_cp; ++cp) {
0 a61af66fc99e Initial load duke parents: diff changeset	2988 cp->set_completed();
a61af66fc99e Initial load duke parents: diff changeset	2989 }
a61af66fc99e Initial load duke parents: diff changeset	2990 }
a61af66fc99e Initial load duke parents: diff changeset	2991
a61af66fc99e Initial load duke parents: diff changeset	2992 // Return the SpaceId for the space containing addr. If addr is not in the
a61af66fc99e Initial load duke parents: diff changeset	2993 // heap, last_space_id is returned. In debug mode it expects the address to be
a61af66fc99e Initial load duke parents: diff changeset	2994 // in the heap and asserts such.
a61af66fc99e Initial load duke parents: diff changeset	2995 PSParallelCompact::SpaceId PSParallelCompact::space_id(HeapWord* addr) {
a61af66fc99e Initial load duke parents: diff changeset	2996 assert(Universe::heap()->is_in_reserved(addr), "addr not in the heap");
a61af66fc99e Initial load duke parents: diff changeset	2997
a61af66fc99e Initial load duke parents: diff changeset	2998 for (unsigned int id = perm_space_id; id < last_space_id; ++id) {
a61af66fc99e Initial load duke parents: diff changeset	2999 if (_space_info[id].space()->contains(addr)) {
a61af66fc99e Initial load duke parents: diff changeset	3000 return SpaceId(id);
a61af66fc99e Initial load duke parents: diff changeset	3001 }
a61af66fc99e Initial load duke parents: diff changeset	3002 }
a61af66fc99e Initial load duke parents: diff changeset	3003
a61af66fc99e Initial load duke parents: diff changeset	3004 assert(false, "no space contains the addr");
a61af66fc99e Initial load duke parents: diff changeset	3005 return last_space_id;
a61af66fc99e Initial load duke parents: diff changeset	3006 }
a61af66fc99e Initial load duke parents: diff changeset	3007
a61af66fc99e Initial load duke parents: diff changeset	3008 void PSParallelCompact::update_deferred_objects(ParCompactionManager* cm,
a61af66fc99e Initial load duke parents: diff changeset	3009 SpaceId id) {
a61af66fc99e Initial load duke parents: diff changeset	3010 assert(id < last_space_id, "bad space id");
a61af66fc99e Initial load duke parents: diff changeset	3011
a61af66fc99e Initial load duke parents: diff changeset	3012 ParallelCompactData& sd = summary_data();
a61af66fc99e Initial load duke parents: diff changeset	3013 const SpaceInfo* const space_info = _space_info + id;
a61af66fc99e Initial load duke parents: diff changeset	3014 ObjectStartArray* const start_array = space_info->start_array();
a61af66fc99e Initial load duke parents: diff changeset	3015
a61af66fc99e Initial load duke parents: diff changeset	3016 const MutableSpace* const space = space_info->space();
a61af66fc99e Initial load duke parents: diff changeset	3017 assert(space_info->dense_prefix() >= space->bottom(), "dense_prefix not set");
a61af66fc99e Initial load duke parents: diff changeset	3018 HeapWord* const beg_addr = space_info->dense_prefix();
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3019 HeapWord* const end_addr = sd.region_align_up(space_info->new_top());
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3020
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3021 const RegionData* const beg_region = sd.addr_to_region_ptr(beg_addr);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3022 const RegionData* const end_region = sd.addr_to_region_ptr(end_addr);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3023 const RegionData* cur_region;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3024 for (cur_region = beg_region; cur_region < end_region; ++cur_region) {
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3025 HeapWord* const addr = cur_region->deferred_obj_addr();
0 a61af66fc99e Initial load duke parents: diff changeset	3026 if (addr != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	3027 if (start_array != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	3028 start_array->allocate_block(addr);
a61af66fc99e Initial load duke parents: diff changeset	3029 }
a61af66fc99e Initial load duke parents: diff changeset	3030 oop(addr)->update_contents(cm);
a61af66fc99e Initial load duke parents: diff changeset	3031 assert(oop(addr)->is_oop_or_null(), "should be an oop now");
a61af66fc99e Initial load duke parents: diff changeset	3032 }
a61af66fc99e Initial load duke parents: diff changeset	3033 }
a61af66fc99e Initial load duke parents: diff changeset	3034 }
a61af66fc99e Initial load duke parents: diff changeset	3035
a61af66fc99e Initial load duke parents: diff changeset	3036 // Skip over count live words starting from beg, and return the address of the
a61af66fc99e Initial load duke parents: diff changeset	3037 // next live word. Unless marked, the word corresponding to beg is assumed to
a61af66fc99e Initial load duke parents: diff changeset	3038 // be dead. Callers must either ensure beg does not correspond to the middle of
a61af66fc99e Initial load duke parents: diff changeset	3039 // an object, or account for those live words in some other way. Callers must
a61af66fc99e Initial load duke parents: diff changeset	3040 // also ensure that there are enough live words in the range [beg, end) to skip.
a61af66fc99e Initial load duke parents: diff changeset	3041 HeapWord*
a61af66fc99e Initial load duke parents: diff changeset	3042 PSParallelCompact::skip_live_words(HeapWord* beg, HeapWord* end, size_t count)
a61af66fc99e Initial load duke parents: diff changeset	3043 {
a61af66fc99e Initial load duke parents: diff changeset	3044 assert(count > 0, "sanity");
a61af66fc99e Initial load duke parents: diff changeset	3045
a61af66fc99e Initial load duke parents: diff changeset	3046 ParMarkBitMap* m = mark_bitmap();
a61af66fc99e Initial load duke parents: diff changeset	3047 idx_t bits_to_skip = m->words_to_bits(count);
a61af66fc99e Initial load duke parents: diff changeset	3048 idx_t cur_beg = m->addr_to_bit(beg);
a61af66fc99e Initial load duke parents: diff changeset	3049 const idx_t search_end = BitMap::word_align_up(m->addr_to_bit(end));
a61af66fc99e Initial load duke parents: diff changeset	3050
a61af66fc99e Initial load duke parents: diff changeset	3051 do {
a61af66fc99e Initial load duke parents: diff changeset	3052 cur_beg = m->find_obj_beg(cur_beg, search_end);
a61af66fc99e Initial load duke parents: diff changeset	3053 idx_t cur_end = m->find_obj_end(cur_beg, search_end);
a61af66fc99e Initial load duke parents: diff changeset	3054 const size_t obj_bits = cur_end - cur_beg + 1;
a61af66fc99e Initial load duke parents: diff changeset	3055 if (obj_bits > bits_to_skip) {
a61af66fc99e Initial load duke parents: diff changeset	3056 return m->bit_to_addr(cur_beg + bits_to_skip);
a61af66fc99e Initial load duke parents: diff changeset	3057 }
a61af66fc99e Initial load duke parents: diff changeset	3058 bits_to_skip -= obj_bits;
a61af66fc99e Initial load duke parents: diff changeset	3059 cur_beg = cur_end + 1;
a61af66fc99e Initial load duke parents: diff changeset	3060 } while (bits_to_skip > 0);
a61af66fc99e Initial load duke parents: diff changeset	3061
a61af66fc99e Initial load duke parents: diff changeset	3062 // Skipping the desired number of words landed just past the end of an object.
a61af66fc99e Initial load duke parents: diff changeset	3063 // Find the start of the next object.
a61af66fc99e Initial load duke parents: diff changeset	3064 cur_beg = m->find_obj_beg(cur_beg, search_end);
a61af66fc99e Initial load duke parents: diff changeset	3065 assert(cur_beg < m->addr_to_bit(end), "not enough live words to skip");
a61af66fc99e Initial load duke parents: diff changeset	3066 return m->bit_to_addr(cur_beg);
a61af66fc99e Initial load duke parents: diff changeset	3067 }
a61af66fc99e Initial load duke parents: diff changeset	3068
482 7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	3069 HeapWord* PSParallelCompact::first_src_addr(HeapWord* const dest_addr,
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	3070 SpaceId src_space_id,
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	3071 size_t src_region_idx)
0 a61af66fc99e Initial load duke parents: diff changeset	3072 {
482 7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	3073 assert(summary_data().is_region_aligned(dest_addr), "not aligned");
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	3074
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	3075 const SplitInfo& split_info = _space_info[src_space_id].split_info();
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	3076 if (split_info.dest_region_addr() == dest_addr) {
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	3077 // The partial object ending at the split point contains the first word to
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	3078 // be copied to dest_addr.
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	3079 return split_info.first_src_addr();
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	3080 }
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	3081
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	3082 const ParallelCompactData& sd = summary_data();
0 a61af66fc99e Initial load duke parents: diff changeset	3083 ParMarkBitMap* const bitmap = mark_bitmap();
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3084 const size_t RegionSize = ParallelCompactData::RegionSize;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3085
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3086 assert(sd.is_region_aligned(dest_addr), "not aligned");
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3087 const RegionData* const src_region_ptr = sd.region(src_region_idx);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3088 const size_t partial_obj_size = src_region_ptr->partial_obj_size();
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3089 HeapWord* const src_region_destination = src_region_ptr->destination();
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3090
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3091 assert(dest_addr >= src_region_destination, "wrong src region");
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3092 assert(src_region_ptr->data_size() > 0, "src region cannot be empty");
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3093
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3094 HeapWord* const src_region_beg = sd.region_to_addr(src_region_idx);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3095 HeapWord* const src_region_end = src_region_beg + RegionSize;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3096
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3097 HeapWord* addr = src_region_beg;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3098 if (dest_addr == src_region_destination) {
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3099 // Return the first live word in the source region.
0 a61af66fc99e Initial load duke parents: diff changeset	3100 if (partial_obj_size == 0) {
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3101 addr = bitmap->find_obj_beg(addr, src_region_end);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3102 assert(addr < src_region_end, "no objects start in src region");
0 a61af66fc99e Initial load duke parents: diff changeset	3103 }
a61af66fc99e Initial load duke parents: diff changeset	3104 return addr;
a61af66fc99e Initial load duke parents: diff changeset	3105 }
a61af66fc99e Initial load duke parents: diff changeset	3106
a61af66fc99e Initial load duke parents: diff changeset	3107 // Must skip some live data.
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3108 size_t words_to_skip = dest_addr - src_region_destination;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3109 assert(src_region_ptr->data_size() > words_to_skip, "wrong src region");
0 a61af66fc99e Initial load duke parents: diff changeset	3110
a61af66fc99e Initial load duke parents: diff changeset	3111 if (partial_obj_size >= words_to_skip) {
a61af66fc99e Initial load duke parents: diff changeset	3112 // All the live words to skip are part of the partial object.
a61af66fc99e Initial load duke parents: diff changeset	3113 addr += words_to_skip;
a61af66fc99e Initial load duke parents: diff changeset	3114 if (partial_obj_size == words_to_skip) {
a61af66fc99e Initial load duke parents: diff changeset	3115 // Find the first live word past the partial object.
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3116 addr = bitmap->find_obj_beg(addr, src_region_end);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3117 assert(addr < src_region_end, "wrong src region");
0 a61af66fc99e Initial load duke parents: diff changeset	3118 }
a61af66fc99e Initial load duke parents: diff changeset	3119 return addr;
a61af66fc99e Initial load duke parents: diff changeset	3120 }
a61af66fc99e Initial load duke parents: diff changeset	3121
a61af66fc99e Initial load duke parents: diff changeset	3122 // Skip over the partial object (if any).
a61af66fc99e Initial load duke parents: diff changeset	3123 if (partial_obj_size != 0) {
a61af66fc99e Initial load duke parents: diff changeset	3124 words_to_skip -= partial_obj_size;
a61af66fc99e Initial load duke parents: diff changeset	3125 addr += partial_obj_size;
a61af66fc99e Initial load duke parents: diff changeset	3126 }
a61af66fc99e Initial load duke parents: diff changeset	3127
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3128 // Skip over live words due to objects that start in the region.
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3129 addr = skip_live_words(addr, src_region_end, words_to_skip);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3130 assert(addr < src_region_end, "wrong src region");
0 a61af66fc99e Initial load duke parents: diff changeset	3131 return addr;
a61af66fc99e Initial load duke parents: diff changeset	3132 }
a61af66fc99e Initial load duke parents: diff changeset	3133
a61af66fc99e Initial load duke parents: diff changeset	3134 void PSParallelCompact::decrement_destination_counts(ParCompactionManager* cm,
495 234c22e54b98 6784849: par compact - can fail when to_space is non-empty jcoomes parents: 483 diff changeset	3135 SpaceId src_space_id,
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3136 size_t beg_region,
0 a61af66fc99e Initial load duke parents: diff changeset	3137 HeapWord* end_addr)
a61af66fc99e Initial load duke parents: diff changeset	3138 {
a61af66fc99e Initial load duke parents: diff changeset	3139 ParallelCompactData& sd = summary_data();
495 234c22e54b98 6784849: par compact - can fail when to_space is non-empty jcoomes parents: 483 diff changeset	3140
234c22e54b98 6784849: par compact - can fail when to_space is non-empty jcoomes parents: 483 diff changeset	3141 #ifdef ASSERT
234c22e54b98 6784849: par compact - can fail when to_space is non-empty jcoomes parents: 483 diff changeset	3142 MutableSpace* const src_space = _space_info[src_space_id].space();
234c22e54b98 6784849: par compact - can fail when to_space is non-empty jcoomes parents: 483 diff changeset	3143 HeapWord* const beg_addr = sd.region_to_addr(beg_region);
234c22e54b98 6784849: par compact - can fail when to_space is non-empty jcoomes parents: 483 diff changeset	3144 assert(src_space->contains(beg_addr) \|\| beg_addr == src_space->end(),
234c22e54b98 6784849: par compact - can fail when to_space is non-empty jcoomes parents: 483 diff changeset	3145 "src_space_id does not match beg_addr");
234c22e54b98 6784849: par compact - can fail when to_space is non-empty jcoomes parents: 483 diff changeset	3146 assert(src_space->contains(end_addr) \|\| end_addr == src_space->end(),
234c22e54b98 6784849: par compact - can fail when to_space is non-empty jcoomes parents: 483 diff changeset	3147 "src_space_id does not match end_addr");
234c22e54b98 6784849: par compact - can fail when to_space is non-empty jcoomes parents: 483 diff changeset	3148 #endif // #ifdef ASSERT
234c22e54b98 6784849: par compact - can fail when to_space is non-empty jcoomes parents: 483 diff changeset	3149
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3150 RegionData* const beg = sd.region(beg_region);
495 234c22e54b98 6784849: par compact - can fail when to_space is non-empty jcoomes parents: 483 diff changeset	3151 RegionData* const end = sd.addr_to_region_ptr(sd.region_align_up(end_addr));
234c22e54b98 6784849: par compact - can fail when to_space is non-empty jcoomes parents: 483 diff changeset	3152
234c22e54b98 6784849: par compact - can fail when to_space is non-empty jcoomes parents: 483 diff changeset	3153 // Regions up to new_top() are enqueued if they become available.
234c22e54b98 6784849: par compact - can fail when to_space is non-empty jcoomes parents: 483 diff changeset	3154 HeapWord* const new_top = _space_info[src_space_id].new_top();
234c22e54b98 6784849: par compact - can fail when to_space is non-empty jcoomes parents: 483 diff changeset	3155 RegionData* const enqueue_end =
234c22e54b98 6784849: par compact - can fail when to_space is non-empty jcoomes parents: 483 diff changeset	3156 sd.addr_to_region_ptr(sd.region_align_up(new_top));
234c22e54b98 6784849: par compact - can fail when to_space is non-empty jcoomes parents: 483 diff changeset	3157
234c22e54b98 6784849: par compact - can fail when to_space is non-empty jcoomes parents: 483 diff changeset	3158 for (RegionData* cur = beg; cur < end; ++cur) {
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3159 assert(cur->data_size() > 0, "region must have live data");
0 a61af66fc99e Initial load duke parents: diff changeset	3160 cur->decrement_destination_count();
495 234c22e54b98 6784849: par compact - can fail when to_space is non-empty jcoomes parents: 483 diff changeset	3161 if (cur < enqueue_end && cur->available() && cur->claim()) {
1638 b2a00dd3117c 6957084: simplify TaskQueue overflow handling jcoomes parents: 1579 diff changeset	3162 cm->push_region(sd.region(cur));
0 a61af66fc99e Initial load duke parents: diff changeset	3163 }
a61af66fc99e Initial load duke parents: diff changeset	3164 }
a61af66fc99e Initial load duke parents: diff changeset	3165 }
a61af66fc99e Initial load duke parents: diff changeset	3166
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3167 size_t PSParallelCompact::next_src_region(MoveAndUpdateClosure& closure,
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3168 SpaceId& src_space_id,
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3169 HeapWord*& src_space_top,
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3170 HeapWord* end_addr)
0 a61af66fc99e Initial load duke parents: diff changeset	3171 {
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3172 typedef ParallelCompactData::RegionData RegionData;
0 a61af66fc99e Initial load duke parents: diff changeset	3173
a61af66fc99e Initial load duke parents: diff changeset	3174 ParallelCompactData& sd = PSParallelCompact::summary_data();
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3175 const size_t region_size = ParallelCompactData::RegionSize;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3176
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3177 size_t src_region_idx = 0;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3178
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3179 // Skip empty regions (if any) up to the top of the space.
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3180 HeapWord* const src_aligned_up = sd.region_align_up(end_addr);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3181 RegionData* src_region_ptr = sd.addr_to_region_ptr(src_aligned_up);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3182 HeapWord* const top_aligned_up = sd.region_align_up(src_space_top);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3183 const RegionData* const top_region_ptr =
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3184 sd.addr_to_region_ptr(top_aligned_up);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3185 while (src_region_ptr < top_region_ptr && src_region_ptr->data_size() == 0) {
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3186 ++src_region_ptr;
0 a61af66fc99e Initial load duke parents: diff changeset	3187 }
a61af66fc99e Initial load duke parents: diff changeset	3188
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3189 if (src_region_ptr < top_region_ptr) {
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3190 // The next source region is in the current space. Update src_region_idx
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3191 // and the source address to match src_region_ptr.
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3192 src_region_idx = sd.region(src_region_ptr);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3193 HeapWord* const src_region_addr = sd.region_to_addr(src_region_idx);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3194 if (src_region_addr > closure.source()) {
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3195 closure.set_source(src_region_addr);
0 a61af66fc99e Initial load duke parents: diff changeset	3196 }
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3197 return src_region_idx;
0 a61af66fc99e Initial load duke parents: diff changeset	3198 }
a61af66fc99e Initial load duke parents: diff changeset	3199
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3200 // Switch to a new source space and find the first non-empty region.
0 a61af66fc99e Initial load duke parents: diff changeset	3201 unsigned int space_id = src_space_id + 1;
a61af66fc99e Initial load duke parents: diff changeset	3202 assert(space_id < last_space_id, "not enough spaces");
a61af66fc99e Initial load duke parents: diff changeset	3203
a61af66fc99e Initial load duke parents: diff changeset	3204 HeapWord* const destination = closure.destination();
a61af66fc99e Initial load duke parents: diff changeset	3205
a61af66fc99e Initial load duke parents: diff changeset	3206 do {
a61af66fc99e Initial load duke parents: diff changeset	3207 MutableSpace* space = _space_info[space_id].space();
a61af66fc99e Initial load duke parents: diff changeset	3208 HeapWord* const bottom = space->bottom();
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3209 const RegionData* const bottom_cp = sd.addr_to_region_ptr(bottom);
0 a61af66fc99e Initial load duke parents: diff changeset	3210
a61af66fc99e Initial load duke parents: diff changeset	3211 // Iterate over the spaces that do not compact into themselves.
a61af66fc99e Initial load duke parents: diff changeset	3212 if (bottom_cp->destination() != bottom) {
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3213 HeapWord* const top_aligned_up = sd.region_align_up(space->top());
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3214 const RegionData* const top_cp = sd.addr_to_region_ptr(top_aligned_up);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3215
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3216 for (const RegionData* src_cp = bottom_cp; src_cp < top_cp; ++src_cp) {
0 a61af66fc99e Initial load duke parents: diff changeset	3217 if (src_cp->live_obj_size() > 0) {
a61af66fc99e Initial load duke parents: diff changeset	3218 // Found it.
a61af66fc99e Initial load duke parents: diff changeset	3219 assert(src_cp->destination() == destination,
a61af66fc99e Initial load duke parents: diff changeset	3220 "first live obj in the space must match the destination");
a61af66fc99e Initial load duke parents: diff changeset	3221 assert(src_cp->partial_obj_size() == 0,
a61af66fc99e Initial load duke parents: diff changeset	3222 "a space cannot begin with a partial obj");
a61af66fc99e Initial load duke parents: diff changeset	3223
a61af66fc99e Initial load duke parents: diff changeset	3224 src_space_id = SpaceId(space_id);
a61af66fc99e Initial load duke parents: diff changeset	3225 src_space_top = space->top();
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3226 const size_t src_region_idx = sd.region(src_cp);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3227 closure.set_source(sd.region_to_addr(src_region_idx));
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3228 return src_region_idx;
0 a61af66fc99e Initial load duke parents: diff changeset	3229 } else {
a61af66fc99e Initial load duke parents: diff changeset	3230 assert(src_cp->data_size() == 0, "sanity");
a61af66fc99e Initial load duke parents: diff changeset	3231 }
a61af66fc99e Initial load duke parents: diff changeset	3232 }
a61af66fc99e Initial load duke parents: diff changeset	3233 }
a61af66fc99e Initial load duke parents: diff changeset	3234 } while (++space_id < last_space_id);
a61af66fc99e Initial load duke parents: diff changeset	3235
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3236 assert(false, "no source region was found");
0 a61af66fc99e Initial load duke parents: diff changeset	3237 return 0;
a61af66fc99e Initial load duke parents: diff changeset	3238 }
a61af66fc99e Initial load duke parents: diff changeset	3239
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3240 void PSParallelCompact::fill_region(ParCompactionManager* cm, size_t region_idx)
0 a61af66fc99e Initial load duke parents: diff changeset	3241 {
a61af66fc99e Initial load duke parents: diff changeset	3242 typedef ParMarkBitMap::IterationStatus IterationStatus;
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3243 const size_t RegionSize = ParallelCompactData::RegionSize;
0 a61af66fc99e Initial load duke parents: diff changeset	3244 ParMarkBitMap* const bitmap = mark_bitmap();
a61af66fc99e Initial load duke parents: diff changeset	3245 ParallelCompactData& sd = summary_data();
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3246 RegionData* const region_ptr = sd.region(region_idx);
0 a61af66fc99e Initial load duke parents: diff changeset	3247
a61af66fc99e Initial load duke parents: diff changeset	3248 // Get the items needed to construct the closure.
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3249 HeapWord* dest_addr = sd.region_to_addr(region_idx);
0 a61af66fc99e Initial load duke parents: diff changeset	3250 SpaceId dest_space_id = space_id(dest_addr);
a61af66fc99e Initial load duke parents: diff changeset	3251 ObjectStartArray* start_array = _space_info[dest_space_id].start_array();
a61af66fc99e Initial load duke parents: diff changeset	3252 HeapWord* new_top = _space_info[dest_space_id].new_top();
a61af66fc99e Initial load duke parents: diff changeset	3253 assert(dest_addr < new_top, "sanity");
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3254 const size_t words = MIN2(pointer_delta(new_top, dest_addr), RegionSize);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3255
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3256 // Get the source region and related info.
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3257 size_t src_region_idx = region_ptr->source_region();
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3258 SpaceId src_space_id = space_id(sd.region_to_addr(src_region_idx));
0 a61af66fc99e Initial load duke parents: diff changeset	3259 HeapWord* src_space_top = _space_info[src_space_id].space()->top();
a61af66fc99e Initial load duke parents: diff changeset	3260
a61af66fc99e Initial load duke parents: diff changeset	3261 MoveAndUpdateClosure closure(bitmap, cm, start_array, dest_addr, words);
482 7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	3262 closure.set_source(first_src_addr(dest_addr, src_space_id, src_region_idx));
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3263
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3264 // Adjust src_region_idx to prepare for decrementing destination counts (the
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3265 // destination count is not decremented when a region is copied to itself).
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3266 if (src_region_idx == region_idx) {
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3267 src_region_idx += 1;
0 a61af66fc99e Initial load duke parents: diff changeset	3268 }
a61af66fc99e Initial load duke parents: diff changeset	3269
a61af66fc99e Initial load duke parents: diff changeset	3270 if (bitmap->is_unmarked(closure.source())) {
a61af66fc99e Initial load duke parents: diff changeset	3271 // The first source word is in the middle of an object; copy the remainder
a61af66fc99e Initial load duke parents: diff changeset	3272 // of the object or as much as will fit. The fact that pointer updates were
a61af66fc99e Initial load duke parents: diff changeset	3273 // deferred will be noted when the object header is processed.
a61af66fc99e Initial load duke parents: diff changeset	3274 HeapWord* const old_src_addr = closure.source();
a61af66fc99e Initial load duke parents: diff changeset	3275 closure.copy_partial_obj();
a61af66fc99e Initial load duke parents: diff changeset	3276 if (closure.is_full()) {
495 234c22e54b98 6784849: par compact - can fail when to_space is non-empty jcoomes parents: 483 diff changeset	3277 decrement_destination_counts(cm, src_space_id, src_region_idx,
234c22e54b98 6784849: par compact - can fail when to_space is non-empty jcoomes parents: 483 diff changeset	3278 closure.source());
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3279 region_ptr->set_deferred_obj_addr(NULL);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3280 region_ptr->set_completed();
0 a61af66fc99e Initial load duke parents: diff changeset	3281 return;
a61af66fc99e Initial load duke parents: diff changeset	3282 }
a61af66fc99e Initial load duke parents: diff changeset	3283
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3284 HeapWord* const end_addr = sd.region_align_down(closure.source());
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3285 if (sd.region_align_down(old_src_addr) != end_addr) {
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3286 // The partial object was copied from more than one source region.
495 234c22e54b98 6784849: par compact - can fail when to_space is non-empty jcoomes parents: 483 diff changeset	3287 decrement_destination_counts(cm, src_space_id, src_region_idx, end_addr);
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3288
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3289 // Move to the next source region, possibly switching spaces as well. All
0 a61af66fc99e Initial load duke parents: diff changeset	3290 // args except end_addr may be modified.
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3291 src_region_idx = next_src_region(closure, src_space_id, src_space_top,
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3292 end_addr);
0 a61af66fc99e Initial load duke parents: diff changeset	3293 }
a61af66fc99e Initial load duke parents: diff changeset	3294 }
a61af66fc99e Initial load duke parents: diff changeset	3295
a61af66fc99e Initial load duke parents: diff changeset	3296 do {
a61af66fc99e Initial load duke parents: diff changeset	3297 HeapWord* const cur_addr = closure.source();
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3298 HeapWord* const end_addr = MIN2(sd.region_align_up(cur_addr + 1),
0 a61af66fc99e Initial load duke parents: diff changeset	3299 src_space_top);
a61af66fc99e Initial load duke parents: diff changeset	3300 IterationStatus status = bitmap->iterate(&closure, cur_addr, end_addr);
a61af66fc99e Initial load duke parents: diff changeset	3301
a61af66fc99e Initial load duke parents: diff changeset	3302 if (status == ParMarkBitMap::incomplete) {
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3303 // The last obj that starts in the source region does not end in the
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3304 // region.
1489 cff162798819 6888953: some calls to function-like macros are missing semicolons jcoomes parents: 1387 diff changeset	3305 assert(closure.source() < end_addr, "sanity");
0 a61af66fc99e Initial load duke parents: diff changeset	3306 HeapWord* const obj_beg = closure.source();
a61af66fc99e Initial load duke parents: diff changeset	3307 HeapWord* const range_end = MIN2(obj_beg + closure.words_remaining(),
a61af66fc99e Initial load duke parents: diff changeset	3308 src_space_top);
a61af66fc99e Initial load duke parents: diff changeset	3309 HeapWord* const obj_end = bitmap->find_obj_end(obj_beg, range_end);
a61af66fc99e Initial load duke parents: diff changeset	3310 if (obj_end < range_end) {
a61af66fc99e Initial load duke parents: diff changeset	3311 // The end was found; the entire object will fit.
a61af66fc99e Initial load duke parents: diff changeset	3312 status = closure.do_addr(obj_beg, bitmap->obj_size(obj_beg, obj_end));
a61af66fc99e Initial load duke parents: diff changeset	3313 assert(status != ParMarkBitMap::would_overflow, "sanity");
a61af66fc99e Initial load duke parents: diff changeset	3314 } else {
a61af66fc99e Initial load duke parents: diff changeset	3315 // The end was not found; the object will not fit.
a61af66fc99e Initial load duke parents: diff changeset	3316 assert(range_end < src_space_top, "obj cannot cross space boundary");
a61af66fc99e Initial load duke parents: diff changeset	3317 status = ParMarkBitMap::would_overflow;
a61af66fc99e Initial load duke parents: diff changeset	3318 }
a61af66fc99e Initial load duke parents: diff changeset	3319 }
a61af66fc99e Initial load duke parents: diff changeset	3320
a61af66fc99e Initial load duke parents: diff changeset	3321 if (status == ParMarkBitMap::would_overflow) {
a61af66fc99e Initial load duke parents: diff changeset	3322 // The last object did not fit. Note that interior oop updates were
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3323 // deferred, then copy enough of the object to fill the region.
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3324 region_ptr->set_deferred_obj_addr(closure.destination());
0 a61af66fc99e Initial load duke parents: diff changeset	3325 status = closure.copy_until_full(); // copies from closure.source()
a61af66fc99e Initial load duke parents: diff changeset	3326
495 234c22e54b98 6784849: par compact - can fail when to_space is non-empty jcoomes parents: 483 diff changeset	3327 decrement_destination_counts(cm, src_space_id, src_region_idx,
234c22e54b98 6784849: par compact - can fail when to_space is non-empty jcoomes parents: 483 diff changeset	3328 closure.source());
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3329 region_ptr->set_completed();
0 a61af66fc99e Initial load duke parents: diff changeset	3330 return;
a61af66fc99e Initial load duke parents: diff changeset	3331 }
a61af66fc99e Initial load duke parents: diff changeset	3332
a61af66fc99e Initial load duke parents: diff changeset	3333 if (status == ParMarkBitMap::full) {
495 234c22e54b98 6784849: par compact - can fail when to_space is non-empty jcoomes parents: 483 diff changeset	3334 decrement_destination_counts(cm, src_space_id, src_region_idx,
234c22e54b98 6784849: par compact - can fail when to_space is non-empty jcoomes parents: 483 diff changeset	3335 closure.source());
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3336 region_ptr->set_deferred_obj_addr(NULL);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3337 region_ptr->set_completed();
0 a61af66fc99e Initial load duke parents: diff changeset	3338 return;
a61af66fc99e Initial load duke parents: diff changeset	3339 }
a61af66fc99e Initial load duke parents: diff changeset	3340
495 234c22e54b98 6784849: par compact - can fail when to_space is non-empty jcoomes parents: 483 diff changeset	3341 decrement_destination_counts(cm, src_space_id, src_region_idx, end_addr);
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3342
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3343 // Move to the next source region, possibly switching spaces as well. All
0 a61af66fc99e Initial load duke parents: diff changeset	3344 // args except end_addr may be modified.
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3345 src_region_idx = next_src_region(closure, src_space_id, src_space_top,
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3346 end_addr);
0 a61af66fc99e Initial load duke parents: diff changeset	3347 } while (true);
a61af66fc99e Initial load duke parents: diff changeset	3348 }
a61af66fc99e Initial load duke parents: diff changeset	3349
a61af66fc99e Initial load duke parents: diff changeset	3350 void
a61af66fc99e Initial load duke parents: diff changeset	3351 PSParallelCompact::move_and_update(ParCompactionManager* cm, SpaceId space_id) {
a61af66fc99e Initial load duke parents: diff changeset	3352 const MutableSpace* sp = space(space_id);
a61af66fc99e Initial load duke parents: diff changeset	3353 if (sp->is_empty()) {
a61af66fc99e Initial load duke parents: diff changeset	3354 return;
a61af66fc99e Initial load duke parents: diff changeset	3355 }
a61af66fc99e Initial load duke parents: diff changeset	3356
a61af66fc99e Initial load duke parents: diff changeset	3357 ParallelCompactData& sd = PSParallelCompact::summary_data();
a61af66fc99e Initial load duke parents: diff changeset	3358 ParMarkBitMap* const bitmap = mark_bitmap();
a61af66fc99e Initial load duke parents: diff changeset	3359 HeapWord* const dp_addr = dense_prefix(space_id);
a61af66fc99e Initial load duke parents: diff changeset	3360 HeapWord* beg_addr = sp->bottom();
a61af66fc99e Initial load duke parents: diff changeset	3361 HeapWord* end_addr = sp->top();
a61af66fc99e Initial load duke parents: diff changeset	3362
a61af66fc99e Initial load duke parents: diff changeset	3363 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	3364 assert(beg_addr <= dp_addr && dp_addr <= end_addr, "bad dense prefix");
a61af66fc99e Initial load duke parents: diff changeset	3365 if (cm->should_verify_only()) {
a61af66fc99e Initial load duke parents: diff changeset	3366 VerifyUpdateClosure verify_update(cm, sp);
a61af66fc99e Initial load duke parents: diff changeset	3367 bitmap->iterate(&verify_update, beg_addr, end_addr);
a61af66fc99e Initial load duke parents: diff changeset	3368 return;
a61af66fc99e Initial load duke parents: diff changeset	3369 }
a61af66fc99e Initial load duke parents: diff changeset	3370
a61af66fc99e Initial load duke parents: diff changeset	3371 if (cm->should_reset_only()) {
a61af66fc99e Initial load duke parents: diff changeset	3372 ResetObjectsClosure reset_objects(cm);
a61af66fc99e Initial load duke parents: diff changeset	3373 bitmap->iterate(&reset_objects, beg_addr, end_addr);
a61af66fc99e Initial load duke parents: diff changeset	3374 return;
a61af66fc99e Initial load duke parents: diff changeset	3375 }
a61af66fc99e Initial load duke parents: diff changeset	3376 #endif
a61af66fc99e Initial load duke parents: diff changeset	3377
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3378 const size_t beg_region = sd.addr_to_region_idx(beg_addr);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3379 const size_t dp_region = sd.addr_to_region_idx(dp_addr);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3380 if (beg_region < dp_region) {
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3381 update_and_deadwood_in_dense_prefix(cm, space_id, beg_region, dp_region);
0 a61af66fc99e Initial load duke parents: diff changeset	3382 }
a61af66fc99e Initial load duke parents: diff changeset	3383
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3384 // The destination of the first live object that starts in the region is one
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3385 // past the end of the partial object entering the region (if any).
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 374 diff changeset	3386 HeapWord* const dest_addr = sd.partial_obj_end(dp_region);
0 a61af66fc99e Initial load duke parents: diff changeset	3387 HeapWord* const new_top = _space_info[space_id].new_top();
a61af66fc99e Initial load duke parents: diff changeset	3388 assert(new_top >= dest_addr, "bad new_top value");
a61af66fc99e Initial load duke parents: diff changeset	3389 const size_t words = pointer_delta(new_top, dest_addr);
a61af66fc99e Initial load duke parents: diff changeset	3390
a61af66fc99e Initial load duke parents: diff changeset	3391 if (words > 0) {
a61af66fc99e Initial load duke parents: diff changeset	3392 ObjectStartArray* start_array = _space_info[space_id].start_array();
a61af66fc99e Initial load duke parents: diff changeset	3393 MoveAndUpdateClosure closure(bitmap, cm, start_array, dest_addr, words);
a61af66fc99e Initial load duke parents: diff changeset	3394
a61af66fc99e Initial load duke parents: diff changeset	3395 ParMarkBitMap::IterationStatus status;
a61af66fc99e Initial load duke parents: diff changeset	3396 status = bitmap->iterate(&closure, dest_addr, end_addr);
a61af66fc99e Initial load duke parents: diff changeset	3397 assert(status == ParMarkBitMap::full, "iteration not complete");
a61af66fc99e Initial load duke parents: diff changeset	3398 assert(bitmap->find_obj_beg(closure.source(), end_addr) == end_addr,
a61af66fc99e Initial load duke parents: diff changeset	3399 "live objects skipped because closure is full");
a61af66fc99e Initial load duke parents: diff changeset	3400 }
a61af66fc99e Initial load duke parents: diff changeset	3401 }
a61af66fc99e Initial load duke parents: diff changeset	3402
a61af66fc99e Initial load duke parents: diff changeset	3403 jlong PSParallelCompact::millis_since_last_gc() {
a61af66fc99e Initial load duke parents: diff changeset	3404 jlong ret_val = os::javaTimeMillis() - _time_of_last_gc;
a61af66fc99e Initial load duke parents: diff changeset	3405 // XXX See note in genCollectedHeap::millis_since_last_gc().
a61af66fc99e Initial load duke parents: diff changeset	3406 if (ret_val < 0) {
a61af66fc99e Initial load duke parents: diff changeset	3407 NOT_PRODUCT(warning("time warp: %d", ret_val);)
a61af66fc99e Initial load duke parents: diff changeset	3408 return 0;
a61af66fc99e Initial load duke parents: diff changeset	3409 }
a61af66fc99e Initial load duke parents: diff changeset	3410 return ret_val;
a61af66fc99e Initial load duke parents: diff changeset	3411 }
a61af66fc99e Initial load duke parents: diff changeset	3412
a61af66fc99e Initial load duke parents: diff changeset	3413 void PSParallelCompact::reset_millis_since_last_gc() {
a61af66fc99e Initial load duke parents: diff changeset	3414 _time_of_last_gc = os::javaTimeMillis();
a61af66fc99e Initial load duke parents: diff changeset	3415 }
a61af66fc99e Initial load duke parents: diff changeset	3416
a61af66fc99e Initial load duke parents: diff changeset	3417 ParMarkBitMap::IterationStatus MoveAndUpdateClosure::copy_until_full()
a61af66fc99e Initial load duke parents: diff changeset	3418 {
a61af66fc99e Initial load duke parents: diff changeset	3419 if (source() != destination()) {
495 234c22e54b98 6784849: par compact - can fail when to_space is non-empty jcoomes parents: 483 diff changeset	3420 DEBUG_ONLY(PSParallelCompact::check_new_location(source(), destination());)
0 a61af66fc99e Initial load duke parents: diff changeset	3421 Copy::aligned_conjoint_words(source(), destination(), words_remaining());
a61af66fc99e Initial load duke parents: diff changeset	3422 }
a61af66fc99e Initial load duke parents: diff changeset	3423 update_state(words_remaining());
a61af66fc99e Initial load duke parents: diff changeset	3424 assert(is_full(), "sanity");
a61af66fc99e Initial load duke parents: diff changeset	3425 return ParMarkBitMap::full;
a61af66fc99e Initial load duke parents: diff changeset	3426 }
a61af66fc99e Initial load duke parents: diff changeset	3427
a61af66fc99e Initial load duke parents: diff changeset	3428 void MoveAndUpdateClosure::copy_partial_obj()
a61af66fc99e Initial load duke parents: diff changeset	3429 {
a61af66fc99e Initial load duke parents: diff changeset	3430 size_t words = words_remaining();
a61af66fc99e Initial load duke parents: diff changeset	3431
a61af66fc99e Initial load duke parents: diff changeset	3432 HeapWord* const range_end = MIN2(source() + words, bitmap()->region_end());
a61af66fc99e Initial load duke parents: diff changeset	3433 HeapWord* const end_addr = bitmap()->find_obj_end(source(), range_end);
a61af66fc99e Initial load duke parents: diff changeset	3434 if (end_addr < range_end) {
a61af66fc99e Initial load duke parents: diff changeset	3435 words = bitmap()->obj_size(source(), end_addr);
a61af66fc99e Initial load duke parents: diff changeset	3436 }
a61af66fc99e Initial load duke parents: diff changeset	3437
a61af66fc99e Initial load duke parents: diff changeset	3438 // This test is necessary; if omitted, the pointer updates to a partial object
a61af66fc99e Initial load duke parents: diff changeset	3439 // that crosses the dense prefix boundary could be overwritten.
a61af66fc99e Initial load duke parents: diff changeset	3440 if (source() != destination()) {
495 234c22e54b98 6784849: par compact - can fail when to_space is non-empty jcoomes parents: 483 diff changeset	3441 DEBUG_ONLY(PSParallelCompact::check_new_location(source(), destination());)
0 a61af66fc99e Initial load duke parents: diff changeset	3442 Copy::aligned_conjoint_words(source(), destination(), words);
a61af66fc99e Initial load duke parents: diff changeset	3443 }
a61af66fc99e Initial load duke parents: diff changeset	3444 update_state(words);
a61af66fc99e Initial load duke parents: diff changeset	3445 }
a61af66fc99e Initial load duke parents: diff changeset	3446
a61af66fc99e Initial load duke parents: diff changeset	3447 ParMarkBitMapClosure::IterationStatus
a61af66fc99e Initial load duke parents: diff changeset	3448 MoveAndUpdateClosure::do_addr(HeapWord* addr, size_t words) {
a61af66fc99e Initial load duke parents: diff changeset	3449 assert(destination() != NULL, "sanity");
a61af66fc99e Initial load duke parents: diff changeset	3450 assert(bitmap()->obj_size(addr) == words, "bad size");
a61af66fc99e Initial load duke parents: diff changeset	3451
a61af66fc99e Initial load duke parents: diff changeset	3452 _source = addr;
a61af66fc99e Initial load duke parents: diff changeset	3453 assert(PSParallelCompact::summary_data().calc_new_pointer(source()) ==
a61af66fc99e Initial load duke parents: diff changeset	3454 destination(), "wrong destination");
a61af66fc99e Initial load duke parents: diff changeset	3455
a61af66fc99e Initial load duke parents: diff changeset	3456 if (words > words_remaining()) {
a61af66fc99e Initial load duke parents: diff changeset	3457 return ParMarkBitMap::would_overflow;
a61af66fc99e Initial load duke parents: diff changeset	3458 }
a61af66fc99e Initial load duke parents: diff changeset	3459
a61af66fc99e Initial load duke parents: diff changeset	3460 // The start_array must be updated even if the object is not moving.
a61af66fc99e Initial load duke parents: diff changeset	3461 if (_start_array != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	3462 _start_array->allocate_block(destination());
a61af66fc99e Initial load duke parents: diff changeset	3463 }
a61af66fc99e Initial load duke parents: diff changeset	3464
a61af66fc99e Initial load duke parents: diff changeset	3465 if (destination() != source()) {
495 234c22e54b98 6784849: par compact - can fail when to_space is non-empty jcoomes parents: 483 diff changeset	3466 DEBUG_ONLY(PSParallelCompact::check_new_location(source(), destination());)
0 a61af66fc99e Initial load duke parents: diff changeset	3467 Copy::aligned_conjoint_words(source(), destination(), words);
a61af66fc99e Initial load duke parents: diff changeset	3468 }
a61af66fc99e Initial load duke parents: diff changeset	3469
a61af66fc99e Initial load duke parents: diff changeset	3470 oop moved_oop = (oop) destination();
a61af66fc99e Initial load duke parents: diff changeset	3471 moved_oop->update_contents(compaction_manager());
a61af66fc99e Initial load duke parents: diff changeset	3472 assert(moved_oop->is_oop_or_null(), "Object should be whole at this point");
a61af66fc99e Initial load duke parents: diff changeset	3473
a61af66fc99e Initial load duke parents: diff changeset	3474 update_state(words);
a61af66fc99e Initial load duke parents: diff changeset	3475 assert(destination() == (HeapWord*)moved_oop + moved_oop->size(), "sanity");
a61af66fc99e Initial load duke parents: diff changeset	3476 return is_full() ? ParMarkBitMap::full : ParMarkBitMap::incomplete;
a61af66fc99e Initial load duke parents: diff changeset	3477 }
a61af66fc99e Initial load duke parents: diff changeset	3478
a61af66fc99e Initial load duke parents: diff changeset	3479 UpdateOnlyClosure::UpdateOnlyClosure(ParMarkBitMap* mbm,
a61af66fc99e Initial load duke parents: diff changeset	3480 ParCompactionManager* cm,
a61af66fc99e Initial load duke parents: diff changeset	3481 PSParallelCompact::SpaceId space_id) :
a61af66fc99e Initial load duke parents: diff changeset	3482 ParMarkBitMapClosure(mbm, cm),
a61af66fc99e Initial load duke parents: diff changeset	3483 _space_id(space_id),
a61af66fc99e Initial load duke parents: diff changeset	3484 _start_array(PSParallelCompact::start_array(space_id))
a61af66fc99e Initial load duke parents: diff changeset	3485 {
a61af66fc99e Initial load duke parents: diff changeset	3486 }
a61af66fc99e Initial load duke parents: diff changeset	3487
a61af66fc99e Initial load duke parents: diff changeset	3488 // Updates the references in the object to their new values.
a61af66fc99e Initial load duke parents: diff changeset	3489 ParMarkBitMapClosure::IterationStatus
a61af66fc99e Initial load duke parents: diff changeset	3490 UpdateOnlyClosure::do_addr(HeapWord* addr, size_t words) {
a61af66fc99e Initial load duke parents: diff changeset	3491 do_addr(addr);
a61af66fc99e Initial load duke parents: diff changeset	3492 return ParMarkBitMap::incomplete;
a61af66fc99e Initial load duke parents: diff changeset	3493 }
a61af66fc99e Initial load duke parents: diff changeset	3494
a61af66fc99e Initial load duke parents: diff changeset	3495 // Verify the new location using the forwarding pointer
a61af66fc99e Initial load duke parents: diff changeset	3496 // from MarkSweep::mark_sweep_phase2(). Set the mark_word
a61af66fc99e Initial load duke parents: diff changeset	3497 // to the initial value.
a61af66fc99e Initial load duke parents: diff changeset	3498 ParMarkBitMapClosure::IterationStatus
a61af66fc99e Initial load duke parents: diff changeset	3499 PSParallelCompact::VerifyUpdateClosure::do_addr(HeapWord* addr, size_t words) {
a61af66fc99e Initial load duke parents: diff changeset	3500 // The second arg (words) is not used.
a61af66fc99e Initial load duke parents: diff changeset	3501 oop obj = (oop) addr;
a61af66fc99e Initial load duke parents: diff changeset	3502 HeapWord* forwarding_ptr = (HeapWord*) obj->mark()->decode_pointer();
a61af66fc99e Initial load duke parents: diff changeset	3503 HeapWord* new_pointer = summary_data().calc_new_pointer(obj);
a61af66fc99e Initial load duke parents: diff changeset	3504 if (forwarding_ptr == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	3505 // The object is dead or not moving.
a61af66fc99e Initial load duke parents: diff changeset	3506 assert(bitmap()->is_unmarked(obj) \|\| (new_pointer == (HeapWord*) obj),
a61af66fc99e Initial load duke parents: diff changeset	3507 "Object liveness is wrong.");
a61af66fc99e Initial load duke parents: diff changeset	3508 return ParMarkBitMap::incomplete;
a61af66fc99e Initial load duke parents: diff changeset	3509 }
3251 eda9eb483d29 6841742: par compact - remove unused/unsupported options jcoomes parents: 2369 diff changeset	3510 assert(HeapMaximumCompactionInterval > 1 \|\| MarkSweepAlwaysCompactCount > 1 \|\|
eda9eb483d29 6841742: par compact - remove unused/unsupported options jcoomes parents: 2369 diff changeset	3511 forwarding_ptr == new_pointer, "new location is incorrect");
0 a61af66fc99e Initial load duke parents: diff changeset	3512 return ParMarkBitMap::incomplete;
a61af66fc99e Initial load duke parents: diff changeset	3513 }
a61af66fc99e Initial load duke parents: diff changeset	3514
a61af66fc99e Initial load duke parents: diff changeset	3515 // Reset objects modified for debug checking.
a61af66fc99e Initial load duke parents: diff changeset	3516 ParMarkBitMapClosure::IterationStatus
a61af66fc99e Initial load duke parents: diff changeset	3517 PSParallelCompact::ResetObjectsClosure::do_addr(HeapWord* addr, size_t words) {
a61af66fc99e Initial load duke parents: diff changeset	3518 // The second arg (words) is not used.
a61af66fc99e Initial load duke parents: diff changeset	3519 oop obj = (oop) addr;
a61af66fc99e Initial load duke parents: diff changeset	3520 obj->init_mark();
a61af66fc99e Initial load duke parents: diff changeset	3521 return ParMarkBitMap::incomplete;
a61af66fc99e Initial load duke parents: diff changeset	3522 }
a61af66fc99e Initial load duke parents: diff changeset	3523
a61af66fc99e Initial load duke parents: diff changeset	3524 // Prepare for compaction. This method is executed once
a61af66fc99e Initial load duke parents: diff changeset	3525 // (i.e., by a single thread) before compaction.
a61af66fc99e Initial load duke parents: diff changeset	3526 // Save the updated location of the intArrayKlassObj for
a61af66fc99e Initial load duke parents: diff changeset	3527 // filling holes in the dense prefix.
a61af66fc99e Initial load duke parents: diff changeset	3528 void PSParallelCompact::compact_prologue() {
a61af66fc99e Initial load duke parents: diff changeset	3529 _updated_int_array_klass_obj = (klassOop)
a61af66fc99e Initial load duke parents: diff changeset	3530 summary_data().calc_new_pointer(Universe::intArrayKlassObj());
a61af66fc99e Initial load duke parents: diff changeset	3531 }
a61af66fc99e Initial load duke parents: diff changeset	3532

Mercurial > hg > truffle

annotate src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp @ 3979:4dfb2df418f2