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

annotate src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.hpp @ 10185:d50cc62e94ff

8012715: G1: GraphKit accesses PtrQueue::_index as int but is size_t Summary: In graphKit INT operations were generated to access PtrQueue::_index which has type size_t. This is 64 bit on 64-bit machines. No problems occur on little endian machines as long as the index fits into 32 bit, but on big endian machines the upper part is read, which is zero. This leads to unnecessary branches to the slow path in the runtime. Reviewed-by: twisti, johnc Contributed-by: Martin Doerr <martin.doerr@sap.com>

author	johnc
date	Wed, 24 Apr 2013 14:48:43 -0700
parents	a08c80e9e1e5
children	001ec9515f84

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
4913 ab4422d0ed59 7146343: PS invoke methods should indicate the type of gc done jcoomes parents: 4099 diff changeset	2 * Copyright (c) 2005, 2012, Oracle and/or its affiliates. All rights reserved.
0 a61af66fc99e Initial load duke parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load duke parents: diff changeset	4 *
a61af66fc99e Initial load duke parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load duke parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load duke parents: diff changeset	7 * published by the Free Software Foundation.
a61af66fc99e Initial load duke parents: diff changeset	8 *
a61af66fc99e Initial load duke parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load duke parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load duke parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load duke parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load duke parents: diff changeset	13 * accompanied this code).
a61af66fc99e Initial load duke parents: diff changeset	14 *
a61af66fc99e Initial load duke parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load duke parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load duke parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load duke parents: diff changeset	18 *
1552 c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1311 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1311 diff changeset	20 * or visit www.oracle.com if you need additional information or have any
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1311 diff changeset	21 * questions.
0 a61af66fc99e Initial load duke parents: diff changeset	22 *
a61af66fc99e Initial load duke parents: diff changeset	23 */
a61af66fc99e Initial load duke parents: diff changeset	24
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1638 diff changeset	25 #ifndef SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_PSPARALLELCOMPACT_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1638 diff changeset	26 #define SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_PSPARALLELCOMPACT_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1638 diff changeset	27
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1638 diff changeset	28 #include "gc_implementation/parallelScavenge/objectStartArray.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1638 diff changeset	29 #include "gc_implementation/parallelScavenge/parMarkBitMap.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1638 diff changeset	30 #include "gc_implementation/parallelScavenge/psCompactionManager.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1638 diff changeset	31 #include "gc_implementation/shared/collectorCounters.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1638 diff changeset	32 #include "gc_implementation/shared/markSweep.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1638 diff changeset	33 #include "gc_implementation/shared/mutableSpace.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1638 diff changeset	34 #include "memory/sharedHeap.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1638 diff changeset	35 #include "oops/oop.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1638 diff changeset	36
0 a61af66fc99e Initial load duke parents: diff changeset	37 class ParallelScavengeHeap;
a61af66fc99e Initial load duke parents: diff changeset	38 class PSAdaptiveSizePolicy;
a61af66fc99e Initial load duke parents: diff changeset	39 class PSYoungGen;
a61af66fc99e Initial load duke parents: diff changeset	40 class PSOldGen;
a61af66fc99e Initial load duke parents: diff changeset	41 class ParCompactionManager;
a61af66fc99e Initial load duke parents: diff changeset	42 class ParallelTaskTerminator;
a61af66fc99e Initial load duke parents: diff changeset	43 class PSParallelCompact;
a61af66fc99e Initial load duke parents: diff changeset	44 class GCTaskManager;
a61af66fc99e Initial load duke parents: diff changeset	45 class GCTaskQueue;
a61af66fc99e Initial load duke parents: diff changeset	46 class PreGCValues;
a61af66fc99e Initial load duke parents: diff changeset	47 class MoveAndUpdateClosure;
a61af66fc99e Initial load duke parents: diff changeset	48 class RefProcTaskExecutor;
a61af66fc99e Initial load duke parents: diff changeset	49
482 7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	50 // The SplitInfo class holds the information needed to 'split' a source region
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	51 // so that the live data can be copied to two destination spaces. Normally,
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	52 // all the live data in a region is copied to a single destination space (e.g.,
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	53 // everything live in a region in eden is copied entirely into the old gen).
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	54 // However, when the heap is nearly full, all the live data in eden may not fit
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	55 // into the old gen. Copying only some of the regions from eden to old gen
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	56 // requires finding a region that does not contain a partial object (i.e., no
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	57 // live object crosses the region boundary) somewhere near the last object that
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	58 // does fit into the old gen. Since it's not always possible to find such a
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	59 // region, splitting is necessary for predictable behavior.
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	60 //
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	61 // A region is always split at the end of the partial object. This avoids
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	62 // additional tests when calculating the new location of a pointer, which is a
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	63 // very hot code path. The partial object and everything to its left will be
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	64 // copied to another space (call it dest_space_1). The live data to the right
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	65 // of the partial object will be copied either within the space itself, or to a
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	66 // different destination space (distinct from dest_space_1).
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	67 //
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	68 // Split points are identified during the summary phase, when region
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	69 // destinations are computed: data about the split, including the
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	70 // partial_object_size, is recorded in a SplitInfo record and the
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	71 // partial_object_size field in the summary data is set to zero. The zeroing is
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	72 // possible (and necessary) since the partial object will move to a different
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	73 // destination space than anything to its right, thus the partial object should
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	74 // not affect the locations of any objects to its right.
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	75 //
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	76 // The recorded data is used during the compaction phase, but only rarely: when
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	77 // the partial object on the split region will be copied across a destination
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	78 // region boundary. This test is made once each time a region is filled, and is
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	79 // a simple address comparison, so the overhead is negligible (see
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	80 // PSParallelCompact::first_src_addr()).
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	81 //
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	82 // Notes:
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	83 //
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	84 // Only regions with partial objects are split; a region without a partial
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	85 // object does not need any extra bookkeeping.
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	86 //
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	87 // At most one region is split per space, so the amount of data required is
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	88 // constant.
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	89 //
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	90 // A region is split only when the destination space would overflow. Once that
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	91 // happens, the destination space is abandoned and no other data (even from
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	92 // other source spaces) is targeted to that destination space. Abandoning the
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	93 // destination space may leave a somewhat large unused area at the end, if a
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	94 // large object caused the overflow.
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	95 //
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	96 // Future work:
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 // More bookkeeping would be required to continue to use the destination space.
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	99 // The most general solution would allow data from regions in two different
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	100 // source spaces to be "joined" in a single destination region. At the very
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	101 // least, additional code would be required in next_src_region() to detect the
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	102 // join and skip to an out-of-order source region. If the join region was also
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	103 // the last destination region to which a split region was copied (the most
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	104 // likely case), then additional work would be needed to get fill_region() to
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	105 // stop iteration and switch to a new source region at the right point. Basic
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	106 // idea would be to use a fake value for the top of the source space. It is
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	107 // doable, if a bit tricky.
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	108 //
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	109 // A simpler (but less general) solution would fill the remainder of the
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	110 // destination region with a dummy object and continue filling the next
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	111 // destination region.
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	112
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	113 class SplitInfo
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	114 {
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	115 public:
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	116 // Return true if this split info is valid (i.e., if a split has been
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	117 // recorded). The very first region cannot have a partial object and thus is
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	118 // never split, so 0 is the 'invalid' value.
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	119 bool is_valid() const { return _src_region_idx > 0; }
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 // Return true if this split holds data for the specified source region.
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	122 inline bool is_split(size_t source_region) const;
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	123
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	124 // The index of the split region, the size of the partial object on that
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	125 // region and the destination of the partial object.
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	126 size_t src_region_idx() const { return _src_region_idx; }
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	127 size_t partial_obj_size() const { return _partial_obj_size; }
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	128 HeapWord* destination() const { return _destination; }
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	129
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	130 // The destination count of the partial object referenced by this split
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	131 // (either 1 or 2). This must be added to the destination count of the
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	132 // remainder of the source region.
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	133 unsigned int destination_count() const { return _destination_count; }
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 // If a word within the partial object will be written to the first word of a
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	136 // destination region, this is the address of the destination region;
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	137 // otherwise this is NULL.
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	138 HeapWord* dest_region_addr() const { return _dest_region_addr; }
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	139
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	140 // If a word within the partial object will be written to the first word of a
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	141 // destination region, this is the address of that word within the partial
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	142 // object; otherwise this is NULL.
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	143 HeapWord* first_src_addr() const { return _first_src_addr; }
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	144
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	145 // Record the data necessary to split the region src_region_idx.
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	146 void 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	147 HeapWord* destination);
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	148
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	149 void clear();
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	150
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	151 DEBUG_ONLY(void verify_clear();)
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	152
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	153 private:
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	154 size_t _src_region_idx;
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	155 size_t _partial_obj_size;
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	156 HeapWord* _destination;
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	157 unsigned int _destination_count;
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	158 HeapWord* _dest_region_addr;
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	159 HeapWord* _first_src_addr;
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	160 };
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	161
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	162 inline bool SplitInfo::is_split(size_t region_idx) const
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	163 {
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	164 return _src_region_idx == region_idx && is_valid();
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	165 }
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	166
0 a61af66fc99e Initial load duke parents: diff changeset	167 class SpaceInfo
a61af66fc99e Initial load duke parents: diff changeset	168 {
a61af66fc99e Initial load duke parents: diff changeset	169 public:
a61af66fc99e Initial load duke parents: diff changeset	170 MutableSpace* space() const { return _space; }
a61af66fc99e Initial load duke parents: diff changeset	171
a61af66fc99e Initial load duke parents: diff changeset	172 // Where the free space will start after the collection. Valid only after the
a61af66fc99e Initial load duke parents: diff changeset	173 // summary phase completes.
a61af66fc99e Initial load duke parents: diff changeset	174 HeapWord* new_top() const { return _new_top; }
a61af66fc99e Initial load duke parents: diff changeset	175
a61af66fc99e Initial load duke parents: diff changeset	176 // Allows new_top to be set.
a61af66fc99e Initial load duke parents: diff changeset	177 HeapWord** new_top_addr() { return &_new_top; }
a61af66fc99e Initial load duke parents: diff changeset	178
a61af66fc99e Initial load duke parents: diff changeset	179 // Where the smallest allowable dense prefix ends (used only for perm gen).
a61af66fc99e Initial load duke parents: diff changeset	180 HeapWord* min_dense_prefix() const { return _min_dense_prefix; }
a61af66fc99e Initial load duke parents: diff changeset	181
a61af66fc99e Initial load duke parents: diff changeset	182 // Where the dense prefix ends, or the compacted region begins.
a61af66fc99e Initial load duke parents: diff changeset	183 HeapWord* dense_prefix() const { return _dense_prefix; }
a61af66fc99e Initial load duke parents: diff changeset	184
a61af66fc99e Initial load duke parents: diff changeset	185 // The start array for the (generation containing the) space, or NULL if there
a61af66fc99e Initial load duke parents: diff changeset	186 // is no start array.
a61af66fc99e Initial load duke parents: diff changeset	187 ObjectStartArray* start_array() const { return _start_array; }
a61af66fc99e Initial load duke parents: diff changeset	188
482 7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	189 SplitInfo& split_info() { return _split_info; }
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	190
0 a61af66fc99e Initial load duke parents: diff changeset	191 void set_space(MutableSpace* s) { _space = s; }
a61af66fc99e Initial load duke parents: diff changeset	192 void set_new_top(HeapWord* addr) { _new_top = addr; }
a61af66fc99e Initial load duke parents: diff changeset	193 void set_min_dense_prefix(HeapWord* addr) { _min_dense_prefix = addr; }
a61af66fc99e Initial load duke parents: diff changeset	194 void set_dense_prefix(HeapWord* addr) { _dense_prefix = addr; }
a61af66fc99e Initial load duke parents: diff changeset	195 void set_start_array(ObjectStartArray* s) { _start_array = s; }
a61af66fc99e Initial load duke parents: diff changeset	196
482 7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	197 void publish_new_top() const { _space->set_top(_new_top); }
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	198
0 a61af66fc99e Initial load duke parents: diff changeset	199 private:
a61af66fc99e Initial load duke parents: diff changeset	200 MutableSpace* _space;
a61af66fc99e Initial load duke parents: diff changeset	201 HeapWord* _new_top;
a61af66fc99e Initial load duke parents: diff changeset	202 HeapWord* _min_dense_prefix;
a61af66fc99e Initial load duke parents: diff changeset	203 HeapWord* _dense_prefix;
a61af66fc99e Initial load duke parents: diff changeset	204 ObjectStartArray* _start_array;
482 7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	205 SplitInfo _split_info;
0 a61af66fc99e Initial load duke parents: diff changeset	206 };
a61af66fc99e Initial load duke parents: diff changeset	207
a61af66fc99e Initial load duke parents: diff changeset	208 class ParallelCompactData
a61af66fc99e Initial load duke parents: diff changeset	209 {
a61af66fc99e Initial load duke parents: diff changeset	210 public:
a61af66fc99e Initial load duke parents: diff changeset	211 // Sizes are in HeapWords, unless indicated otherwise.
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	212 static const size_t Log2RegionSize;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	213 static const size_t RegionSize;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	214 static const size_t RegionSizeBytes;
0 a61af66fc99e Initial load duke parents: diff changeset	215
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	216 // Mask for the bits in a size_t to get an offset within a region.
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	217 static const size_t RegionSizeOffsetMask;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	218 // Mask for the bits in a pointer to get an offset within a region.
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	219 static const size_t RegionAddrOffsetMask;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	220 // Mask for the bits in a pointer to get the address of the start of a region.
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	221 static const size_t RegionAddrMask;
0 a61af66fc99e Initial load duke parents: diff changeset	222
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	223 class RegionData
0 a61af66fc99e Initial load duke parents: diff changeset	224 {
a61af66fc99e Initial load duke parents: diff changeset	225 public:
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	226 // Destination address of the region.
0 a61af66fc99e Initial load duke parents: diff changeset	227 HeapWord* destination() const { return _destination; }
a61af66fc99e Initial load duke parents: diff changeset	228
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	229 // The first region containing data destined for this region.
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	230 size_t source_region() const { return _source_region; }
0 a61af66fc99e Initial load duke parents: diff changeset	231
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	232 // The object (if any) starting in this region and ending in a different
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	233 // region that could not be updated during the main (parallel) compaction
0 a61af66fc99e Initial load duke parents: diff changeset	234 // phase. This is different from _partial_obj_addr, which is an object that
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	235 // extends onto a source region. However, the two uses do not overlap in
0 a61af66fc99e Initial load duke parents: diff changeset	236 // time, so the same field is used to save space.
a61af66fc99e Initial load duke parents: diff changeset	237 HeapWord* deferred_obj_addr() const { return _partial_obj_addr; }
a61af66fc99e Initial load duke parents: diff changeset	238
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	239 // The starting address of the partial object extending onto the region.
0 a61af66fc99e Initial load duke parents: diff changeset	240 HeapWord* partial_obj_addr() const { return _partial_obj_addr; }
a61af66fc99e Initial load duke parents: diff changeset	241
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	242 // Size of the partial object extending onto the region (words).
0 a61af66fc99e Initial load duke parents: diff changeset	243 size_t partial_obj_size() const { return _partial_obj_size; }
a61af66fc99e Initial load duke parents: diff changeset	244
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	245 // Size of live data that lies within this region due to objects that start
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	246 // in this region (words). This does not include the partial object
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	247 // extending onto the region (if any), or the part of an object that extends
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	248 // onto the next region (if any).
0 a61af66fc99e Initial load duke parents: diff changeset	249 size_t live_obj_size() const { return _dc_and_los & los_mask; }
a61af66fc99e Initial load duke parents: diff changeset	250
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	251 // Total live data that lies within the region (words).
0 a61af66fc99e Initial load duke parents: diff changeset	252 size_t data_size() const { return partial_obj_size() + live_obj_size(); }
a61af66fc99e Initial load duke parents: diff changeset	253
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	254 // The destination_count is the number of other regions to which data from
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	255 // this region will be copied. At the end of the summary phase, the valid
0 a61af66fc99e Initial load duke parents: diff changeset	256 // values of destination_count are
a61af66fc99e Initial load duke parents: diff changeset	257 //
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	258 // 0 - data from the region will be compacted completely into itself, or the
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	259 // region is empty. The region can be claimed and then filled.
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	260 // 1 - data from the region will be compacted into 1 other region; some
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	261 // data from the region may also be compacted into the region itself.
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	262 // 2 - data from the region will be copied to 2 other regions.
0 a61af66fc99e Initial load duke parents: diff changeset	263 //
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	264 // During compaction as regions are emptied, the destination_count is
0 a61af66fc99e Initial load duke parents: diff changeset	265 // decremented (atomically) and when it reaches 0, it can be claimed and
a61af66fc99e Initial load duke parents: diff changeset	266 // then filled.
a61af66fc99e Initial load duke parents: diff changeset	267 //
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	268 // A region is claimed for processing by atomically changing the
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	269 // destination_count to the claimed value (dc_claimed). After a region has
0 a61af66fc99e Initial load duke parents: diff changeset	270 // been filled, the destination_count should be set to the completed value
a61af66fc99e Initial load duke parents: diff changeset	271 // (dc_completed).
a61af66fc99e Initial load duke parents: diff changeset	272 inline uint destination_count() const;
a61af66fc99e Initial load duke parents: diff changeset	273 inline uint destination_count_raw() const;
a61af66fc99e Initial load duke parents: diff changeset	274
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	275 // The location of the java heap data that corresponds to this region.
0 a61af66fc99e Initial load duke parents: diff changeset	276 inline HeapWord* data_location() const;
a61af66fc99e Initial load duke parents: diff changeset	277
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	278 // The highest address referenced by objects in this region.
0 a61af66fc99e Initial load duke parents: diff changeset	279 inline HeapWord* highest_ref() const;
a61af66fc99e Initial load duke parents: diff changeset	280
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	281 // Whether this region is available to be claimed, has been claimed, or has
0 a61af66fc99e Initial load duke parents: diff changeset	282 // been completed.
a61af66fc99e Initial load duke parents: diff changeset	283 //
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	284 // Minor subtlety: claimed() returns true if the region is marked
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	285 // completed(), which is desirable since a region must be claimed before it
0 a61af66fc99e Initial load duke parents: diff changeset	286 // can be completed.
a61af66fc99e Initial load duke parents: diff changeset	287 bool available() const { return _dc_and_los < dc_one; }
a61af66fc99e Initial load duke parents: diff changeset	288 bool claimed() const { return _dc_and_los >= dc_claimed; }
a61af66fc99e Initial load duke parents: diff changeset	289 bool completed() const { return _dc_and_los >= dc_completed; }
a61af66fc99e Initial load duke parents: diff changeset	290
a61af66fc99e Initial load duke parents: diff changeset	291 // These are not atomic.
a61af66fc99e Initial load duke parents: diff changeset	292 void set_destination(HeapWord* addr) { _destination = addr; }
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	293 void set_source_region(size_t region) { _source_region = region; }
0 a61af66fc99e Initial load duke parents: diff changeset	294 void set_deferred_obj_addr(HeapWord* addr) { _partial_obj_addr = addr; }
a61af66fc99e Initial load duke parents: diff changeset	295 void set_partial_obj_addr(HeapWord* addr) { _partial_obj_addr = addr; }
a61af66fc99e Initial load duke parents: diff changeset	296 void set_partial_obj_size(size_t words) {
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	297 _partial_obj_size = (region_sz_t) words;
0 a61af66fc99e Initial load duke parents: diff changeset	298 }
a61af66fc99e Initial load duke parents: diff changeset	299
a61af66fc99e Initial load duke parents: diff changeset	300 inline void set_destination_count(uint count);
a61af66fc99e Initial load duke parents: diff changeset	301 inline void set_live_obj_size(size_t words);
a61af66fc99e Initial load duke parents: diff changeset	302 inline void set_data_location(HeapWord* addr);
a61af66fc99e Initial load duke parents: diff changeset	303 inline void set_completed();
a61af66fc99e Initial load duke parents: diff changeset	304 inline bool claim_unsafe();
a61af66fc99e Initial load duke parents: diff changeset	305
a61af66fc99e Initial load duke parents: diff changeset	306 // These are atomic.
a61af66fc99e Initial load duke parents: diff changeset	307 inline void add_live_obj(size_t words);
a61af66fc99e Initial load duke parents: diff changeset	308 inline void set_highest_ref(HeapWord* addr);
a61af66fc99e Initial load duke parents: diff changeset	309 inline void decrement_destination_count();
a61af66fc99e Initial load duke parents: diff changeset	310 inline bool claim();
a61af66fc99e Initial load duke parents: diff changeset	311
a61af66fc99e Initial load duke parents: diff changeset	312 private:
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	313 // The type used to represent object sizes within a region.
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	314 typedef uint region_sz_t;
0 a61af66fc99e Initial load duke parents: diff changeset	315
a61af66fc99e Initial load duke parents: diff changeset	316 // Constants for manipulating the _dc_and_los field, which holds both the
a61af66fc99e Initial load duke parents: diff changeset	317 // destination count and live obj size. The live obj size lives at the
a61af66fc99e Initial load duke parents: diff changeset	318 // least significant end so no masking is necessary when adding.
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	319 static const region_sz_t dc_shift; // Shift amount.
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	320 static const region_sz_t dc_mask; // Mask for destination count.
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	321 static const region_sz_t dc_one; // 1, shifted appropriately.
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	322 static const region_sz_t dc_claimed; // Region has been claimed.
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	323 static const region_sz_t dc_completed; // Region has been completed.
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	324 static const region_sz_t los_mask; // Mask for live obj size.
0 a61af66fc99e Initial load duke parents: diff changeset	325
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	326 HeapWord* _destination;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	327 size_t _source_region;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	328 HeapWord* _partial_obj_addr;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	329 region_sz_t _partial_obj_size;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	330 region_sz_t volatile _dc_and_los;
0 a61af66fc99e Initial load duke parents: diff changeset	331 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	332 // These enable optimizations that are only partially implemented. Use
a61af66fc99e Initial load duke parents: diff changeset	333 // debug builds to prevent the code fragments from breaking.
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	334 HeapWord* _data_location;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	335 HeapWord* _highest_ref;
0 a61af66fc99e Initial load duke parents: diff changeset	336 #endif // #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	337
a61af66fc99e Initial load duke parents: diff changeset	338 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	339 public:
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	340 uint _pushed; // 0 until region is pushed onto a worker's stack
0 a61af66fc99e Initial load duke parents: diff changeset	341 private:
a61af66fc99e Initial load duke parents: diff changeset	342 #endif
a61af66fc99e Initial load duke parents: diff changeset	343 };
a61af66fc99e Initial load duke parents: diff changeset	344
a61af66fc99e Initial load duke parents: diff changeset	345 public:
a61af66fc99e Initial load duke parents: diff changeset	346 ParallelCompactData();
a61af66fc99e Initial load duke parents: diff changeset	347 bool initialize(MemRegion covered_region);
a61af66fc99e Initial load duke parents: diff changeset	348
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	349 size_t region_count() const { return _region_count; }
0 a61af66fc99e Initial load duke parents: diff changeset	350
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	351 // Convert region indices to/from RegionData pointers.
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	352 inline RegionData* region(size_t region_idx) const;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	353 inline size_t region(const RegionData* const region_ptr) const;
0 a61af66fc99e Initial load duke parents: diff changeset	354
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	355 // Returns true if the given address is contained within the region
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	356 bool region_contains(size_t region_index, HeapWord* addr);
0 a61af66fc99e Initial load duke parents: diff changeset	357
a61af66fc99e Initial load duke parents: diff changeset	358 void add_obj(HeapWord* addr, size_t len);
a61af66fc99e Initial load duke parents: diff changeset	359 void add_obj(oop p, size_t len) { add_obj((HeapWord*)p, len); }
a61af66fc99e Initial load duke parents: diff changeset	360
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	361 // Fill in the regions covering [beg, end) so that no data moves; i.e., the
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	362 // destination of region n is simply the start of region n. The argument beg
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	363 // must be region-aligned; end need not be.
0 a61af66fc99e Initial load duke parents: diff changeset	364 void summarize_dense_prefix(HeapWord* beg, HeapWord* end);
a61af66fc99e Initial load duke parents: diff changeset	365
482 7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	366 HeapWord* summarize_split_space(size_t src_region, SplitInfo& split_info,
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	367 HeapWord* destination, HeapWord* target_end,
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	368 HeapWord** target_next);
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	369 bool summarize(SplitInfo& split_info,
0 a61af66fc99e Initial load duke parents: diff changeset	370 HeapWord* source_beg, HeapWord* source_end,
482 7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	371 HeapWord** source_next,
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	372 HeapWord* target_beg, HeapWord* target_end,
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	373 HeapWord** target_next);
0 a61af66fc99e Initial load duke parents: diff changeset	374
a61af66fc99e Initial load duke parents: diff changeset	375 void clear();
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	376 void clear_range(size_t beg_region, size_t end_region);
0 a61af66fc99e Initial load duke parents: diff changeset	377 void clear_range(HeapWord* beg, HeapWord* end) {
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	378 clear_range(addr_to_region_idx(beg), addr_to_region_idx(end));
0 a61af66fc99e Initial load duke parents: diff changeset	379 }
a61af66fc99e Initial load duke parents: diff changeset	380
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	381 // Return the number of words between addr and the start of the region
0 a61af66fc99e Initial load duke parents: diff changeset	382 // containing addr.
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	383 inline size_t region_offset(const HeapWord* addr) const;
0 a61af66fc99e Initial load duke parents: diff changeset	384
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	385 // Convert addresses to/from a region index or region pointer.
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	386 inline size_t addr_to_region_idx(const HeapWord* addr) const;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	387 inline RegionData* addr_to_region_ptr(const HeapWord* addr) const;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	388 inline HeapWord* region_to_addr(size_t region) const;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	389 inline HeapWord* region_to_addr(size_t region, size_t offset) const;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	390 inline HeapWord* region_to_addr(const RegionData* region) const;
0 a61af66fc99e Initial load duke parents: diff changeset	391
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	392 inline HeapWord* region_align_down(HeapWord* addr) const;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	393 inline HeapWord* region_align_up(HeapWord* addr) const;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	394 inline bool is_region_aligned(HeapWord* addr) const;
0 a61af66fc99e Initial load duke parents: diff changeset	395
a61af66fc99e Initial load duke parents: diff changeset	396 // Return the address one past the end of the partial object.
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	397 HeapWord* partial_obj_end(size_t region_idx) const;
0 a61af66fc99e Initial load duke parents: diff changeset	398
a61af66fc99e Initial load duke parents: diff changeset	399 // Return the new location of the object p after the
a61af66fc99e Initial load duke parents: diff changeset	400 // the compaction.
a61af66fc99e Initial load duke parents: diff changeset	401 HeapWord* calc_new_pointer(HeapWord* addr);
a61af66fc99e Initial load duke parents: diff changeset	402
a61af66fc99e Initial load duke parents: diff changeset	403 HeapWord* calc_new_pointer(oop p) {
a61af66fc99e Initial load duke parents: diff changeset	404 return calc_new_pointer((HeapWord*) p);
a61af66fc99e Initial load duke parents: diff changeset	405 }
a61af66fc99e Initial load duke parents: diff changeset	406
a61af66fc99e Initial load duke parents: diff changeset	407 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	408 void verify_clear(const PSVirtualSpace* vspace);
a61af66fc99e Initial load duke parents: diff changeset	409 void verify_clear();
a61af66fc99e Initial load duke parents: diff changeset	410 #endif // #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	411
a61af66fc99e Initial load duke parents: diff changeset	412 private:
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	413 bool initialize_region_data(size_t region_size);
0 a61af66fc99e Initial load duke parents: diff changeset	414 PSVirtualSpace* create_vspace(size_t count, size_t element_size);
a61af66fc99e Initial load duke parents: diff changeset	415
a61af66fc99e Initial load duke parents: diff changeset	416 private:
a61af66fc99e Initial load duke parents: diff changeset	417 HeapWord* _region_start;
a61af66fc99e Initial load duke parents: diff changeset	418 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	419 HeapWord* _region_end;
a61af66fc99e Initial load duke parents: diff changeset	420 #endif // #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	421
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	422 PSVirtualSpace* _region_vspace;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	423 RegionData* _region_data;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	424 size_t _region_count;
0 a61af66fc99e Initial load duke parents: diff changeset	425 };
a61af66fc99e Initial load duke parents: diff changeset	426
a61af66fc99e Initial load duke parents: diff changeset	427 inline uint
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	428 ParallelCompactData::RegionData::destination_count_raw() const
0 a61af66fc99e Initial load duke parents: diff changeset	429 {
a61af66fc99e Initial load duke parents: diff changeset	430 return _dc_and_los & dc_mask;
a61af66fc99e Initial load duke parents: diff changeset	431 }
a61af66fc99e Initial load duke parents: diff changeset	432
a61af66fc99e Initial load duke parents: diff changeset	433 inline uint
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	434 ParallelCompactData::RegionData::destination_count() const
0 a61af66fc99e Initial load duke parents: diff changeset	435 {
a61af66fc99e Initial load duke parents: diff changeset	436 return destination_count_raw() >> dc_shift;
a61af66fc99e Initial load duke parents: diff changeset	437 }
a61af66fc99e Initial load duke parents: diff changeset	438
a61af66fc99e Initial load duke parents: diff changeset	439 inline void
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	440 ParallelCompactData::RegionData::set_destination_count(uint count)
0 a61af66fc99e Initial load duke parents: diff changeset	441 {
a61af66fc99e Initial load duke parents: diff changeset	442 assert(count <= (dc_completed >> dc_shift), "count too large");
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	443 const region_sz_t live_sz = (region_sz_t) live_obj_size();
0 a61af66fc99e Initial load duke parents: diff changeset	444 _dc_and_los = (count << dc_shift) \| live_sz;
a61af66fc99e Initial load duke parents: diff changeset	445 }
a61af66fc99e Initial load duke parents: diff changeset	446
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	447 inline void ParallelCompactData::RegionData::set_live_obj_size(size_t words)
0 a61af66fc99e Initial load duke parents: diff changeset	448 {
a61af66fc99e Initial load duke parents: diff changeset	449 assert(words <= los_mask, "would overflow");
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	450 _dc_and_los = destination_count_raw() \| (region_sz_t)words;
0 a61af66fc99e Initial load duke parents: diff changeset	451 }
a61af66fc99e Initial load duke parents: diff changeset	452
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	453 inline void ParallelCompactData::RegionData::decrement_destination_count()
0 a61af66fc99e Initial load duke parents: diff changeset	454 {
a61af66fc99e Initial load duke parents: diff changeset	455 assert(_dc_and_los < dc_claimed, "already claimed");
a61af66fc99e Initial load duke parents: diff changeset	456 assert(_dc_and_los >= dc_one, "count would go negative");
a61af66fc99e Initial load duke parents: diff changeset	457 Atomic::add((int)dc_mask, (volatile int*)&_dc_and_los);
a61af66fc99e Initial load duke parents: diff changeset	458 }
a61af66fc99e Initial load duke parents: diff changeset	459
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	460 inline HeapWord* ParallelCompactData::RegionData::data_location() const
0 a61af66fc99e Initial load duke parents: diff changeset	461 {
a61af66fc99e Initial load duke parents: diff changeset	462 DEBUG_ONLY(return _data_location;)
a61af66fc99e Initial load duke parents: diff changeset	463 NOT_DEBUG(return NULL;)
a61af66fc99e Initial load duke parents: diff changeset	464 }
a61af66fc99e Initial load duke parents: diff changeset	465
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	466 inline HeapWord* ParallelCompactData::RegionData::highest_ref() const
0 a61af66fc99e Initial load duke parents: diff changeset	467 {
a61af66fc99e Initial load duke parents: diff changeset	468 DEBUG_ONLY(return _highest_ref;)
a61af66fc99e Initial load duke parents: diff changeset	469 NOT_DEBUG(return NULL;)
a61af66fc99e Initial load duke parents: diff changeset	470 }
a61af66fc99e Initial load duke parents: diff changeset	471
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	472 inline void ParallelCompactData::RegionData::set_data_location(HeapWord* addr)
0 a61af66fc99e Initial load duke parents: diff changeset	473 {
a61af66fc99e Initial load duke parents: diff changeset	474 DEBUG_ONLY(_data_location = addr;)
a61af66fc99e Initial load duke parents: diff changeset	475 }
a61af66fc99e Initial load duke parents: diff changeset	476
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	477 inline void ParallelCompactData::RegionData::set_completed()
0 a61af66fc99e Initial load duke parents: diff changeset	478 {
a61af66fc99e Initial load duke parents: diff changeset	479 assert(claimed(), "must be claimed first");
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	480 _dc_and_los = dc_completed \| (region_sz_t) live_obj_size();
0 a61af66fc99e Initial load duke parents: diff changeset	481 }
a61af66fc99e Initial load duke parents: diff changeset	482
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	483 // MT-unsafe claiming of a region. Should only be used during single threaded
0 a61af66fc99e Initial load duke parents: diff changeset	484 // execution.
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	485 inline bool ParallelCompactData::RegionData::claim_unsafe()
0 a61af66fc99e Initial load duke parents: diff changeset	486 {
a61af66fc99e Initial load duke parents: diff changeset	487 if (available()) {
a61af66fc99e Initial load duke parents: diff changeset	488 _dc_and_los \|= dc_claimed;
a61af66fc99e Initial load duke parents: diff changeset	489 return true;
a61af66fc99e Initial load duke parents: diff changeset	490 }
a61af66fc99e Initial load duke parents: diff changeset	491 return false;
a61af66fc99e Initial load duke parents: diff changeset	492 }
a61af66fc99e Initial load duke parents: diff changeset	493
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	494 inline void ParallelCompactData::RegionData::add_live_obj(size_t words)
0 a61af66fc99e Initial load duke parents: diff changeset	495 {
a61af66fc99e Initial load duke parents: diff changeset	496 assert(words <= (size_t)los_mask - live_obj_size(), "overflow");
a61af66fc99e Initial load duke parents: diff changeset	497 Atomic::add((int) words, (volatile int*) &_dc_and_los);
a61af66fc99e Initial load duke parents: diff changeset	498 }
a61af66fc99e Initial load duke parents: diff changeset	499
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	500 inline void ParallelCompactData::RegionData::set_highest_ref(HeapWord* addr)
0 a61af66fc99e Initial load duke parents: diff changeset	501 {
a61af66fc99e Initial load duke parents: diff changeset	502 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	503 HeapWord* tmp = _highest_ref;
a61af66fc99e Initial load duke parents: diff changeset	504 while (addr > tmp) {
a61af66fc99e Initial load duke parents: diff changeset	505 tmp = (HeapWord*)Atomic::cmpxchg_ptr(addr, &_highest_ref, tmp);
a61af66fc99e Initial load duke parents: diff changeset	506 }
a61af66fc99e Initial load duke parents: diff changeset	507 #endif // #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	508 }
a61af66fc99e Initial load duke parents: diff changeset	509
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	510 inline bool ParallelCompactData::RegionData::claim()
0 a61af66fc99e Initial load duke parents: diff changeset	511 {
a61af66fc99e Initial load duke parents: diff changeset	512 const int los = (int) live_obj_size();
a61af66fc99e Initial load duke parents: diff changeset	513 const int old = Atomic::cmpxchg(dc_claimed \| los,
a61af66fc99e Initial load duke parents: diff changeset	514 (volatile int*) &_dc_and_los, los);
a61af66fc99e Initial load duke parents: diff changeset	515 return old == los;
a61af66fc99e Initial load duke parents: diff changeset	516 }
a61af66fc99e Initial load duke parents: diff changeset	517
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	518 inline ParallelCompactData::RegionData*
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	519 ParallelCompactData::region(size_t region_idx) const
0 a61af66fc99e Initial load duke parents: diff changeset	520 {
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	521 assert(region_idx <= region_count(), "bad arg");
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	522 return _region_data + region_idx;
0 a61af66fc99e Initial load duke parents: diff changeset	523 }
a61af66fc99e Initial load duke parents: diff changeset	524
a61af66fc99e Initial load duke parents: diff changeset	525 inline size_t
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	526 ParallelCompactData::region(const RegionData* const region_ptr) const
0 a61af66fc99e Initial load duke parents: diff changeset	527 {
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	528 assert(region_ptr >= _region_data, "bad arg");
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	529 assert(region_ptr <= _region_data + region_count(), "bad arg");
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	530 return pointer_delta(region_ptr, _region_data, sizeof(RegionData));
0 a61af66fc99e Initial load duke parents: diff changeset	531 }
a61af66fc99e Initial load duke parents: diff changeset	532
a61af66fc99e Initial load duke parents: diff changeset	533 inline size_t
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	534 ParallelCompactData::region_offset(const HeapWord* addr) const
0 a61af66fc99e Initial load duke parents: diff changeset	535 {
a61af66fc99e Initial load duke parents: diff changeset	536 assert(addr >= _region_start, "bad addr");
a61af66fc99e Initial load duke parents: diff changeset	537 assert(addr <= _region_end, "bad addr");
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	538 return (size_t(addr) & RegionAddrOffsetMask) >> LogHeapWordSize;
0 a61af66fc99e Initial load duke parents: diff changeset	539 }
a61af66fc99e Initial load duke parents: diff changeset	540
a61af66fc99e Initial load duke parents: diff changeset	541 inline size_t
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	542 ParallelCompactData::addr_to_region_idx(const HeapWord* addr) const
0 a61af66fc99e Initial load duke parents: diff changeset	543 {
a61af66fc99e Initial load duke parents: diff changeset	544 assert(addr >= _region_start, "bad addr");
a61af66fc99e Initial load duke parents: diff changeset	545 assert(addr <= _region_end, "bad addr");
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	546 return pointer_delta(addr, _region_start) >> Log2RegionSize;
0 a61af66fc99e Initial load duke parents: diff changeset	547 }
a61af66fc99e Initial load duke parents: diff changeset	548
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	549 inline ParallelCompactData::RegionData*
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	550 ParallelCompactData::addr_to_region_ptr(const HeapWord* addr) const
0 a61af66fc99e Initial load duke parents: diff changeset	551 {
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	552 return region(addr_to_region_idx(addr));
0 a61af66fc99e Initial load duke parents: diff changeset	553 }
a61af66fc99e Initial load duke parents: diff changeset	554
a61af66fc99e Initial load duke parents: diff changeset	555 inline HeapWord*
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	556 ParallelCompactData::region_to_addr(size_t region) const
0 a61af66fc99e Initial load duke parents: diff changeset	557 {
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	558 assert(region <= _region_count, "region out of range");
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	559 return _region_start + (region << Log2RegionSize);
0 a61af66fc99e Initial load duke parents: diff changeset	560 }
a61af66fc99e Initial load duke parents: diff changeset	561
a61af66fc99e Initial load duke parents: diff changeset	562 inline HeapWord*
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	563 ParallelCompactData::region_to_addr(const RegionData* region) const
0 a61af66fc99e Initial load duke parents: diff changeset	564 {
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	565 return region_to_addr(pointer_delta(region, _region_data,
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	566 sizeof(RegionData)));
0 a61af66fc99e Initial load duke parents: diff changeset	567 }
a61af66fc99e Initial load duke parents: diff changeset	568
a61af66fc99e Initial load duke parents: diff changeset	569 inline HeapWord*
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	570 ParallelCompactData::region_to_addr(size_t region, size_t offset) const
0 a61af66fc99e Initial load duke parents: diff changeset	571 {
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	572 assert(region <= _region_count, "region out of range");
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	573 assert(offset < RegionSize, "offset too big"); // This may be too strict.
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	574 return region_to_addr(region) + offset;
0 a61af66fc99e Initial load duke parents: diff changeset	575 }
a61af66fc99e Initial load duke parents: diff changeset	576
a61af66fc99e Initial load duke parents: diff changeset	577 inline HeapWord*
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	578 ParallelCompactData::region_align_down(HeapWord* addr) const
0 a61af66fc99e Initial load duke parents: diff changeset	579 {
a61af66fc99e Initial load duke parents: diff changeset	580 assert(addr >= _region_start, "bad addr");
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	581 assert(addr < _region_end + RegionSize, "bad addr");
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	582 return (HeapWord*)(size_t(addr) & RegionAddrMask);
0 a61af66fc99e Initial load duke parents: diff changeset	583 }
a61af66fc99e Initial load duke parents: diff changeset	584
a61af66fc99e Initial load duke parents: diff changeset	585 inline HeapWord*
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	586 ParallelCompactData::region_align_up(HeapWord* addr) const
0 a61af66fc99e Initial load duke parents: diff changeset	587 {
a61af66fc99e Initial load duke parents: diff changeset	588 assert(addr >= _region_start, "bad addr");
a61af66fc99e Initial load duke parents: diff changeset	589 assert(addr <= _region_end, "bad addr");
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	590 return region_align_down(addr + RegionSizeOffsetMask);
0 a61af66fc99e Initial load duke parents: diff changeset	591 }
a61af66fc99e Initial load duke parents: diff changeset	592
a61af66fc99e Initial load duke parents: diff changeset	593 inline bool
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	594 ParallelCompactData::is_region_aligned(HeapWord* addr) const
0 a61af66fc99e Initial load duke parents: diff changeset	595 {
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	596 return region_offset(addr) == 0;
0 a61af66fc99e Initial load duke parents: diff changeset	597 }
a61af66fc99e Initial load duke parents: diff changeset	598
a61af66fc99e Initial load duke parents: diff changeset	599 // Abstract closure for use with ParMarkBitMap::iterate(), which will invoke the
a61af66fc99e Initial load duke parents: diff changeset	600 // do_addr() method.
a61af66fc99e Initial load duke parents: diff changeset	601 //
a61af66fc99e Initial load duke parents: diff changeset	602 // The closure is initialized with the number of heap words to process
a61af66fc99e Initial load duke parents: diff changeset	603 // (words_remaining()), and becomes 'full' when it reaches 0. The do_addr()
a61af66fc99e Initial load duke parents: diff changeset	604 // methods in subclasses should update the total as words are processed. Since
a61af66fc99e Initial load duke parents: diff changeset	605 // only one subclass actually uses this mechanism to terminate iteration, the
a61af66fc99e Initial load duke parents: diff changeset	606 // default initial value is > 0. The implementation is here and not in the
a61af66fc99e Initial load duke parents: diff changeset	607 // single subclass that uses it to avoid making is_full() virtual, and thus
a61af66fc99e Initial load duke parents: diff changeset	608 // adding a virtual call per live object.
a61af66fc99e Initial load duke parents: diff changeset	609
a61af66fc99e Initial load duke parents: diff changeset	610 class ParMarkBitMapClosure: public StackObj {
a61af66fc99e Initial load duke parents: diff changeset	611 public:
a61af66fc99e Initial load duke parents: diff changeset	612 typedef ParMarkBitMap::idx_t idx_t;
a61af66fc99e Initial load duke parents: diff changeset	613 typedef ParMarkBitMap::IterationStatus IterationStatus;
a61af66fc99e Initial load duke parents: diff changeset	614
a61af66fc99e Initial load duke parents: diff changeset	615 public:
a61af66fc99e Initial load duke parents: diff changeset	616 inline ParMarkBitMapClosure(ParMarkBitMap* mbm, ParCompactionManager* cm,
a61af66fc99e Initial load duke parents: diff changeset	617 size_t words = max_uintx);
a61af66fc99e Initial load duke parents: diff changeset	618
a61af66fc99e Initial load duke parents: diff changeset	619 inline ParCompactionManager* compaction_manager() const;
a61af66fc99e Initial load duke parents: diff changeset	620 inline ParMarkBitMap* bitmap() const;
a61af66fc99e Initial load duke parents: diff changeset	621 inline size_t words_remaining() const;
a61af66fc99e Initial load duke parents: diff changeset	622 inline bool is_full() const;
a61af66fc99e Initial load duke parents: diff changeset	623 inline HeapWord* source() const;
a61af66fc99e Initial load duke parents: diff changeset	624
a61af66fc99e Initial load duke parents: diff changeset	625 inline void set_source(HeapWord* addr);
a61af66fc99e Initial load duke parents: diff changeset	626
a61af66fc99e Initial load duke parents: diff changeset	627 virtual IterationStatus do_addr(HeapWord* addr, size_t words) = 0;
a61af66fc99e Initial load duke parents: diff changeset	628
a61af66fc99e Initial load duke parents: diff changeset	629 protected:
a61af66fc99e Initial load duke parents: diff changeset	630 inline void decrement_words_remaining(size_t words);
a61af66fc99e Initial load duke parents: diff changeset	631
a61af66fc99e Initial load duke parents: diff changeset	632 private:
a61af66fc99e Initial load duke parents: diff changeset	633 ParMarkBitMap* const _bitmap;
a61af66fc99e Initial load duke parents: diff changeset	634 ParCompactionManager* const _compaction_manager;
a61af66fc99e Initial load duke parents: diff changeset	635 DEBUG_ONLY(const size_t _initial_words_remaining;) // Useful in debugger.
a61af66fc99e Initial load duke parents: diff changeset	636 size_t _words_remaining; // Words left to copy.
a61af66fc99e Initial load duke parents: diff changeset	637
a61af66fc99e Initial load duke parents: diff changeset	638 protected:
a61af66fc99e Initial load duke parents: diff changeset	639 HeapWord* _source; // Next addr that would be read.
a61af66fc99e Initial load duke parents: diff changeset	640 };
a61af66fc99e Initial load duke parents: diff changeset	641
a61af66fc99e Initial load duke parents: diff changeset	642 inline
a61af66fc99e Initial load duke parents: diff changeset	643 ParMarkBitMapClosure::ParMarkBitMapClosure(ParMarkBitMap* bitmap,
a61af66fc99e Initial load duke parents: diff changeset	644 ParCompactionManager* cm,
a61af66fc99e Initial load duke parents: diff changeset	645 size_t words):
a61af66fc99e Initial load duke parents: diff changeset	646 _bitmap(bitmap), _compaction_manager(cm)
a61af66fc99e Initial load duke parents: diff changeset	647 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	648 , _initial_words_remaining(words)
a61af66fc99e Initial load duke parents: diff changeset	649 #endif
a61af66fc99e Initial load duke parents: diff changeset	650 {
a61af66fc99e Initial load duke parents: diff changeset	651 _words_remaining = words;
a61af66fc99e Initial load duke parents: diff changeset	652 _source = NULL;
a61af66fc99e Initial load duke parents: diff changeset	653 }
a61af66fc99e Initial load duke parents: diff changeset	654
a61af66fc99e Initial load duke parents: diff changeset	655 inline ParCompactionManager* ParMarkBitMapClosure::compaction_manager() const {
a61af66fc99e Initial load duke parents: diff changeset	656 return _compaction_manager;
a61af66fc99e Initial load duke parents: diff changeset	657 }
a61af66fc99e Initial load duke parents: diff changeset	658
a61af66fc99e Initial load duke parents: diff changeset	659 inline ParMarkBitMap* ParMarkBitMapClosure::bitmap() const {
a61af66fc99e Initial load duke parents: diff changeset	660 return _bitmap;
a61af66fc99e Initial load duke parents: diff changeset	661 }
a61af66fc99e Initial load duke parents: diff changeset	662
a61af66fc99e Initial load duke parents: diff changeset	663 inline size_t ParMarkBitMapClosure::words_remaining() const {
a61af66fc99e Initial load duke parents: diff changeset	664 return _words_remaining;
a61af66fc99e Initial load duke parents: diff changeset	665 }
a61af66fc99e Initial load duke parents: diff changeset	666
a61af66fc99e Initial load duke parents: diff changeset	667 inline bool ParMarkBitMapClosure::is_full() const {
a61af66fc99e Initial load duke parents: diff changeset	668 return words_remaining() == 0;
a61af66fc99e Initial load duke parents: diff changeset	669 }
a61af66fc99e Initial load duke parents: diff changeset	670
a61af66fc99e Initial load duke parents: diff changeset	671 inline HeapWord* ParMarkBitMapClosure::source() const {
a61af66fc99e Initial load duke parents: diff changeset	672 return _source;
a61af66fc99e Initial load duke parents: diff changeset	673 }
a61af66fc99e Initial load duke parents: diff changeset	674
a61af66fc99e Initial load duke parents: diff changeset	675 inline void ParMarkBitMapClosure::set_source(HeapWord* addr) {
a61af66fc99e Initial load duke parents: diff changeset	676 _source = addr;
a61af66fc99e Initial load duke parents: diff changeset	677 }
a61af66fc99e Initial load duke parents: diff changeset	678
a61af66fc99e Initial load duke parents: diff changeset	679 inline void ParMarkBitMapClosure::decrement_words_remaining(size_t words) {
a61af66fc99e Initial load duke parents: diff changeset	680 assert(_words_remaining >= words, "processed too many words");
a61af66fc99e Initial load duke parents: diff changeset	681 _words_remaining -= words;
a61af66fc99e Initial load duke parents: diff changeset	682 }
a61af66fc99e Initial load duke parents: diff changeset	683
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	684 // The UseParallelOldGC collector is a stop-the-world garbage collector that
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	685 // does parts of the collection using parallel threads. The collection includes
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	686 // the tenured generation and the young generation. The permanent generation is
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	687 // collected at the same time as the other two generations but the permanent
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	688 // generation is collect by a single GC thread. The permanent generation is
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	689 // collected serially because of the requirement that during the processing of a
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	690 // klass AAA, any objects reference by AAA must already have been processed.
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	691 // This requirement is enforced by a left (lower address) to right (higher
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	692 // address) sliding compaction.
263 12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 113 diff changeset	693 //
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 113 diff changeset	694 // There are four phases of the collection.
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 113 diff changeset	695 //
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 113 diff changeset	696 // - marking phase
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 113 diff changeset	697 // - summary phase
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 113 diff changeset	698 // - compacting phase
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 113 diff changeset	699 // - clean up phase
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 113 diff changeset	700 //
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 113 diff changeset	701 // Roughly speaking these phases correspond, respectively, to
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 113 diff changeset	702 // - mark all the live objects
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 113 diff changeset	703 // - calculate the destination of each object at the end of the collection
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 113 diff changeset	704 // - move the objects to their destination
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 113 diff changeset	705 // - update some references and reinitialize some variables
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 113 diff changeset	706 //
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	707 // These three phases are invoked in PSParallelCompact::invoke_no_policy(). The
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	708 // marking phase is implemented in PSParallelCompact::marking_phase() and does a
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	709 // complete marking of the heap. The summary phase is implemented in
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	710 // PSParallelCompact::summary_phase(). The move and update phase is implemented
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	711 // in PSParallelCompact::compact().
263 12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 113 diff changeset	712 //
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	713 // A space that is being collected is divided into regions and with each region
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	714 // is associated an object of type ParallelCompactData. Each region is of a
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	715 // fixed size and typically will contain more than 1 object and may have parts
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	716 // of objects at the front and back of the region.
263 12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 113 diff changeset	717 //
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	718 // region -----+---------------------+----------
263 12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 113 diff changeset	719 // objects covered [ AAA )[ BBB )[ CCC )[ DDD )
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 113 diff changeset	720 //
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	721 // The marking phase does a complete marking of all live objects in the heap.
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	722 // The marking also compiles the size of the data for all live objects covered
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	723 // by the region. This size includes the part of any live object spanning onto
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	724 // the region (part of AAA if it is live) from the front, all live objects
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	725 // contained in the region (BBB and/or CCC if they are live), and the part of
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	726 // any live objects covered by the region that extends off the region (part of
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	727 // DDD if it is live). The marking phase uses multiple GC threads and marking
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	728 // is done in a bit array of type ParMarkBitMap. The marking of the bit map is
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	729 // done atomically as is the accumulation of the size of the live objects
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	730 // covered by a region.
263 12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 113 diff changeset	731 //
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	732 // The summary phase calculates the total live data to the left of each region
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	733 // XXX. Based on that total and the bottom of the space, it can calculate the
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	734 // starting location of the live data in XXX. The summary phase calculates for
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	735 // each region XXX quantites such as
263 12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 113 diff changeset	736 //
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	737 // - the amount of live data at the beginning of a region from an object
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	738 // entering the region.
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	739 // - the location of the first live data on the region
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	740 // - a count of the number of regions receiving live data from XXX.
263 12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 113 diff changeset	741 //
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 113 diff changeset	742 // See ParallelCompactData for precise details. The summary phase also
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	743 // calculates the dense prefix for the compaction. The dense prefix is a
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	744 // portion at the beginning of the space that is not moved. The objects in the
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	745 // dense prefix do need to have their object references updated. See method
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	746 // summarize_dense_prefix().
263 12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 113 diff changeset	747 //
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 113 diff changeset	748 // The summary phase is done using 1 GC thread.
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 113 diff changeset	749 //
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	750 // The compaction phase moves objects to their new location and updates all
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	751 // references in the object.
263 12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 113 diff changeset	752 //
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	753 // A current exception is that objects that cross a region boundary are moved
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	754 // but do not have their references updated. References are not updated because
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	755 // it cannot easily be determined if the klass pointer KKK for the object AAA
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	756 // has been updated. KKK likely resides in a region to the left of the region
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	757 // containing AAA. These AAA's have there references updated at the end in a
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	758 // clean up phase. See the method PSParallelCompact::update_deferred_objects().
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	759 // An alternate strategy is being investigated for this deferral of updating.
263 12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 113 diff changeset	760 //
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	761 // Compaction is done on a region basis. A region that is ready to be filled is
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	762 // put on a ready list and GC threads take region off the list and fill them. A
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	763 // region is ready to be filled if it empty of live objects. Such a region may
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	764 // have been initially empty (only contained dead objects) or may have had all
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	765 // its live objects copied out already. A region that compacts into itself is
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	766 // also ready for filling. The ready list is initially filled with empty
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	767 // regions and regions compacting into themselves. There is always at least 1
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	768 // region that can be put on the ready list. The regions are atomically added
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	769 // and removed from the ready list.
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	770
0 a61af66fc99e Initial load duke parents: diff changeset	771 class PSParallelCompact : AllStatic {
a61af66fc99e Initial load duke parents: diff changeset	772 public:
a61af66fc99e Initial load duke parents: diff changeset	773 // Convenient access to type names.
a61af66fc99e Initial load duke parents: diff changeset	774 typedef ParMarkBitMap::idx_t idx_t;
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	775 typedef ParallelCompactData::RegionData RegionData;
0 a61af66fc99e Initial load duke parents: diff changeset	776
a61af66fc99e Initial load duke parents: diff changeset	777 typedef enum {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4913 diff changeset	778 old_space_id, eden_space_id,
0 a61af66fc99e Initial load duke parents: diff changeset	779 from_space_id, to_space_id, last_space_id
a61af66fc99e Initial load duke parents: diff changeset	780 } SpaceId;
a61af66fc99e Initial load duke parents: diff changeset	781
a61af66fc99e Initial load duke parents: diff changeset	782 public:
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	783 // Inline closure decls
0 a61af66fc99e Initial load duke parents: diff changeset	784 //
a61af66fc99e Initial load duke parents: diff changeset	785 class IsAliveClosure: public BoolObjectClosure {
a61af66fc99e Initial load duke parents: diff changeset	786 public:
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	787 virtual void do_object(oop p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	788 virtual bool do_object_b(oop p);
0 a61af66fc99e Initial load duke parents: diff changeset	789 };
a61af66fc99e Initial load duke parents: diff changeset	790
a61af66fc99e Initial load duke parents: diff changeset	791 class KeepAliveClosure: public OopClosure {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	792 private:
0 a61af66fc99e Initial load duke parents: diff changeset	793 ParCompactionManager* _compaction_manager;
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	794 protected:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	795 template <class T> inline void do_oop_work(T* p);
0 a61af66fc99e Initial load duke parents: diff changeset	796 public:
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	797 KeepAliveClosure(ParCompactionManager* cm) : _compaction_manager(cm) { }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	798 virtual void do_oop(oop* p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	799 virtual void do_oop(narrowOop* p);
0 a61af66fc99e Initial load duke parents: diff changeset	800 };
a61af66fc99e Initial load duke parents: diff changeset	801
a61af66fc99e Initial load duke parents: diff changeset	802 class FollowStackClosure: public VoidClosure {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	803 private:
0 a61af66fc99e Initial load duke parents: diff changeset	804 ParCompactionManager* _compaction_manager;
a61af66fc99e Initial load duke parents: diff changeset	805 public:
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	806 FollowStackClosure(ParCompactionManager* cm) : _compaction_manager(cm) { }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	807 virtual void do_void();
0 a61af66fc99e Initial load duke parents: diff changeset	808 };
a61af66fc99e Initial load duke parents: diff changeset	809
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4913 diff changeset	810 class AdjustPointerClosure: public OopClosure {
0 a61af66fc99e Initial load duke parents: diff changeset	811 public:
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	812 virtual void do_oop(oop* p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	813 virtual void do_oop(narrowOop* p);
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	814 // do not walk from thread stacks to the code cache on this phase
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	815 virtual void do_code_blob(CodeBlob* cb) const { }
0 a61af66fc99e Initial load duke parents: diff changeset	816 };
a61af66fc99e Initial load duke parents: diff changeset	817
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4913 diff changeset	818 class AdjustKlassClosure : public KlassClosure {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4913 diff changeset	819 public:
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4913 diff changeset	820 void do_klass(Klass* klass);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4913 diff changeset	821 };
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4913 diff changeset	822
0 a61af66fc99e Initial load duke parents: diff changeset	823 friend class KeepAliveClosure;
a61af66fc99e Initial load duke parents: diff changeset	824 friend class FollowStackClosure;
a61af66fc99e Initial load duke parents: diff changeset	825 friend class AdjustPointerClosure;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4913 diff changeset	826 friend class AdjustKlassClosure;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4913 diff changeset	827 friend class FollowKlassClosure;
6735 aed758eda82a 7195833: NPG: Rename instanceClassLoaderKlass, instanceRefKlass and instanceMirrorKlass coleenp parents: 6725 diff changeset	828 friend class InstanceClassLoaderKlass;
0 a61af66fc99e Initial load duke parents: diff changeset	829 friend class RefProcTaskProxy;
a61af66fc99e Initial load duke parents: diff changeset	830
a61af66fc99e Initial load duke parents: diff changeset	831 private:
a61af66fc99e Initial load duke parents: diff changeset	832 static elapsedTimer _accumulated_time;
a61af66fc99e Initial load duke parents: diff changeset	833 static unsigned int _total_invocations;
a61af66fc99e Initial load duke parents: diff changeset	834 static unsigned int _maximum_compaction_gc_num;
a61af66fc99e Initial load duke parents: diff changeset	835 static jlong _time_of_last_gc; // ms
a61af66fc99e Initial load duke parents: diff changeset	836 static CollectorCounters* _counters;
a61af66fc99e Initial load duke parents: diff changeset	837 static ParMarkBitMap _mark_bitmap;
a61af66fc99e Initial load duke parents: diff changeset	838 static ParallelCompactData _summary_data;
a61af66fc99e Initial load duke parents: diff changeset	839 static IsAliveClosure _is_alive_closure;
a61af66fc99e Initial load duke parents: diff changeset	840 static SpaceInfo _space_info[last_space_id];
a61af66fc99e Initial load duke parents: diff changeset	841 static bool _print_phases;
a61af66fc99e Initial load duke parents: diff changeset	842 static AdjustPointerClosure _adjust_pointer_closure;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4913 diff changeset	843 static AdjustKlassClosure _adjust_klass_closure;
0 a61af66fc99e Initial load duke parents: diff changeset	844
a61af66fc99e Initial load duke parents: diff changeset	845 // Reference processing (used in ...follow_contents)
a61af66fc99e Initial load duke parents: diff changeset	846 static ReferenceProcessor* _ref_processor;
a61af66fc99e Initial load duke parents: diff changeset	847
a61af66fc99e Initial load duke parents: diff changeset	848 // Updated location of intArrayKlassObj.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4913 diff changeset	849 static Klass* _updated_int_array_klass_obj;
0 a61af66fc99e Initial load duke parents: diff changeset	850
a61af66fc99e Initial load duke parents: diff changeset	851 // Values computed at initialization and used by dead_wood_limiter().
a61af66fc99e Initial load duke parents: diff changeset	852 static double _dwl_mean;
a61af66fc99e Initial load duke parents: diff changeset	853 static double _dwl_std_dev;
a61af66fc99e Initial load duke parents: diff changeset	854 static double _dwl_first_term;
a61af66fc99e Initial load duke parents: diff changeset	855 static double _dwl_adjustment;
a61af66fc99e Initial load duke parents: diff changeset	856 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	857 static bool _dwl_initialized;
a61af66fc99e Initial load duke parents: diff changeset	858 #endif // #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	859
a61af66fc99e Initial load duke parents: diff changeset	860 private:
a61af66fc99e Initial load duke parents: diff changeset	861
a61af66fc99e Initial load duke parents: diff changeset	862 static void initialize_space_info();
a61af66fc99e Initial load duke parents: diff changeset	863
a61af66fc99e Initial load duke parents: diff changeset	864 // Return true if details about individual phases should be printed.
a61af66fc99e Initial load duke parents: diff changeset	865 static inline bool print_phases();
a61af66fc99e Initial load duke parents: diff changeset	866
a61af66fc99e Initial load duke parents: diff changeset	867 // Clear the marking bitmap and summary data that cover the specified space.
a61af66fc99e Initial load duke parents: diff changeset	868 static void clear_data_covering_space(SpaceId id);
a61af66fc99e Initial load duke parents: diff changeset	869
a61af66fc99e Initial load duke parents: diff changeset	870 static void pre_compact(PreGCValues* pre_gc_values);
a61af66fc99e Initial load duke parents: diff changeset	871 static void post_compact();
a61af66fc99e Initial load duke parents: diff changeset	872
a61af66fc99e Initial load duke parents: diff changeset	873 // Mark live objects
a61af66fc99e Initial load duke parents: diff changeset	874 static void marking_phase(ParCompactionManager* cm,
a61af66fc99e Initial load duke parents: diff changeset	875 bool maximum_heap_compaction);
a61af66fc99e Initial load duke parents: diff changeset	876
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	877 template <class T>
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	878 static inline void follow_root(ParCompactionManager* cm, T* p);
0 a61af66fc99e Initial load duke parents: diff changeset	879
a61af66fc99e Initial load duke parents: diff changeset	880 // Compute the dense prefix for the designated space. This is an experimental
a61af66fc99e Initial load duke parents: diff changeset	881 // implementation currently not used in production.
a61af66fc99e Initial load duke parents: diff changeset	882 static HeapWord* compute_dense_prefix_via_density(const SpaceId id,
a61af66fc99e Initial load duke parents: diff changeset	883 bool maximum_compaction);
a61af66fc99e Initial load duke parents: diff changeset	884
a61af66fc99e Initial load duke parents: diff changeset	885 // Methods used to compute the dense prefix.
a61af66fc99e Initial load duke parents: diff changeset	886
a61af66fc99e Initial load duke parents: diff changeset	887 // Compute the value of the normal distribution at x = density. The mean and
a61af66fc99e Initial load duke parents: diff changeset	888 // standard deviation are values saved by initialize_dead_wood_limiter().
a61af66fc99e Initial load duke parents: diff changeset	889 static inline double normal_distribution(double density);
a61af66fc99e Initial load duke parents: diff changeset	890
a61af66fc99e Initial load duke parents: diff changeset	891 // Initialize the static vars used by dead_wood_limiter().
a61af66fc99e Initial load duke parents: diff changeset	892 static void initialize_dead_wood_limiter();
a61af66fc99e Initial load duke parents: diff changeset	893
a61af66fc99e Initial load duke parents: diff changeset	894 // Return the percentage of space that can be treated as "dead wood" (i.e.,
a61af66fc99e Initial load duke parents: diff changeset	895 // not reclaimed).
a61af66fc99e Initial load duke parents: diff changeset	896 static double dead_wood_limiter(double density, size_t min_percent);
a61af66fc99e Initial load duke parents: diff changeset	897
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	898 // Find the first (left-most) region in the range [beg, end) that has at least
0 a61af66fc99e Initial load duke parents: diff changeset	899 // dead_words of dead space to the left. The argument beg must be the first
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	900 // region in the space that is not completely live.
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	901 static RegionData* dead_wood_limit_region(const RegionData* beg,
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	902 const RegionData* end,
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	903 size_t dead_words);
0 a61af66fc99e Initial load duke parents: diff changeset	904
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	905 // Return a pointer to the first region in the range [beg, end) that is not
0 a61af66fc99e Initial load duke parents: diff changeset	906 // completely full.
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	907 static RegionData* first_dead_space_region(const RegionData* beg,
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	908 const RegionData* end);
0 a61af66fc99e Initial load duke parents: diff changeset	909
a61af66fc99e Initial load duke parents: diff changeset	910 // Return a value indicating the benefit or 'yield' if the compacted region
a61af66fc99e Initial load duke parents: diff changeset	911 // were to start (or equivalently if the dense prefix were to end) at the
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	912 // candidate region. Higher values are better.
0 a61af66fc99e Initial load duke parents: diff changeset	913 //
a61af66fc99e Initial load duke parents: diff changeset	914 // The value is based on the amount of space reclaimed vs. the costs of (a)
a61af66fc99e Initial load duke parents: diff changeset	915 // updating references in the dense prefix plus (b) copying objects and
a61af66fc99e Initial load duke parents: diff changeset	916 // updating references in the compacted region.
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	917 static inline double reclaimed_ratio(const RegionData* const candidate,
0 a61af66fc99e Initial load duke parents: diff changeset	918 HeapWord* const bottom,
a61af66fc99e Initial load duke parents: diff changeset	919 HeapWord* const top,
a61af66fc99e Initial load duke parents: diff changeset	920 HeapWord* const new_top);
a61af66fc99e Initial load duke parents: diff changeset	921
a61af66fc99e Initial load duke parents: diff changeset	922 // Compute the dense prefix for the designated space.
a61af66fc99e Initial load duke parents: diff changeset	923 static HeapWord* compute_dense_prefix(const SpaceId id,
a61af66fc99e Initial load duke parents: diff changeset	924 bool maximum_compaction);
a61af66fc99e Initial load duke parents: diff changeset	925
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	926 // Return true if dead space crosses onto the specified Region; bit must be
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	927 // the bit index corresponding to the first word of the Region.
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	928 static inline bool dead_space_crosses_boundary(const RegionData* region,
0 a61af66fc99e Initial load duke parents: diff changeset	929 idx_t bit);
a61af66fc99e Initial load duke parents: diff changeset	930
a61af66fc99e Initial load duke parents: diff changeset	931 // Summary phase utility routine to fill dead space (if any) at the dense
a61af66fc99e Initial load duke parents: diff changeset	932 // prefix boundary. Should only be called if the the dense prefix is
a61af66fc99e Initial load duke parents: diff changeset	933 // non-empty.
a61af66fc99e Initial load duke parents: diff changeset	934 static void fill_dense_prefix_end(SpaceId id);
a61af66fc99e Initial load duke parents: diff changeset	935
482 7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	936 // Clear the summary data source_region field for the specified addresses.
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	937 static void 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	938
483 0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	939 #ifndef PRODUCT
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	940 // Routines to provoke splitting a young gen space (ParallelOldGCSplitALot).
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	941
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	942 // Fill the region [start, start + words) with live object(s). Only usable
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	943 // for the old and permanent generations.
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	944 static void 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	945 size_t words);
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	946 // Include the new objects in the summary data.
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	947 static void summarize_new_objects(SpaceId id, HeapWord* start);
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	948
496 b27c885f75f9 6786188: par compact - "SplitALot" stress mode should fill to_space jcoomes parents: 495 diff changeset	949 // Add live objects to a survivor space since it's rare that both survivors
b27c885f75f9 6786188: par compact - "SplitALot" stress mode should fill to_space jcoomes parents: 495 diff changeset	950 // are non-empty.
b27c885f75f9 6786188: par compact - "SplitALot" stress mode should fill to_space jcoomes parents: 495 diff changeset	951 static void provoke_split_fill_survivor(SpaceId id);
b27c885f75f9 6786188: par compact - "SplitALot" stress mode should fill to_space jcoomes parents: 495 diff changeset	952
483 0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	953 // Add live objects and/or choose the dense prefix to provoke splitting.
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	954 static void provoke_split(bool & maximum_compaction);
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	955 #endif
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	956
0 a61af66fc99e Initial load duke parents: diff changeset	957 static void summarize_spaces_quick();
a61af66fc99e Initial load duke parents: diff changeset	958 static void summarize_space(SpaceId id, bool maximum_compaction);
a61af66fc99e Initial load duke parents: diff changeset	959 static void summary_phase(ParCompactionManager* cm, bool maximum_compaction);
a61af66fc99e Initial load duke parents: diff changeset	960
a61af66fc99e Initial load duke parents: diff changeset	961 // Adjust addresses in roots. Does not adjust addresses in heap.
a61af66fc99e Initial load duke parents: diff changeset	962 static void adjust_roots();
a61af66fc99e Initial load duke parents: diff changeset	963
a61af66fc99e Initial load duke parents: diff changeset	964 // Move objects to new locations.
a61af66fc99e Initial load duke parents: diff changeset	965 static void compact_perm(ParCompactionManager* cm);
a61af66fc99e Initial load duke parents: diff changeset	966 static void compact();
a61af66fc99e Initial load duke parents: diff changeset	967
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	968 // Add available regions to the stack and draining tasks to the task queue.
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	969 static void enqueue_region_draining_tasks(GCTaskQueue* q,
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	970 uint parallel_gc_threads);
0 a61af66fc99e Initial load duke parents: diff changeset	971
a61af66fc99e Initial load duke parents: diff changeset	972 // Add dense prefix update tasks to the task queue.
a61af66fc99e Initial load duke parents: diff changeset	973 static void enqueue_dense_prefix_tasks(GCTaskQueue* q,
a61af66fc99e Initial load duke parents: diff changeset	974 uint parallel_gc_threads);
a61af66fc99e Initial load duke parents: diff changeset	975
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	976 // Add region stealing tasks to the task queue.
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	977 static void enqueue_region_stealing_tasks(
0 a61af66fc99e Initial load duke parents: diff changeset	978 GCTaskQueue* q,
a61af66fc99e Initial load duke parents: diff changeset	979 ParallelTaskTerminator* terminator_ptr,
a61af66fc99e Initial load duke parents: diff changeset	980 uint parallel_gc_threads);
a61af66fc99e Initial load duke parents: diff changeset	981
a61af66fc99e Initial load duke parents: diff changeset	982 // If objects are left in eden after a collection, try to move the boundary
a61af66fc99e Initial load duke parents: diff changeset	983 // and absorb them into the old gen. Returns true if eden was emptied.
a61af66fc99e Initial load duke parents: diff changeset	984 static bool absorb_live_data_from_eden(PSAdaptiveSizePolicy* size_policy,
a61af66fc99e Initial load duke parents: diff changeset	985 PSYoungGen* young_gen,
a61af66fc99e Initial load duke parents: diff changeset	986 PSOldGen* old_gen);
a61af66fc99e Initial load duke parents: diff changeset	987
a61af66fc99e Initial load duke parents: diff changeset	988 // Reset time since last full gc
a61af66fc99e Initial load duke parents: diff changeset	989 static void reset_millis_since_last_gc();
a61af66fc99e Initial load duke parents: diff changeset	990
a61af66fc99e Initial load duke parents: diff changeset	991 public:
a61af66fc99e Initial load duke parents: diff changeset	992 class MarkAndPushClosure: public OopClosure {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	993 private:
0 a61af66fc99e Initial load duke parents: diff changeset	994 ParCompactionManager* _compaction_manager;
a61af66fc99e Initial load duke parents: diff changeset	995 public:
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	996 MarkAndPushClosure(ParCompactionManager* cm) : _compaction_manager(cm) { }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	997 virtual void do_oop(oop* p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	998 virtual void do_oop(narrowOop* p);
0 a61af66fc99e Initial load duke parents: diff changeset	999 };
a61af66fc99e Initial load duke parents: diff changeset	1000
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4913 diff changeset	1001 // The one and only place to start following the classes.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4913 diff changeset	1002 // Should only be applied to the ClassLoaderData klasses list.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4913 diff changeset	1003 class FollowKlassClosure : public KlassClosure {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4913 diff changeset	1004 private:
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4913 diff changeset	1005 MarkAndPushClosure* _mark_and_push_closure;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4913 diff changeset	1006 public:
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4913 diff changeset	1007 FollowKlassClosure(MarkAndPushClosure* mark_and_push_closure) :
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4913 diff changeset	1008 _mark_and_push_closure(mark_and_push_closure) { }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4913 diff changeset	1009 void do_klass(Klass* klass);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4913 diff changeset	1010 };
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4913 diff changeset	1011
0 a61af66fc99e Initial load duke parents: diff changeset	1012 PSParallelCompact();
a61af66fc99e Initial load duke parents: diff changeset	1013
a61af66fc99e Initial load duke parents: diff changeset	1014 // Convenient accessor for Universe::heap().
a61af66fc99e Initial load duke parents: diff changeset	1015 static ParallelScavengeHeap* gc_heap() {
a61af66fc99e Initial load duke parents: diff changeset	1016 return (ParallelScavengeHeap*)Universe::heap();
a61af66fc99e Initial load duke parents: diff changeset	1017 }
a61af66fc99e Initial load duke parents: diff changeset	1018
a61af66fc99e Initial load duke parents: diff changeset	1019 static void invoke(bool maximum_heap_compaction);
4913 ab4422d0ed59 7146343: PS invoke methods should indicate the type of gc done jcoomes parents: 4099 diff changeset	1020 static bool invoke_no_policy(bool maximum_heap_compaction);
0 a61af66fc99e Initial load duke parents: diff changeset	1021
a61af66fc99e Initial load duke parents: diff changeset	1022 static void post_initialize();
a61af66fc99e Initial load duke parents: diff changeset	1023 // Perform initialization for PSParallelCompact that requires
a61af66fc99e Initial load duke parents: diff changeset	1024 // allocations. This should be called during the VM initialization
a61af66fc99e Initial load duke parents: diff changeset	1025 // at a pointer where it would be appropriate to return a JNI_ENOMEM
a61af66fc99e Initial load duke parents: diff changeset	1026 // in the event of a failure.
a61af66fc99e Initial load duke parents: diff changeset	1027 static bool initialize();
a61af66fc99e Initial load duke parents: diff changeset	1028
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4913 diff changeset	1029 // Closure accessors
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4913 diff changeset	1030 static OopClosure* adjust_pointer_closure() { return (OopClosure*)&_adjust_pointer_closure; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4913 diff changeset	1031 static KlassClosure* adjust_klass_closure() { return (KlassClosure*)&_adjust_klass_closure; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4913 diff changeset	1032 static BoolObjectClosure* is_alive_closure() { return (BoolObjectClosure*)&_is_alive_closure; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4913 diff changeset	1033
0 a61af66fc99e Initial load duke parents: diff changeset	1034 // Public accessors
a61af66fc99e Initial load duke parents: diff changeset	1035 static elapsedTimer* accumulated_time() { return &_accumulated_time; }
a61af66fc99e Initial load duke parents: diff changeset	1036 static unsigned int total_invocations() { return _total_invocations; }
a61af66fc99e Initial load duke parents: diff changeset	1037 static CollectorCounters* counters() { return _counters; }
a61af66fc99e Initial load duke parents: diff changeset	1038
a61af66fc99e Initial load duke parents: diff changeset	1039 // Used to add tasks
a61af66fc99e Initial load duke parents: diff changeset	1040 static GCTaskManager* const gc_task_manager();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4913 diff changeset	1041 static Klass* updated_int_array_klass_obj() {
0 a61af66fc99e Initial load duke parents: diff changeset	1042 return _updated_int_array_klass_obj;
a61af66fc99e Initial load duke parents: diff changeset	1043 }
a61af66fc99e Initial load duke parents: diff changeset	1044
a61af66fc99e Initial load duke parents: diff changeset	1045 // Marking support
a61af66fc99e Initial load duke parents: diff changeset	1046 static inline bool mark_obj(oop obj);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4913 diff changeset	1047 static inline bool is_marked(oop obj);
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1048 // Check mark and maybe push on marking stack
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1049 template <class T> static inline void mark_and_push(ParCompactionManager* cm,
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1050 T* p);
10179 a08c80e9e1e5 8012687: Remove unused is_root checks and closures stefank parents: 9076 diff changeset	1051 template <class T> static inline void adjust_pointer(T* p);
0 a61af66fc99e Initial load duke parents: diff changeset	1052
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4913 diff changeset	1053 static void follow_klass(ParCompactionManager* cm, Klass* klass);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4913 diff changeset	1054 static void adjust_klass(ParCompactionManager* cm, Klass* klass);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4913 diff changeset	1055
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4913 diff changeset	1056 static void follow_class_loader(ParCompactionManager* cm,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4913 diff changeset	1057 ClassLoaderData* klass);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4913 diff changeset	1058 static void adjust_class_loader(ParCompactionManager* cm,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4913 diff changeset	1059 ClassLoaderData* klass);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4913 diff changeset	1060
0 a61af66fc99e Initial load duke parents: diff changeset	1061 // Compaction support.
a61af66fc99e Initial load duke parents: diff changeset	1062 // Return true if p is in the range [beg_addr, end_addr).
a61af66fc99e Initial load duke parents: diff changeset	1063 static inline bool is_in(HeapWord* p, HeapWord* beg_addr, HeapWord* end_addr);
a61af66fc99e Initial load duke parents: diff changeset	1064 static inline bool is_in(oop* p, HeapWord* beg_addr, HeapWord* end_addr);
a61af66fc99e Initial load duke parents: diff changeset	1065
a61af66fc99e Initial load duke parents: diff changeset	1066 // Convenience wrappers for per-space data kept in _space_info.
a61af66fc99e Initial load duke parents: diff changeset	1067 static inline MutableSpace* space(SpaceId space_id);
a61af66fc99e Initial load duke parents: diff changeset	1068 static inline HeapWord* new_top(SpaceId space_id);
a61af66fc99e Initial load duke parents: diff changeset	1069 static inline HeapWord* dense_prefix(SpaceId space_id);
a61af66fc99e Initial load duke parents: diff changeset	1070 static inline ObjectStartArray* start_array(SpaceId space_id);
a61af66fc99e Initial load duke parents: diff changeset	1071
a61af66fc99e Initial load duke parents: diff changeset	1072 // Move and update the live objects in the specified space.
a61af66fc99e Initial load duke parents: diff changeset	1073 static void move_and_update(ParCompactionManager* cm, SpaceId space_id);
a61af66fc99e Initial load duke parents: diff changeset	1074
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1075 // Process the end of the given region range in the dense prefix.
0 a61af66fc99e Initial load duke parents: diff changeset	1076 // This includes saving any object not updated.
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1077 static void dense_prefix_regions_epilogue(ParCompactionManager* cm,
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1078 size_t region_start_index,
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1079 size_t region_end_index,
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1080 idx_t exiting_object_offset,
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1081 idx_t region_offset_start,
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1082 idx_t region_offset_end);
0 a61af66fc99e Initial load duke parents: diff changeset	1083
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1084 // Update a region in the dense prefix. For each live object
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1085 // in the region, update it's interior references. For each
0 a61af66fc99e Initial load duke parents: diff changeset	1086 // dead object, fill it with deadwood. Dead space at the end
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1087 // of a region range will be filled to the start of the next
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1088 // live object regardless of the region_index_end. None of the
0 a61af66fc99e Initial load duke parents: diff changeset	1089 // objects in the dense prefix move and dead space is dead
a61af66fc99e Initial load duke parents: diff changeset	1090 // (holds only dead objects that don't need any processing), so
a61af66fc99e Initial load duke parents: diff changeset	1091 // dead space can be filled in any order.
a61af66fc99e Initial load duke parents: diff changeset	1092 static void update_and_deadwood_in_dense_prefix(ParCompactionManager* cm,
a61af66fc99e Initial load duke parents: diff changeset	1093 SpaceId space_id,
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1094 size_t region_index_start,
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1095 size_t region_index_end);
0 a61af66fc99e Initial load duke parents: diff changeset	1096
a61af66fc99e Initial load duke parents: diff changeset	1097 // Return the address of the count + 1st live word in the range [beg, end).
a61af66fc99e Initial load duke parents: diff changeset	1098 static HeapWord* skip_live_words(HeapWord* beg, HeapWord* end, size_t count);
a61af66fc99e Initial load duke parents: diff changeset	1099
a61af66fc99e Initial load duke parents: diff changeset	1100 // Return the address of the word to be copied to dest_addr, which must be
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1101 // aligned to a region boundary.
0 a61af66fc99e Initial load duke parents: diff changeset	1102 static HeapWord* first_src_addr(HeapWord* const dest_addr,
482 7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1103 SpaceId src_space_id,
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1104 size_t src_region_idx);
0 a61af66fc99e Initial load duke parents: diff changeset	1105
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1106 // Determine the next source region, set closure.source() to the start of the
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1107 // new region return the region index. Parameter end_addr is the address one
0 a61af66fc99e Initial load duke parents: diff changeset	1108 // beyond the end of source range just processed. If necessary, switch to a
a61af66fc99e Initial load duke parents: diff changeset	1109 // new source space and set src_space_id (in-out parameter) and src_space_top
a61af66fc99e Initial load duke parents: diff changeset	1110 // (out parameter) accordingly.
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1111 static size_t next_src_region(MoveAndUpdateClosure& closure,
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1112 SpaceId& src_space_id,
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1113 HeapWord*& src_space_top,
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1114 HeapWord* end_addr);
0 a61af66fc99e Initial load duke parents: diff changeset	1115
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1116 // Decrement the destination count for each non-empty source region in the
495 234c22e54b98 6784849: par compact - can fail when to_space is non-empty jcoomes parents: 483 diff changeset	1117 // range [beg_region, region(region_align_up(end_addr))). If the destination
234c22e54b98 6784849: par compact - can fail when to_space is non-empty jcoomes parents: 483 diff changeset	1118 // count for a region goes to 0 and it needs to be filled, enqueue it.
0 a61af66fc99e Initial load duke parents: diff changeset	1119 static void decrement_destination_counts(ParCompactionManager* cm,
495 234c22e54b98 6784849: par compact - can fail when to_space is non-empty jcoomes parents: 483 diff changeset	1120 SpaceId src_space_id,
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1121 size_t beg_region,
0 a61af66fc99e Initial load duke parents: diff changeset	1122 HeapWord* end_addr);
a61af66fc99e Initial load duke parents: diff changeset	1123
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1124 // Fill a region, copying objects from one or more source regions.
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1125 static void fill_region(ParCompactionManager* cm, size_t region_idx);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1126 static void fill_and_update_region(ParCompactionManager* cm, size_t region) {
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1127 fill_region(cm, region);
0 a61af66fc99e Initial load duke parents: diff changeset	1128 }
a61af66fc99e Initial load duke parents: diff changeset	1129
a61af66fc99e Initial load duke parents: diff changeset	1130 // Update the deferred objects in the space.
a61af66fc99e Initial load duke parents: diff changeset	1131 static void update_deferred_objects(ParCompactionManager* cm, SpaceId id);
a61af66fc99e Initial load duke parents: diff changeset	1132
a61af66fc99e Initial load duke parents: diff changeset	1133 static ParMarkBitMap* mark_bitmap() { return &_mark_bitmap; }
a61af66fc99e Initial load duke parents: diff changeset	1134 static ParallelCompactData& summary_data() { return _summary_data; }
a61af66fc99e Initial load duke parents: diff changeset	1135
a61af66fc99e Initial load duke parents: diff changeset	1136 // Reference Processing
a61af66fc99e Initial load duke parents: diff changeset	1137 static ReferenceProcessor* const ref_processor() { return _ref_processor; }
a61af66fc99e Initial load duke parents: diff changeset	1138
a61af66fc99e Initial load duke parents: diff changeset	1139 // Return the SpaceId for the given address.
a61af66fc99e Initial load duke parents: diff changeset	1140 static SpaceId space_id(HeapWord* addr);
a61af66fc99e Initial load duke parents: diff changeset	1141
a61af66fc99e Initial load duke parents: diff changeset	1142 // Time since last full gc (in milliseconds).
a61af66fc99e Initial load duke parents: diff changeset	1143 static jlong millis_since_last_gc();
a61af66fc99e Initial load duke parents: diff changeset	1144
9076 7b835924c31c 8011872: Include Bit Map addresses in the hs_err files stefank parents: 7448 diff changeset	1145 static void print_on_error(outputStream* st);
7b835924c31c 8011872: Include Bit Map addresses in the hs_err files stefank parents: 7448 diff changeset	1146
0 a61af66fc99e Initial load duke parents: diff changeset	1147 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	1148 // Debugging support.
a61af66fc99e Initial load duke parents: diff changeset	1149 static const char* space_names[last_space_id];
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1150 static void print_region_ranges();
0 a61af66fc99e Initial load duke parents: diff changeset	1151 static void print_dense_prefix_stats(const char* const algorithm,
a61af66fc99e Initial load duke parents: diff changeset	1152 const SpaceId id,
a61af66fc99e Initial load duke parents: diff changeset	1153 const bool maximum_compaction,
a61af66fc99e Initial load duke parents: diff changeset	1154 HeapWord* const addr);
482 7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1155 static void summary_phase_msg(SpaceId dst_space_id,
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1156 HeapWord* dst_beg, HeapWord* dst_end,
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1157 SpaceId src_space_id,
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1158 HeapWord* src_beg, HeapWord* src_end);
0 a61af66fc99e Initial load duke parents: diff changeset	1159 #endif // #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	1160
a61af66fc99e Initial load duke parents: diff changeset	1161 #ifdef ASSERT
495 234c22e54b98 6784849: par compact - can fail when to_space is non-empty jcoomes parents: 483 diff changeset	1162 // Sanity check the new location of a word in the heap.
234c22e54b98 6784849: par compact - can fail when to_space is non-empty jcoomes parents: 483 diff changeset	1163 static inline void check_new_location(HeapWord* old_addr, HeapWord* new_addr);
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1164 // Verify that all the regions have been emptied.
0 a61af66fc99e Initial load duke parents: diff changeset	1165 static void verify_complete(SpaceId space_id);
a61af66fc99e Initial load duke parents: diff changeset	1166 #endif // #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	1167 };
a61af66fc99e Initial load duke parents: diff changeset	1168
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1169 inline bool PSParallelCompact::mark_obj(oop obj) {
0 a61af66fc99e Initial load duke parents: diff changeset	1170 const int obj_size = obj->size();
a61af66fc99e Initial load duke parents: diff changeset	1171 if (mark_bitmap()->mark_obj(obj, obj_size)) {
a61af66fc99e Initial load duke parents: diff changeset	1172 _summary_data.add_obj(obj, obj_size);
a61af66fc99e Initial load duke parents: diff changeset	1173 return true;
a61af66fc99e Initial load duke parents: diff changeset	1174 } else {
a61af66fc99e Initial load duke parents: diff changeset	1175 return false;
a61af66fc99e Initial load duke parents: diff changeset	1176 }
a61af66fc99e Initial load duke parents: diff changeset	1177 }
a61af66fc99e Initial load duke parents: diff changeset	1178
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4913 diff changeset	1179 inline bool PSParallelCompact::is_marked(oop obj) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4913 diff changeset	1180 return mark_bitmap()->is_marked(obj);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4913 diff changeset	1181 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4913 diff changeset	1182
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1183 template <class T>
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1184 inline void PSParallelCompact::follow_root(ParCompactionManager* cm, T* p) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1185 assert(!Universe::heap()->is_in_reserved(p),
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1186 "roots shouldn't be things within the heap");
7448 b735136e0d82 8004132: SerialGC: ValidateMarkSweep broken when running GCOld johnc parents: 6735 diff changeset	1187
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1188 T heap_oop = oopDesc::load_heap_oop(p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1189 if (!oopDesc::is_null(heap_oop)) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1190 oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1191 if (mark_bitmap()->is_unmarked(obj)) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1192 if (mark_obj(obj)) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1193 obj->follow_contents(cm);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1194 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1195 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1196 }
1311 2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 993 diff changeset	1197 cm->follow_marking_stacks();
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1198 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1199
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1200 template <class T>
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1201 inline void PSParallelCompact::mark_and_push(ParCompactionManager* cm, T* p) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1202 T heap_oop = oopDesc::load_heap_oop(p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1203 if (!oopDesc::is_null(heap_oop)) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1204 oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
1638 b2a00dd3117c 6957084: simplify TaskQueue overflow handling jcoomes parents: 1579 diff changeset	1205 if (mark_bitmap()->is_unmarked(obj) && mark_obj(obj)) {
b2a00dd3117c 6957084: simplify TaskQueue overflow handling jcoomes parents: 1579 diff changeset	1206 cm->push(obj);
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1207 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1208 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1209 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1210
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1211 template <class T>
10179 a08c80e9e1e5 8012687: Remove unused is_root checks and closures stefank parents: 9076 diff changeset	1212 inline void PSParallelCompact::adjust_pointer(T* p) {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1213 T heap_oop = oopDesc::load_heap_oop(p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1214 if (!oopDesc::is_null(heap_oop)) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1215 oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1216 oop new_obj = (oop)summary_data().calc_new_pointer(obj);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4913 diff changeset	1217 assert(new_obj != NULL, // is forwarding ptr?
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1218 "should be forwarded");
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1219 // Just always do the update unconditionally?
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1220 if (new_obj != NULL) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1221 assert(Universe::heap()->is_in_reserved(new_obj),
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1222 "should be in object space");
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1223 oopDesc::encode_store_heap_oop_not_null(p, new_obj);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1224 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1225 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1226 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1227
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1228 template <class T>
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1229 inline void PSParallelCompact::KeepAliveClosure::do_oop_work(T* p) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1230 mark_and_push(_compaction_manager, p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1231 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1232
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1233 inline bool PSParallelCompact::print_phases() {
0 a61af66fc99e Initial load duke parents: diff changeset	1234 return _print_phases;
a61af66fc99e Initial load duke parents: diff changeset	1235 }
a61af66fc99e Initial load duke parents: diff changeset	1236
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1237 inline double PSParallelCompact::normal_distribution(double density) {
0 a61af66fc99e Initial load duke parents: diff changeset	1238 assert(_dwl_initialized, "uninitialized");
a61af66fc99e Initial load duke parents: diff changeset	1239 const double squared_term = (density - _dwl_mean) / _dwl_std_dev;
a61af66fc99e Initial load duke parents: diff changeset	1240 return _dwl_first_term * exp(-0.5 * squared_term * squared_term);
a61af66fc99e Initial load duke parents: diff changeset	1241 }
a61af66fc99e Initial load duke parents: diff changeset	1242
a61af66fc99e Initial load duke parents: diff changeset	1243 inline bool
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1244 PSParallelCompact::dead_space_crosses_boundary(const RegionData* region,
0 a61af66fc99e Initial load duke parents: diff changeset	1245 idx_t bit)
a61af66fc99e Initial load duke parents: diff changeset	1246 {
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1247 assert(bit > 0, "cannot call this for the first bit/region");
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1248 assert(_summary_data.region_to_addr(region) == _mark_bitmap.bit_to_addr(bit),
0 a61af66fc99e Initial load duke parents: diff changeset	1249 "sanity check");
a61af66fc99e Initial load duke parents: diff changeset	1250
a61af66fc99e Initial load duke parents: diff changeset	1251 // Dead space crosses the boundary if (1) a partial object does not extend
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1252 // onto the region, (2) an object does not start at the beginning of the
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1253 // region, and (3) an object does not end at the end of the prior region.
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1254 return region->partial_obj_size() == 0 &&
0 a61af66fc99e Initial load duke parents: diff changeset	1255 !_mark_bitmap.is_obj_beg(bit) &&
a61af66fc99e Initial load duke parents: diff changeset	1256 !_mark_bitmap.is_obj_end(bit - 1);
a61af66fc99e Initial load duke parents: diff changeset	1257 }
a61af66fc99e Initial load duke parents: diff changeset	1258
a61af66fc99e Initial load duke parents: diff changeset	1259 inline bool
a61af66fc99e Initial load duke parents: diff changeset	1260 PSParallelCompact::is_in(HeapWord* p, HeapWord* beg_addr, HeapWord* end_addr) {
a61af66fc99e Initial load duke parents: diff changeset	1261 return p >= beg_addr && p < end_addr;
a61af66fc99e Initial load duke parents: diff changeset	1262 }
a61af66fc99e Initial load duke parents: diff changeset	1263
a61af66fc99e Initial load duke parents: diff changeset	1264 inline bool
a61af66fc99e Initial load duke parents: diff changeset	1265 PSParallelCompact::is_in(oop* p, HeapWord* beg_addr, HeapWord* end_addr) {
a61af66fc99e Initial load duke parents: diff changeset	1266 return is_in((HeapWord*)p, beg_addr, end_addr);
a61af66fc99e Initial load duke parents: diff changeset	1267 }
a61af66fc99e Initial load duke parents: diff changeset	1268
a61af66fc99e Initial load duke parents: diff changeset	1269 inline MutableSpace* PSParallelCompact::space(SpaceId id) {
a61af66fc99e Initial load duke parents: diff changeset	1270 assert(id < last_space_id, "id out of range");
a61af66fc99e Initial load duke parents: diff changeset	1271 return _space_info[id].space();
a61af66fc99e Initial load duke parents: diff changeset	1272 }
a61af66fc99e Initial load duke parents: diff changeset	1273
a61af66fc99e Initial load duke parents: diff changeset	1274 inline HeapWord* PSParallelCompact::new_top(SpaceId id) {
a61af66fc99e Initial load duke parents: diff changeset	1275 assert(id < last_space_id, "id out of range");
a61af66fc99e Initial load duke parents: diff changeset	1276 return _space_info[id].new_top();
a61af66fc99e Initial load duke parents: diff changeset	1277 }
a61af66fc99e Initial load duke parents: diff changeset	1278
a61af66fc99e Initial load duke parents: diff changeset	1279 inline HeapWord* PSParallelCompact::dense_prefix(SpaceId id) {
a61af66fc99e Initial load duke parents: diff changeset	1280 assert(id < last_space_id, "id out of range");
a61af66fc99e Initial load duke parents: diff changeset	1281 return _space_info[id].dense_prefix();
a61af66fc99e Initial load duke parents: diff changeset	1282 }
a61af66fc99e Initial load duke parents: diff changeset	1283
a61af66fc99e Initial load duke parents: diff changeset	1284 inline ObjectStartArray* PSParallelCompact::start_array(SpaceId id) {
a61af66fc99e Initial load duke parents: diff changeset	1285 assert(id < last_space_id, "id out of range");
a61af66fc99e Initial load duke parents: diff changeset	1286 return _space_info[id].start_array();
a61af66fc99e Initial load duke parents: diff changeset	1287 }
a61af66fc99e Initial load duke parents: diff changeset	1288
495 234c22e54b98 6784849: par compact - can fail when to_space is non-empty jcoomes parents: 483 diff changeset	1289 #ifdef ASSERT
234c22e54b98 6784849: par compact - can fail when to_space is non-empty jcoomes parents: 483 diff changeset	1290 inline void
234c22e54b98 6784849: par compact - can fail when to_space is non-empty jcoomes parents: 483 diff changeset	1291 PSParallelCompact::check_new_location(HeapWord* old_addr, HeapWord* new_addr)
234c22e54b98 6784849: par compact - can fail when to_space is non-empty jcoomes parents: 483 diff changeset	1292 {
234c22e54b98 6784849: par compact - can fail when to_space is non-empty jcoomes parents: 483 diff changeset	1293 assert(old_addr >= new_addr \|\| space_id(old_addr) != space_id(new_addr),
234c22e54b98 6784849: par compact - can fail when to_space is non-empty jcoomes parents: 483 diff changeset	1294 "must move left or to a different space");
1571 2d127394260e 6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb kvn parents: 1311 diff changeset	1295 assert(is_object_aligned((intptr_t)old_addr) && is_object_aligned((intptr_t)new_addr),
2d127394260e 6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb kvn parents: 1311 diff changeset	1296 "checking alignment");
495 234c22e54b98 6784849: par compact - can fail when to_space is non-empty jcoomes parents: 483 diff changeset	1297 }
234c22e54b98 6784849: par compact - can fail when to_space is non-empty jcoomes parents: 483 diff changeset	1298 #endif // ASSERT
234c22e54b98 6784849: par compact - can fail when to_space is non-empty jcoomes parents: 483 diff changeset	1299
0 a61af66fc99e Initial load duke parents: diff changeset	1300 class MoveAndUpdateClosure: public ParMarkBitMapClosure {
a61af66fc99e Initial load duke parents: diff changeset	1301 public:
a61af66fc99e Initial load duke parents: diff changeset	1302 inline MoveAndUpdateClosure(ParMarkBitMap* bitmap, ParCompactionManager* cm,
a61af66fc99e Initial load duke parents: diff changeset	1303 ObjectStartArray* start_array,
a61af66fc99e Initial load duke parents: diff changeset	1304 HeapWord* destination, size_t words);
a61af66fc99e Initial load duke parents: diff changeset	1305
a61af66fc99e Initial load duke parents: diff changeset	1306 // Accessors.
a61af66fc99e Initial load duke parents: diff changeset	1307 HeapWord* destination() const { return _destination; }
a61af66fc99e Initial load duke parents: diff changeset	1308
a61af66fc99e Initial load duke parents: diff changeset	1309 // If the object will fit (size <= words_remaining()), copy it to the current
a61af66fc99e Initial load duke parents: diff changeset	1310 // destination, update the interior oops and the start array and return either
a61af66fc99e Initial load duke parents: diff changeset	1311 // full (if the closure is full) or incomplete. If the object will not fit,
a61af66fc99e Initial load duke parents: diff changeset	1312 // return would_overflow.
a61af66fc99e Initial load duke parents: diff changeset	1313 virtual IterationStatus do_addr(HeapWord* addr, size_t size);
a61af66fc99e Initial load duke parents: diff changeset	1314
a61af66fc99e Initial load duke parents: diff changeset	1315 // Copy enough words to fill this closure, starting at source(). Interior
a61af66fc99e Initial load duke parents: diff changeset	1316 // oops and the start array are not updated. Return full.
a61af66fc99e Initial load duke parents: diff changeset	1317 IterationStatus copy_until_full();
a61af66fc99e Initial load duke parents: diff changeset	1318
a61af66fc99e Initial load duke parents: diff changeset	1319 // Copy enough words to fill this closure or to the end of an object,
a61af66fc99e Initial load duke parents: diff changeset	1320 // whichever is smaller, starting at source(). Interior oops and the start
a61af66fc99e Initial load duke parents: diff changeset	1321 // array are not updated.
a61af66fc99e Initial load duke parents: diff changeset	1322 void copy_partial_obj();
a61af66fc99e Initial load duke parents: diff changeset	1323
a61af66fc99e Initial load duke parents: diff changeset	1324 protected:
a61af66fc99e Initial load duke parents: diff changeset	1325 // Update variables to indicate that word_count words were processed.
a61af66fc99e Initial load duke parents: diff changeset	1326 inline void update_state(size_t word_count);
a61af66fc99e Initial load duke parents: diff changeset	1327
a61af66fc99e Initial load duke parents: diff changeset	1328 protected:
a61af66fc99e Initial load duke parents: diff changeset	1329 ObjectStartArray* const _start_array;
a61af66fc99e Initial load duke parents: diff changeset	1330 HeapWord* _destination; // Next addr to be written.
a61af66fc99e Initial load duke parents: diff changeset	1331 };
a61af66fc99e Initial load duke parents: diff changeset	1332
a61af66fc99e Initial load duke parents: diff changeset	1333 inline
a61af66fc99e Initial load duke parents: diff changeset	1334 MoveAndUpdateClosure::MoveAndUpdateClosure(ParMarkBitMap* bitmap,
a61af66fc99e Initial load duke parents: diff changeset	1335 ParCompactionManager* cm,
a61af66fc99e Initial load duke parents: diff changeset	1336 ObjectStartArray* start_array,
a61af66fc99e Initial load duke parents: diff changeset	1337 HeapWord* destination,
a61af66fc99e Initial load duke parents: diff changeset	1338 size_t words) :
a61af66fc99e Initial load duke parents: diff changeset	1339 ParMarkBitMapClosure(bitmap, cm, words), _start_array(start_array)
a61af66fc99e Initial load duke parents: diff changeset	1340 {
a61af66fc99e Initial load duke parents: diff changeset	1341 _destination = destination;
a61af66fc99e Initial load duke parents: diff changeset	1342 }
a61af66fc99e Initial load duke parents: diff changeset	1343
a61af66fc99e Initial load duke parents: diff changeset	1344 inline void MoveAndUpdateClosure::update_state(size_t words)
a61af66fc99e Initial load duke parents: diff changeset	1345 {
a61af66fc99e Initial load duke parents: diff changeset	1346 decrement_words_remaining(words);
a61af66fc99e Initial load duke parents: diff changeset	1347 _source += words;
a61af66fc99e Initial load duke parents: diff changeset	1348 _destination += words;
a61af66fc99e Initial load duke parents: diff changeset	1349 }
a61af66fc99e Initial load duke parents: diff changeset	1350
a61af66fc99e Initial load duke parents: diff changeset	1351 class UpdateOnlyClosure: public ParMarkBitMapClosure {
a61af66fc99e Initial load duke parents: diff changeset	1352 private:
a61af66fc99e Initial load duke parents: diff changeset	1353 const PSParallelCompact::SpaceId _space_id;
a61af66fc99e Initial load duke parents: diff changeset	1354 ObjectStartArray* const _start_array;
a61af66fc99e Initial load duke parents: diff changeset	1355
a61af66fc99e Initial load duke parents: diff changeset	1356 public:
a61af66fc99e Initial load duke parents: diff changeset	1357 UpdateOnlyClosure(ParMarkBitMap* mbm,
a61af66fc99e Initial load duke parents: diff changeset	1358 ParCompactionManager* cm,
a61af66fc99e Initial load duke parents: diff changeset	1359 PSParallelCompact::SpaceId space_id);
a61af66fc99e Initial load duke parents: diff changeset	1360
a61af66fc99e Initial load duke parents: diff changeset	1361 // Update the object.
a61af66fc99e Initial load duke parents: diff changeset	1362 virtual IterationStatus do_addr(HeapWord* addr, size_t words);
a61af66fc99e Initial load duke parents: diff changeset	1363
a61af66fc99e Initial load duke parents: diff changeset	1364 inline void do_addr(HeapWord* addr);
a61af66fc99e Initial load duke parents: diff changeset	1365 };
a61af66fc99e Initial load duke parents: diff changeset	1366
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1367 inline void UpdateOnlyClosure::do_addr(HeapWord* addr)
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1368 {
0 a61af66fc99e Initial load duke parents: diff changeset	1369 _start_array->allocate_block(addr);
a61af66fc99e Initial load duke parents: diff changeset	1370 oop(addr)->update_contents(compaction_manager());
a61af66fc99e Initial load duke parents: diff changeset	1371 }
a61af66fc99e Initial load duke parents: diff changeset	1372
481 7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 376 diff changeset	1373 class FillClosure: public ParMarkBitMapClosure
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 376 diff changeset	1374 {
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 376 diff changeset	1375 public:
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1376 FillClosure(ParCompactionManager* cm, PSParallelCompact::SpaceId space_id) :
0 a61af66fc99e Initial load duke parents: diff changeset	1377 ParMarkBitMapClosure(PSParallelCompact::mark_bitmap(), cm),
481 7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 376 diff changeset	1378 _start_array(PSParallelCompact::start_array(space_id))
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 376 diff changeset	1379 {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4913 diff changeset	1380 assert(space_id == PSParallelCompact::old_space_id,
0 a61af66fc99e Initial load duke parents: diff changeset	1381 "cannot use FillClosure in the young gen");
a61af66fc99e Initial load duke parents: diff changeset	1382 }
a61af66fc99e Initial load duke parents: diff changeset	1383
a61af66fc99e Initial load duke parents: diff changeset	1384 virtual IterationStatus do_addr(HeapWord* addr, size_t size) {
481 7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 376 diff changeset	1385 CollectedHeap::fill_with_objects(addr, size);
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 376 diff changeset	1386 HeapWord* const end = addr + size;
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 376 diff changeset	1387 do {
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 376 diff changeset	1388 _start_array->allocate_block(addr);
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 376 diff changeset	1389 addr += oop(addr)->size();
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 376 diff changeset	1390 } while (addr < end);
0 a61af66fc99e Initial load duke parents: diff changeset	1391 return ParMarkBitMap::incomplete;
a61af66fc99e Initial load duke parents: diff changeset	1392 }
a61af66fc99e Initial load duke parents: diff changeset	1393
a61af66fc99e Initial load duke parents: diff changeset	1394 private:
481 7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 376 diff changeset	1395 ObjectStartArray* const _start_array;
0 a61af66fc99e Initial load duke parents: diff changeset	1396 };
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1638 diff changeset	1397
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1638 diff changeset	1398 #endif // SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_PSPARALLELCOMPACT_HPP

Mercurial > hg > graal-compiler

annotate src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.hpp @ 10185:d50cc62e94ff