graal-compiler: src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp annotate

annotate src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp @ 1091:6aa7255741f3

6906727: UseCompressedOops: some card-marking fixes related to object arrays Summary: Introduced a new write_ref_array(HeapWords* start, size_t count) method that does the requisite MemRegion range calculation so (some of the) clients of the erstwhile write_ref_array(MemRegion mr) do not need to worry. This removed all external uses of array_size(), which was also simplified and made private. Asserts were added to catch other possible issues. Further, less essential, fixes stemming from this investigation are deferred to CR 6904516 (to follow shortly in hs17). Reviewed-by: kvn, coleenp, jmasa

author	ysr
date	Thu, 03 Dec 2009 15:01:57 -0800
parents	46b819ba120b
children	2a1472c30599

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

Mercurial > hg > graal-compiler

annotate src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp @ 1091:6aa7255741f3