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

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

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

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

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
579 0fbdb4381b99 6814575: Update copyright year xdono parents: 496 diff changeset	2 * Copyright 2005-2009 Sun Microsystems, Inc. All Rights Reserved.
0 a61af66fc99e Initial load duke parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load duke parents: diff changeset	4 *
a61af66fc99e Initial load duke parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load duke parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load duke parents: diff changeset	7 * published by the Free Software Foundation.
a61af66fc99e Initial load duke parents: diff changeset	8 *
a61af66fc99e Initial load duke parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load duke parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load duke parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load duke parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load duke parents: diff changeset	13 * accompanied this code).
a61af66fc99e Initial load duke parents: diff changeset	14 *
a61af66fc99e Initial load duke parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load duke parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load duke parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load duke parents: diff changeset	18 *
a61af66fc99e Initial load duke parents: diff changeset	19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
a61af66fc99e Initial load duke parents: diff changeset	20 * CA 95054 USA or visit www.sun.com if you need additional information or
a61af66fc99e Initial load duke parents: diff changeset	21 * have any questions.
a61af66fc99e Initial load duke parents: diff changeset	22 *
a61af66fc99e Initial load duke parents: diff changeset	23 */
a61af66fc99e Initial load duke parents: diff changeset	24
a61af66fc99e Initial load duke parents: diff changeset	25 class ParallelScavengeHeap;
a61af66fc99e Initial load duke parents: diff changeset	26 class PSAdaptiveSizePolicy;
a61af66fc99e Initial load duke parents: diff changeset	27 class PSYoungGen;
a61af66fc99e Initial load duke parents: diff changeset	28 class PSOldGen;
a61af66fc99e Initial load duke parents: diff changeset	29 class PSPermGen;
a61af66fc99e Initial load duke parents: diff changeset	30 class ParCompactionManager;
a61af66fc99e Initial load duke parents: diff changeset	31 class ParallelTaskTerminator;
a61af66fc99e Initial load duke parents: diff changeset	32 class PSParallelCompact;
a61af66fc99e Initial load duke parents: diff changeset	33 class GCTaskManager;
a61af66fc99e Initial load duke parents: diff changeset	34 class GCTaskQueue;
a61af66fc99e Initial load duke parents: diff changeset	35 class PreGCValues;
a61af66fc99e Initial load duke parents: diff changeset	36 class MoveAndUpdateClosure;
a61af66fc99e Initial load duke parents: diff changeset	37 class RefProcTaskExecutor;
a61af66fc99e Initial load duke parents: diff changeset	38
482 7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	39 // 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	40 // 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	41 // 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	42 // 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	43 // 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	44 // 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	45 // 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	46 // 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	47 // 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	48 // region, splitting is necessary for predictable behavior.
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	49 //
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	50 // 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	51 // 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	52 // 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	53 // 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	54 // 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	55 // different destination space (distinct from dest_space_1).
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	56 //
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	57 // 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	58 // 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	59 // 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	60 // 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	61 // 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	62 // 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	63 // 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	64 //
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	65 // 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	66 // 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	67 // 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	68 // 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	69 // PSParallelCompact::first_src_addr()).
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	70 //
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	71 // Notes:
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	72 //
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	73 // 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	74 // object does not need any extra bookkeeping.
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 // 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	77 // constant.
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	78 //
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	79 // 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	80 // 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	81 // 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	82 // 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	83 // large object caused the overflow.
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	84 //
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	85 // Future work:
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 // 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	88 // 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	89 // 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	90 // 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	91 // 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	92 // 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	93 // 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	94 // 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	95 // 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	96 // doable, if a bit tricky.
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 // 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	99 // 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	100 // destination region.
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	101
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	102 class SplitInfo
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	103 {
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	104 public:
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	105 // 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	106 // 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	107 // never split, so 0 is the 'invalid' value.
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	108 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	109
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	110 // 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	111 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	112
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	113 // 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	114 // region and the destination of the partial object.
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	115 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	116 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	117 HeapWord* destination() const { return _destination; }
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	118
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	119 // 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	120 // (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	121 // remainder of the source region.
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	122 unsigned int destination_count() const { return _destination_count; }
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 // 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	125 // 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	126 // otherwise this is NULL.
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	127 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	128
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	129 // 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	130 // 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	131 // object; otherwise this is NULL.
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	132 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	133
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	134 // 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	135 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	136 HeapWord* destination);
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	137
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	138 void clear();
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 DEBUG_ONLY(void verify_clear();)
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	141
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	142 private:
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	143 size_t _src_region_idx;
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	144 size_t _partial_obj_size;
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	145 HeapWord* _destination;
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	146 unsigned int _destination_count;
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	147 HeapWord* _dest_region_addr;
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	148 HeapWord* _first_src_addr;
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	149 };
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 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	152 {
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	153 return _src_region_idx == region_idx && is_valid();
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	154 }
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	155
0 a61af66fc99e Initial load duke parents: diff changeset	156 class SpaceInfo
a61af66fc99e Initial load duke parents: diff changeset	157 {
a61af66fc99e Initial load duke parents: diff changeset	158 public:
a61af66fc99e Initial load duke parents: diff changeset	159 MutableSpace* space() const { return _space; }
a61af66fc99e Initial load duke parents: diff changeset	160
a61af66fc99e Initial load duke parents: diff changeset	161 // Where the free space will start after the collection. Valid only after the
a61af66fc99e Initial load duke parents: diff changeset	162 // summary phase completes.
a61af66fc99e Initial load duke parents: diff changeset	163 HeapWord* new_top() const { return _new_top; }
a61af66fc99e Initial load duke parents: diff changeset	164
a61af66fc99e Initial load duke parents: diff changeset	165 // Allows new_top to be set.
a61af66fc99e Initial load duke parents: diff changeset	166 HeapWord** new_top_addr() { return &_new_top; }
a61af66fc99e Initial load duke parents: diff changeset	167
a61af66fc99e Initial load duke parents: diff changeset	168 // Where the smallest allowable dense prefix ends (used only for perm gen).
a61af66fc99e Initial load duke parents: diff changeset	169 HeapWord* min_dense_prefix() const { return _min_dense_prefix; }
a61af66fc99e Initial load duke parents: diff changeset	170
a61af66fc99e Initial load duke parents: diff changeset	171 // Where the dense prefix ends, or the compacted region begins.
a61af66fc99e Initial load duke parents: diff changeset	172 HeapWord* dense_prefix() const { return _dense_prefix; }
a61af66fc99e Initial load duke parents: diff changeset	173
a61af66fc99e Initial load duke parents: diff changeset	174 // The start array for the (generation containing the) space, or NULL if there
a61af66fc99e Initial load duke parents: diff changeset	175 // is no start array.
a61af66fc99e Initial load duke parents: diff changeset	176 ObjectStartArray* start_array() const { return _start_array; }
a61af66fc99e Initial load duke parents: diff changeset	177
482 7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	178 SplitInfo& split_info() { return _split_info; }
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	179
0 a61af66fc99e Initial load duke parents: diff changeset	180 void set_space(MutableSpace* s) { _space = s; }
a61af66fc99e Initial load duke parents: diff changeset	181 void set_new_top(HeapWord* addr) { _new_top = addr; }
a61af66fc99e Initial load duke parents: diff changeset	182 void set_min_dense_prefix(HeapWord* addr) { _min_dense_prefix = addr; }
a61af66fc99e Initial load duke parents: diff changeset	183 void set_dense_prefix(HeapWord* addr) { _dense_prefix = addr; }
a61af66fc99e Initial load duke parents: diff changeset	184 void set_start_array(ObjectStartArray* s) { _start_array = s; }
a61af66fc99e Initial load duke parents: diff changeset	185
482 7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	186 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	187
0 a61af66fc99e Initial load duke parents: diff changeset	188 private:
a61af66fc99e Initial load duke parents: diff changeset	189 MutableSpace* _space;
a61af66fc99e Initial load duke parents: diff changeset	190 HeapWord* _new_top;
a61af66fc99e Initial load duke parents: diff changeset	191 HeapWord* _min_dense_prefix;
a61af66fc99e Initial load duke parents: diff changeset	192 HeapWord* _dense_prefix;
a61af66fc99e Initial load duke parents: diff changeset	193 ObjectStartArray* _start_array;
482 7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	194 SplitInfo _split_info;
0 a61af66fc99e Initial load duke parents: diff changeset	195 };
a61af66fc99e Initial load duke parents: diff changeset	196
a61af66fc99e Initial load duke parents: diff changeset	197 class ParallelCompactData
a61af66fc99e Initial load duke parents: diff changeset	198 {
a61af66fc99e Initial load duke parents: diff changeset	199 public:
a61af66fc99e Initial load duke parents: diff changeset	200 // Sizes are in HeapWords, unless indicated otherwise.
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	201 static const size_t Log2RegionSize;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	202 static const size_t RegionSize;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	203 static const size_t RegionSizeBytes;
0 a61af66fc99e Initial load duke parents: diff changeset	204
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	205 // 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	206 static const size_t RegionSizeOffsetMask;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	207 // 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	208 static const size_t RegionAddrOffsetMask;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	209 // 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	210 static const size_t RegionAddrMask;
0 a61af66fc99e Initial load duke parents: diff changeset	211
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	212 class RegionData
0 a61af66fc99e Initial load duke parents: diff changeset	213 {
a61af66fc99e Initial load duke parents: diff changeset	214 public:
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	215 // Destination address of the region.
0 a61af66fc99e Initial load duke parents: diff changeset	216 HeapWord* destination() const { return _destination; }
a61af66fc99e Initial load duke parents: diff changeset	217
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	218 // The first region containing data destined for this region.
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	219 size_t source_region() const { return _source_region; }
0 a61af66fc99e Initial load duke parents: diff changeset	220
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	221 // 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	222 // region that could not be updated during the main (parallel) compaction
0 a61af66fc99e Initial load duke parents: diff changeset	223 // 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	224 // extends onto a source region. However, the two uses do not overlap in
0 a61af66fc99e Initial load duke parents: diff changeset	225 // time, so the same field is used to save space.
a61af66fc99e Initial load duke parents: diff changeset	226 HeapWord* deferred_obj_addr() const { return _partial_obj_addr; }
a61af66fc99e Initial load duke parents: diff changeset	227
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	228 // The starting address of the partial object extending onto the region.
0 a61af66fc99e Initial load duke parents: diff changeset	229 HeapWord* partial_obj_addr() const { return _partial_obj_addr; }
a61af66fc99e Initial load duke parents: diff changeset	230
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	231 // Size of the partial object extending onto the region (words).
0 a61af66fc99e Initial load duke parents: diff changeset	232 size_t partial_obj_size() const { return _partial_obj_size; }
a61af66fc99e Initial load duke parents: diff changeset	233
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	234 // 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	235 // 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	236 // 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	237 // onto the next region (if any).
0 a61af66fc99e Initial load duke parents: diff changeset	238 size_t live_obj_size() const { return _dc_and_los & los_mask; }
a61af66fc99e Initial load duke parents: diff changeset	239
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	240 // Total live data that lies within the region (words).
0 a61af66fc99e Initial load duke parents: diff changeset	241 size_t data_size() const { return partial_obj_size() + live_obj_size(); }
a61af66fc99e Initial load duke parents: diff changeset	242
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	243 // 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	244 // this region will be copied. At the end of the summary phase, the valid
0 a61af66fc99e Initial load duke parents: diff changeset	245 // values of destination_count are
a61af66fc99e Initial load duke parents: diff changeset	246 //
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	247 // 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	248 // 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	249 // 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	250 // 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	251 // 2 - data from the region will be copied to 2 other regions.
0 a61af66fc99e Initial load duke parents: diff changeset	252 //
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	253 // During compaction as regions are emptied, the destination_count is
0 a61af66fc99e Initial load duke parents: diff changeset	254 // decremented (atomically) and when it reaches 0, it can be claimed and
a61af66fc99e Initial load duke parents: diff changeset	255 // then filled.
a61af66fc99e Initial load duke parents: diff changeset	256 //
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	257 // A region is claimed for processing by atomically changing the
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	258 // destination_count to the claimed value (dc_claimed). After a region has
0 a61af66fc99e Initial load duke parents: diff changeset	259 // been filled, the destination_count should be set to the completed value
a61af66fc99e Initial load duke parents: diff changeset	260 // (dc_completed).
a61af66fc99e Initial load duke parents: diff changeset	261 inline uint destination_count() const;
a61af66fc99e Initial load duke parents: diff changeset	262 inline uint destination_count_raw() const;
a61af66fc99e Initial load duke parents: diff changeset	263
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	264 // The location of the java heap data that corresponds to this region.
0 a61af66fc99e Initial load duke parents: diff changeset	265 inline HeapWord* data_location() const;
a61af66fc99e Initial load duke parents: diff changeset	266
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	267 // The highest address referenced by objects in this region.
0 a61af66fc99e Initial load duke parents: diff changeset	268 inline HeapWord* highest_ref() const;
a61af66fc99e Initial load duke parents: diff changeset	269
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	270 // Whether this region is available to be claimed, has been claimed, or has
0 a61af66fc99e Initial load duke parents: diff changeset	271 // been completed.
a61af66fc99e Initial load duke parents: diff changeset	272 //
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	273 // Minor subtlety: claimed() returns true if the region is marked
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	274 // completed(), which is desirable since a region must be claimed before it
0 a61af66fc99e Initial load duke parents: diff changeset	275 // can be completed.
a61af66fc99e Initial load duke parents: diff changeset	276 bool available() const { return _dc_and_los < dc_one; }
a61af66fc99e Initial load duke parents: diff changeset	277 bool claimed() const { return _dc_and_los >= dc_claimed; }
a61af66fc99e Initial load duke parents: diff changeset	278 bool completed() const { return _dc_and_los >= dc_completed; }
a61af66fc99e Initial load duke parents: diff changeset	279
a61af66fc99e Initial load duke parents: diff changeset	280 // These are not atomic.
a61af66fc99e Initial load duke parents: diff changeset	281 void set_destination(HeapWord* addr) { _destination = addr; }
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	282 void set_source_region(size_t region) { _source_region = region; }
0 a61af66fc99e Initial load duke parents: diff changeset	283 void set_deferred_obj_addr(HeapWord* addr) { _partial_obj_addr = addr; }
a61af66fc99e Initial load duke parents: diff changeset	284 void set_partial_obj_addr(HeapWord* addr) { _partial_obj_addr = addr; }
a61af66fc99e Initial load duke parents: diff changeset	285 void set_partial_obj_size(size_t words) {
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	286 _partial_obj_size = (region_sz_t) words;
0 a61af66fc99e Initial load duke parents: diff changeset	287 }
a61af66fc99e Initial load duke parents: diff changeset	288
a61af66fc99e Initial load duke parents: diff changeset	289 inline void set_destination_count(uint count);
a61af66fc99e Initial load duke parents: diff changeset	290 inline void set_live_obj_size(size_t words);
a61af66fc99e Initial load duke parents: diff changeset	291 inline void set_data_location(HeapWord* addr);
a61af66fc99e Initial load duke parents: diff changeset	292 inline void set_completed();
a61af66fc99e Initial load duke parents: diff changeset	293 inline bool claim_unsafe();
a61af66fc99e Initial load duke parents: diff changeset	294
a61af66fc99e Initial load duke parents: diff changeset	295 // These are atomic.
a61af66fc99e Initial load duke parents: diff changeset	296 inline void add_live_obj(size_t words);
a61af66fc99e Initial load duke parents: diff changeset	297 inline void set_highest_ref(HeapWord* addr);
a61af66fc99e Initial load duke parents: diff changeset	298 inline void decrement_destination_count();
a61af66fc99e Initial load duke parents: diff changeset	299 inline bool claim();
a61af66fc99e Initial load duke parents: diff changeset	300
a61af66fc99e Initial load duke parents: diff changeset	301 private:
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	302 // The type used to represent object sizes within a region.
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	303 typedef uint region_sz_t;
0 a61af66fc99e Initial load duke parents: diff changeset	304
a61af66fc99e Initial load duke parents: diff changeset	305 // Constants for manipulating the _dc_and_los field, which holds both the
a61af66fc99e Initial load duke parents: diff changeset	306 // destination count and live obj size. The live obj size lives at the
a61af66fc99e Initial load duke parents: diff changeset	307 // 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	308 static const region_sz_t dc_shift; // Shift amount.
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	309 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	310 static const region_sz_t dc_one; // 1, shifted appropriately.
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	311 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	312 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	313 static const region_sz_t los_mask; // Mask for live obj size.
0 a61af66fc99e Initial load duke parents: diff changeset	314
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	315 HeapWord* _destination;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	316 size_t _source_region;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	317 HeapWord* _partial_obj_addr;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	318 region_sz_t _partial_obj_size;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	319 region_sz_t volatile _dc_and_los;
0 a61af66fc99e Initial load duke parents: diff changeset	320 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	321 // These enable optimizations that are only partially implemented. Use
a61af66fc99e Initial load duke parents: diff changeset	322 // debug builds to prevent the code fragments from breaking.
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	323 HeapWord* _data_location;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	324 HeapWord* _highest_ref;
0 a61af66fc99e Initial load duke parents: diff changeset	325 #endif // #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	326
a61af66fc99e Initial load duke parents: diff changeset	327 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	328 public:
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	329 uint _pushed; // 0 until region is pushed onto a worker's stack
0 a61af66fc99e Initial load duke parents: diff changeset	330 private:
a61af66fc99e Initial load duke parents: diff changeset	331 #endif
a61af66fc99e Initial load duke parents: diff changeset	332 };
a61af66fc99e Initial load duke parents: diff changeset	333
a61af66fc99e Initial load duke parents: diff changeset	334 public:
a61af66fc99e Initial load duke parents: diff changeset	335 ParallelCompactData();
a61af66fc99e Initial load duke parents: diff changeset	336 bool initialize(MemRegion covered_region);
a61af66fc99e Initial load duke parents: diff changeset	337
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	338 size_t region_count() const { return _region_count; }
0 a61af66fc99e Initial load duke parents: diff changeset	339
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	340 // Convert region indices to/from RegionData pointers.
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	341 inline RegionData* region(size_t region_idx) const;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	342 inline size_t region(const RegionData* const region_ptr) const;
0 a61af66fc99e Initial load duke parents: diff changeset	343
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	344 // 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	345 bool region_contains(size_t region_index, HeapWord* addr);
0 a61af66fc99e Initial load duke parents: diff changeset	346
a61af66fc99e Initial load duke parents: diff changeset	347 void add_obj(HeapWord* addr, size_t len);
a61af66fc99e Initial load duke parents: diff changeset	348 void add_obj(oop p, size_t len) { add_obj((HeapWord*)p, len); }
a61af66fc99e Initial load duke parents: diff changeset	349
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	350 // 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	351 // 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	352 // must be region-aligned; end need not be.
0 a61af66fc99e Initial load duke parents: diff changeset	353 void summarize_dense_prefix(HeapWord* beg, HeapWord* end);
a61af66fc99e Initial load duke parents: diff changeset	354
482 7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	355 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	356 HeapWord* destination, HeapWord* target_end,
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	357 HeapWord** target_next);
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	358 bool summarize(SplitInfo& split_info,
0 a61af66fc99e Initial load duke parents: diff changeset	359 HeapWord* source_beg, HeapWord* source_end,
482 7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	360 HeapWord** source_next,
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	361 HeapWord* target_beg, HeapWord* target_end,
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	362 HeapWord** target_next);
0 a61af66fc99e Initial load duke parents: diff changeset	363
a61af66fc99e Initial load duke parents: diff changeset	364 void clear();
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	365 void clear_range(size_t beg_region, size_t end_region);
0 a61af66fc99e Initial load duke parents: diff changeset	366 void clear_range(HeapWord* beg, HeapWord* end) {
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	367 clear_range(addr_to_region_idx(beg), addr_to_region_idx(end));
0 a61af66fc99e Initial load duke parents: diff changeset	368 }
a61af66fc99e Initial load duke parents: diff changeset	369
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	370 // Return the number of words between addr and the start of the region
0 a61af66fc99e Initial load duke parents: diff changeset	371 // containing addr.
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	372 inline size_t region_offset(const HeapWord* addr) const;
0 a61af66fc99e Initial load duke parents: diff changeset	373
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	374 // Convert addresses to/from a region index or region pointer.
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	375 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	376 inline RegionData* addr_to_region_ptr(const HeapWord* addr) const;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	377 inline HeapWord* region_to_addr(size_t region) const;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	378 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	379 inline HeapWord* region_to_addr(const RegionData* region) const;
0 a61af66fc99e Initial load duke parents: diff changeset	380
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	381 inline HeapWord* region_align_down(HeapWord* addr) const;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	382 inline HeapWord* region_align_up(HeapWord* addr) const;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	383 inline bool is_region_aligned(HeapWord* addr) const;
0 a61af66fc99e Initial load duke parents: diff changeset	384
a61af66fc99e Initial load duke parents: diff changeset	385 // 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	386 HeapWord* partial_obj_end(size_t region_idx) const;
0 a61af66fc99e Initial load duke parents: diff changeset	387
a61af66fc99e Initial load duke parents: diff changeset	388 // Return the new location of the object p after the
a61af66fc99e Initial load duke parents: diff changeset	389 // the compaction.
a61af66fc99e Initial load duke parents: diff changeset	390 HeapWord* calc_new_pointer(HeapWord* addr);
a61af66fc99e Initial load duke parents: diff changeset	391
a61af66fc99e Initial load duke parents: diff changeset	392 HeapWord* calc_new_pointer(oop p) {
a61af66fc99e Initial load duke parents: diff changeset	393 return calc_new_pointer((HeapWord*) p);
a61af66fc99e Initial load duke parents: diff changeset	394 }
a61af66fc99e Initial load duke parents: diff changeset	395
a61af66fc99e Initial load duke parents: diff changeset	396 // Return the updated address for the given klass
a61af66fc99e Initial load duke parents: diff changeset	397 klassOop calc_new_klass(klassOop);
a61af66fc99e Initial load duke parents: diff changeset	398
a61af66fc99e Initial load duke parents: diff changeset	399 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	400 void verify_clear(const PSVirtualSpace* vspace);
a61af66fc99e Initial load duke parents: diff changeset	401 void verify_clear();
a61af66fc99e Initial load duke parents: diff changeset	402 #endif // #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	403
a61af66fc99e Initial load duke parents: diff changeset	404 private:
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	405 bool initialize_region_data(size_t region_size);
0 a61af66fc99e Initial load duke parents: diff changeset	406 PSVirtualSpace* create_vspace(size_t count, size_t element_size);
a61af66fc99e Initial load duke parents: diff changeset	407
a61af66fc99e Initial load duke parents: diff changeset	408 private:
a61af66fc99e Initial load duke parents: diff changeset	409 HeapWord* _region_start;
a61af66fc99e Initial load duke parents: diff changeset	410 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	411 HeapWord* _region_end;
a61af66fc99e Initial load duke parents: diff changeset	412 #endif // #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	413
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	414 PSVirtualSpace* _region_vspace;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	415 RegionData* _region_data;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	416 size_t _region_count;
0 a61af66fc99e Initial load duke parents: diff changeset	417 };
a61af66fc99e Initial load duke parents: diff changeset	418
a61af66fc99e Initial load duke parents: diff changeset	419 inline uint
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	420 ParallelCompactData::RegionData::destination_count_raw() const
0 a61af66fc99e Initial load duke parents: diff changeset	421 {
a61af66fc99e Initial load duke parents: diff changeset	422 return _dc_and_los & dc_mask;
a61af66fc99e Initial load duke parents: diff changeset	423 }
a61af66fc99e Initial load duke parents: diff changeset	424
a61af66fc99e Initial load duke parents: diff changeset	425 inline uint
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	426 ParallelCompactData::RegionData::destination_count() const
0 a61af66fc99e Initial load duke parents: diff changeset	427 {
a61af66fc99e Initial load duke parents: diff changeset	428 return destination_count_raw() >> dc_shift;
a61af66fc99e Initial load duke parents: diff changeset	429 }
a61af66fc99e Initial load duke parents: diff changeset	430
a61af66fc99e Initial load duke parents: diff changeset	431 inline void
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	432 ParallelCompactData::RegionData::set_destination_count(uint count)
0 a61af66fc99e Initial load duke parents: diff changeset	433 {
a61af66fc99e Initial load duke parents: diff changeset	434 assert(count <= (dc_completed >> dc_shift), "count too large");
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	435 const region_sz_t live_sz = (region_sz_t) live_obj_size();
0 a61af66fc99e Initial load duke parents: diff changeset	436 _dc_and_los = (count << dc_shift) \| live_sz;
a61af66fc99e Initial load duke parents: diff changeset	437 }
a61af66fc99e Initial load duke parents: diff changeset	438
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	439 inline void ParallelCompactData::RegionData::set_live_obj_size(size_t words)
0 a61af66fc99e Initial load duke parents: diff changeset	440 {
a61af66fc99e Initial load duke parents: diff changeset	441 assert(words <= los_mask, "would overflow");
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	442 _dc_and_los = destination_count_raw() \| (region_sz_t)words;
0 a61af66fc99e Initial load duke parents: diff changeset	443 }
a61af66fc99e Initial load duke parents: diff changeset	444
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	445 inline void ParallelCompactData::RegionData::decrement_destination_count()
0 a61af66fc99e Initial load duke parents: diff changeset	446 {
a61af66fc99e Initial load duke parents: diff changeset	447 assert(_dc_and_los < dc_claimed, "already claimed");
a61af66fc99e Initial load duke parents: diff changeset	448 assert(_dc_and_los >= dc_one, "count would go negative");
a61af66fc99e Initial load duke parents: diff changeset	449 Atomic::add((int)dc_mask, (volatile int*)&_dc_and_los);
a61af66fc99e Initial load duke parents: diff changeset	450 }
a61af66fc99e Initial load duke parents: diff changeset	451
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	452 inline HeapWord* ParallelCompactData::RegionData::data_location() const
0 a61af66fc99e Initial load duke parents: diff changeset	453 {
a61af66fc99e Initial load duke parents: diff changeset	454 DEBUG_ONLY(return _data_location;)
a61af66fc99e Initial load duke parents: diff changeset	455 NOT_DEBUG(return NULL;)
a61af66fc99e Initial load duke parents: diff changeset	456 }
a61af66fc99e Initial load duke parents: diff changeset	457
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	458 inline HeapWord* ParallelCompactData::RegionData::highest_ref() const
0 a61af66fc99e Initial load duke parents: diff changeset	459 {
a61af66fc99e Initial load duke parents: diff changeset	460 DEBUG_ONLY(return _highest_ref;)
a61af66fc99e Initial load duke parents: diff changeset	461 NOT_DEBUG(return NULL;)
a61af66fc99e Initial load duke parents: diff changeset	462 }
a61af66fc99e Initial load duke parents: diff changeset	463
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	464 inline void ParallelCompactData::RegionData::set_data_location(HeapWord* addr)
0 a61af66fc99e Initial load duke parents: diff changeset	465 {
a61af66fc99e Initial load duke parents: diff changeset	466 DEBUG_ONLY(_data_location = addr;)
a61af66fc99e Initial load duke parents: diff changeset	467 }
a61af66fc99e Initial load duke parents: diff changeset	468
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	469 inline void ParallelCompactData::RegionData::set_completed()
0 a61af66fc99e Initial load duke parents: diff changeset	470 {
a61af66fc99e Initial load duke parents: diff changeset	471 assert(claimed(), "must be claimed first");
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	472 _dc_and_los = dc_completed \| (region_sz_t) live_obj_size();
0 a61af66fc99e Initial load duke parents: diff changeset	473 }
a61af66fc99e Initial load duke parents: diff changeset	474
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	475 // MT-unsafe claiming of a region. Should only be used during single threaded
0 a61af66fc99e Initial load duke parents: diff changeset	476 // execution.
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	477 inline bool ParallelCompactData::RegionData::claim_unsafe()
0 a61af66fc99e Initial load duke parents: diff changeset	478 {
a61af66fc99e Initial load duke parents: diff changeset	479 if (available()) {
a61af66fc99e Initial load duke parents: diff changeset	480 _dc_and_los \|= dc_claimed;
a61af66fc99e Initial load duke parents: diff changeset	481 return true;
a61af66fc99e Initial load duke parents: diff changeset	482 }
a61af66fc99e Initial load duke parents: diff changeset	483 return false;
a61af66fc99e Initial load duke parents: diff changeset	484 }
a61af66fc99e Initial load duke parents: diff changeset	485
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	486 inline void ParallelCompactData::RegionData::add_live_obj(size_t words)
0 a61af66fc99e Initial load duke parents: diff changeset	487 {
a61af66fc99e Initial load duke parents: diff changeset	488 assert(words <= (size_t)los_mask - live_obj_size(), "overflow");
a61af66fc99e Initial load duke parents: diff changeset	489 Atomic::add((int) words, (volatile int*) &_dc_and_los);
a61af66fc99e Initial load duke parents: diff changeset	490 }
a61af66fc99e Initial load duke parents: diff changeset	491
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	492 inline void ParallelCompactData::RegionData::set_highest_ref(HeapWord* addr)
0 a61af66fc99e Initial load duke parents: diff changeset	493 {
a61af66fc99e Initial load duke parents: diff changeset	494 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	495 HeapWord* tmp = _highest_ref;
a61af66fc99e Initial load duke parents: diff changeset	496 while (addr > tmp) {
a61af66fc99e Initial load duke parents: diff changeset	497 tmp = (HeapWord*)Atomic::cmpxchg_ptr(addr, &_highest_ref, tmp);
a61af66fc99e Initial load duke parents: diff changeset	498 }
a61af66fc99e Initial load duke parents: diff changeset	499 #endif // #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	500 }
a61af66fc99e Initial load duke parents: diff changeset	501
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	502 inline bool ParallelCompactData::RegionData::claim()
0 a61af66fc99e Initial load duke parents: diff changeset	503 {
a61af66fc99e Initial load duke parents: diff changeset	504 const int los = (int) live_obj_size();
a61af66fc99e Initial load duke parents: diff changeset	505 const int old = Atomic::cmpxchg(dc_claimed \| los,
a61af66fc99e Initial load duke parents: diff changeset	506 (volatile int*) &_dc_and_los, los);
a61af66fc99e Initial load duke parents: diff changeset	507 return old == los;
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 ParallelCompactData::RegionData*
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	511 ParallelCompactData::region(size_t region_idx) const
0 a61af66fc99e Initial load duke parents: diff changeset	512 {
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	513 assert(region_idx <= region_count(), "bad arg");
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	514 return _region_data + region_idx;
0 a61af66fc99e Initial load duke parents: diff changeset	515 }
a61af66fc99e Initial load duke parents: diff changeset	516
a61af66fc99e Initial load duke parents: diff changeset	517 inline size_t
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	518 ParallelCompactData::region(const RegionData* const region_ptr) const
0 a61af66fc99e Initial load duke parents: diff changeset	519 {
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	520 assert(region_ptr >= _region_data, "bad arg");
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	521 assert(region_ptr <= _region_data + region_count(), "bad arg");
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	522 return pointer_delta(region_ptr, _region_data, sizeof(RegionData));
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_offset(const HeapWord* addr) const
0 a61af66fc99e Initial load duke parents: diff changeset	527 {
a61af66fc99e Initial load duke parents: diff changeset	528 assert(addr >= _region_start, "bad addr");
a61af66fc99e Initial load duke parents: diff changeset	529 assert(addr <= _region_end, "bad addr");
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	530 return (size_t(addr) & RegionAddrOffsetMask) >> LogHeapWordSize;
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::addr_to_region_idx(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 pointer_delta(addr, _region_start) >> Log2RegionSize;
0 a61af66fc99e Initial load duke parents: diff changeset	539 }
a61af66fc99e Initial load duke parents: diff changeset	540
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	541 inline ParallelCompactData::RegionData*
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	542 ParallelCompactData::addr_to_region_ptr(const HeapWord* addr) const
0 a61af66fc99e Initial load duke parents: diff changeset	543 {
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	544 return region(addr_to_region_idx(addr));
0 a61af66fc99e Initial load duke parents: diff changeset	545 }
a61af66fc99e Initial load duke parents: diff changeset	546
a61af66fc99e Initial load duke parents: diff changeset	547 inline HeapWord*
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	548 ParallelCompactData::region_to_addr(size_t region) const
0 a61af66fc99e Initial load duke parents: diff changeset	549 {
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	550 assert(region <= _region_count, "region out of range");
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	551 return _region_start + (region << Log2RegionSize);
0 a61af66fc99e Initial load duke parents: diff changeset	552 }
a61af66fc99e Initial load duke parents: diff changeset	553
a61af66fc99e Initial load duke parents: diff changeset	554 inline HeapWord*
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	555 ParallelCompactData::region_to_addr(const RegionData* region) const
0 a61af66fc99e Initial load duke parents: diff changeset	556 {
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	557 return region_to_addr(pointer_delta(region, _region_data,
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	558 sizeof(RegionData)));
0 a61af66fc99e Initial load duke parents: diff changeset	559 }
a61af66fc99e Initial load duke parents: diff changeset	560
a61af66fc99e Initial load duke parents: diff changeset	561 inline HeapWord*
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	562 ParallelCompactData::region_to_addr(size_t region, size_t offset) const
0 a61af66fc99e Initial load duke parents: diff changeset	563 {
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	564 assert(region <= _region_count, "region out of range");
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	565 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	566 return region_to_addr(region) + offset;
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_align_down(HeapWord* addr) const
0 a61af66fc99e Initial load duke parents: diff changeset	571 {
a61af66fc99e Initial load duke parents: diff changeset	572 assert(addr >= _region_start, "bad addr");
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	573 assert(addr < _region_end + RegionSize, "bad addr");
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	574 return (HeapWord*)(size_t(addr) & RegionAddrMask);
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_up(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");
a61af66fc99e Initial load duke parents: diff changeset	581 assert(addr <= _region_end, "bad addr");
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	582 return region_align_down(addr + RegionSizeOffsetMask);
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 bool
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	586 ParallelCompactData::is_region_aligned(HeapWord* addr) const
0 a61af66fc99e Initial load duke parents: diff changeset	587 {
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	588 return region_offset(addr) == 0;
0 a61af66fc99e Initial load duke parents: diff changeset	589 }
a61af66fc99e Initial load duke parents: diff changeset	590
a61af66fc99e Initial load duke parents: diff changeset	591 // Abstract closure for use with ParMarkBitMap::iterate(), which will invoke the
a61af66fc99e Initial load duke parents: diff changeset	592 // do_addr() method.
a61af66fc99e Initial load duke parents: diff changeset	593 //
a61af66fc99e Initial load duke parents: diff changeset	594 // The closure is initialized with the number of heap words to process
a61af66fc99e Initial load duke parents: diff changeset	595 // (words_remaining()), and becomes 'full' when it reaches 0. The do_addr()
a61af66fc99e Initial load duke parents: diff changeset	596 // methods in subclasses should update the total as words are processed. Since
a61af66fc99e Initial load duke parents: diff changeset	597 // only one subclass actually uses this mechanism to terminate iteration, the
a61af66fc99e Initial load duke parents: diff changeset	598 // default initial value is > 0. The implementation is here and not in the
a61af66fc99e Initial load duke parents: diff changeset	599 // single subclass that uses it to avoid making is_full() virtual, and thus
a61af66fc99e Initial load duke parents: diff changeset	600 // adding a virtual call per live object.
a61af66fc99e Initial load duke parents: diff changeset	601
a61af66fc99e Initial load duke parents: diff changeset	602 class ParMarkBitMapClosure: public StackObj {
a61af66fc99e Initial load duke parents: diff changeset	603 public:
a61af66fc99e Initial load duke parents: diff changeset	604 typedef ParMarkBitMap::idx_t idx_t;
a61af66fc99e Initial load duke parents: diff changeset	605 typedef ParMarkBitMap::IterationStatus IterationStatus;
a61af66fc99e Initial load duke parents: diff changeset	606
a61af66fc99e Initial load duke parents: diff changeset	607 public:
a61af66fc99e Initial load duke parents: diff changeset	608 inline ParMarkBitMapClosure(ParMarkBitMap* mbm, ParCompactionManager* cm,
a61af66fc99e Initial load duke parents: diff changeset	609 size_t words = max_uintx);
a61af66fc99e Initial load duke parents: diff changeset	610
a61af66fc99e Initial load duke parents: diff changeset	611 inline ParCompactionManager* compaction_manager() const;
a61af66fc99e Initial load duke parents: diff changeset	612 inline ParMarkBitMap* bitmap() const;
a61af66fc99e Initial load duke parents: diff changeset	613 inline size_t words_remaining() const;
a61af66fc99e Initial load duke parents: diff changeset	614 inline bool is_full() const;
a61af66fc99e Initial load duke parents: diff changeset	615 inline HeapWord* source() const;
a61af66fc99e Initial load duke parents: diff changeset	616
a61af66fc99e Initial load duke parents: diff changeset	617 inline void set_source(HeapWord* addr);
a61af66fc99e Initial load duke parents: diff changeset	618
a61af66fc99e Initial load duke parents: diff changeset	619 virtual IterationStatus do_addr(HeapWord* addr, size_t words) = 0;
a61af66fc99e Initial load duke parents: diff changeset	620
a61af66fc99e Initial load duke parents: diff changeset	621 protected:
a61af66fc99e Initial load duke parents: diff changeset	622 inline void decrement_words_remaining(size_t words);
a61af66fc99e Initial load duke parents: diff changeset	623
a61af66fc99e Initial load duke parents: diff changeset	624 private:
a61af66fc99e Initial load duke parents: diff changeset	625 ParMarkBitMap* const _bitmap;
a61af66fc99e Initial load duke parents: diff changeset	626 ParCompactionManager* const _compaction_manager;
a61af66fc99e Initial load duke parents: diff changeset	627 DEBUG_ONLY(const size_t _initial_words_remaining;) // Useful in debugger.
a61af66fc99e Initial load duke parents: diff changeset	628 size_t _words_remaining; // Words left to copy.
a61af66fc99e Initial load duke parents: diff changeset	629
a61af66fc99e Initial load duke parents: diff changeset	630 protected:
a61af66fc99e Initial load duke parents: diff changeset	631 HeapWord* _source; // Next addr that would be read.
a61af66fc99e Initial load duke parents: diff changeset	632 };
a61af66fc99e Initial load duke parents: diff changeset	633
a61af66fc99e Initial load duke parents: diff changeset	634 inline
a61af66fc99e Initial load duke parents: diff changeset	635 ParMarkBitMapClosure::ParMarkBitMapClosure(ParMarkBitMap* bitmap,
a61af66fc99e Initial load duke parents: diff changeset	636 ParCompactionManager* cm,
a61af66fc99e Initial load duke parents: diff changeset	637 size_t words):
a61af66fc99e Initial load duke parents: diff changeset	638 _bitmap(bitmap), _compaction_manager(cm)
a61af66fc99e Initial load duke parents: diff changeset	639 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	640 , _initial_words_remaining(words)
a61af66fc99e Initial load duke parents: diff changeset	641 #endif
a61af66fc99e Initial load duke parents: diff changeset	642 {
a61af66fc99e Initial load duke parents: diff changeset	643 _words_remaining = words;
a61af66fc99e Initial load duke parents: diff changeset	644 _source = NULL;
a61af66fc99e Initial load duke parents: diff changeset	645 }
a61af66fc99e Initial load duke parents: diff changeset	646
a61af66fc99e Initial load duke parents: diff changeset	647 inline ParCompactionManager* ParMarkBitMapClosure::compaction_manager() const {
a61af66fc99e Initial load duke parents: diff changeset	648 return _compaction_manager;
a61af66fc99e Initial load duke parents: diff changeset	649 }
a61af66fc99e Initial load duke parents: diff changeset	650
a61af66fc99e Initial load duke parents: diff changeset	651 inline ParMarkBitMap* ParMarkBitMapClosure::bitmap() const {
a61af66fc99e Initial load duke parents: diff changeset	652 return _bitmap;
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 size_t ParMarkBitMapClosure::words_remaining() const {
a61af66fc99e Initial load duke parents: diff changeset	656 return _words_remaining;
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 bool ParMarkBitMapClosure::is_full() const {
a61af66fc99e Initial load duke parents: diff changeset	660 return words_remaining() == 0;
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 HeapWord* ParMarkBitMapClosure::source() const {
a61af66fc99e Initial load duke parents: diff changeset	664 return _source;
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 void ParMarkBitMapClosure::set_source(HeapWord* addr) {
a61af66fc99e Initial load duke parents: diff changeset	668 _source = addr;
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 void ParMarkBitMapClosure::decrement_words_remaining(size_t words) {
a61af66fc99e Initial load duke parents: diff changeset	672 assert(_words_remaining >= words, "processed too many words");
a61af66fc99e Initial load duke parents: diff changeset	673 _words_remaining -= words;
a61af66fc99e Initial load duke parents: diff changeset	674 }
a61af66fc99e Initial load duke parents: diff changeset	675
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	676 // 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	677 // 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	678 // 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	679 // 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	680 // 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	681 // 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	682 // 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	683 // 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	684 // address) sliding compaction.
263 12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 113 diff changeset	685 //
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 113 diff changeset	686 // 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	687 //
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 113 diff changeset	688 // - marking phase
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 113 diff changeset	689 // - summary phase
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 113 diff changeset	690 // - compacting phase
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 113 diff changeset	691 // - clean up phase
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 113 diff changeset	692 //
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 113 diff changeset	693 // 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	694 // - mark all the live objects
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 113 diff changeset	695 // - 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	696 // - 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	697 // - 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	698 //
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	699 // 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	700 // 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	701 // 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	702 // PSParallelCompact::summary_phase(). The move and update phase is implemented
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	703 // in PSParallelCompact::compact().
263 12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 113 diff changeset	704 //
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	705 // 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	706 // 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	707 // 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	708 // 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	709 //
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	710 // region -----+---------------------+----------
263 12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 113 diff changeset	711 // 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	712 //
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	713 // 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	714 // 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	715 // 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	716 // 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	717 // 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	718 // 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	719 // 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	720 // 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	721 // 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	722 // covered by a region.
263 12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 113 diff changeset	723 //
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	724 // 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	725 // 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	726 // 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	727 // 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	728 //
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	729 // - 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	730 // entering the region.
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	731 // - the location of the first live data on the region
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	732 // - 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	733 //
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 113 diff changeset	734 // See ParallelCompactData for precise details. The summary phase also
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	735 // 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	736 // 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	737 // 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	738 // summarize_dense_prefix().
263 12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 113 diff changeset	739 //
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 113 diff changeset	740 // 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	741 //
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	742 // 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	743 // references in the object.
263 12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 113 diff changeset	744 //
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	745 // 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	746 // 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	747 // 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	748 // 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	749 // 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	750 // clean up phase. See the method PSParallelCompact::update_deferred_objects().
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	751 // 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	752 //
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	753 // 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	754 // 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	755 // 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	756 // 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	757 // 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	758 // 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	759 // 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	760 // 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	761 // and removed from the ready list.
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	762
0 a61af66fc99e Initial load duke parents: diff changeset	763 class PSParallelCompact : AllStatic {
a61af66fc99e Initial load duke parents: diff changeset	764 public:
a61af66fc99e Initial load duke parents: diff changeset	765 // Convenient access to type names.
a61af66fc99e Initial load duke parents: diff changeset	766 typedef ParMarkBitMap::idx_t idx_t;
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	767 typedef ParallelCompactData::RegionData RegionData;
0 a61af66fc99e Initial load duke parents: diff changeset	768
a61af66fc99e Initial load duke parents: diff changeset	769 typedef enum {
a61af66fc99e Initial load duke parents: diff changeset	770 perm_space_id, old_space_id, eden_space_id,
a61af66fc99e Initial load duke parents: diff changeset	771 from_space_id, to_space_id, last_space_id
a61af66fc99e Initial load duke parents: diff changeset	772 } SpaceId;
a61af66fc99e Initial load duke parents: diff changeset	773
a61af66fc99e Initial load duke parents: diff changeset	774 public:
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	775 // Inline closure decls
0 a61af66fc99e Initial load duke parents: diff changeset	776 //
a61af66fc99e Initial load duke parents: diff changeset	777 class IsAliveClosure: public BoolObjectClosure {
a61af66fc99e Initial load duke parents: diff changeset	778 public:
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	779 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	780 virtual bool do_object_b(oop p);
0 a61af66fc99e Initial load duke parents: diff changeset	781 };
a61af66fc99e Initial load duke parents: diff changeset	782
a61af66fc99e Initial load duke parents: diff changeset	783 class KeepAliveClosure: public OopClosure {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	784 private:
0 a61af66fc99e Initial load duke parents: diff changeset	785 ParCompactionManager* _compaction_manager;
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	786 protected:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	787 template <class T> inline void do_oop_work(T* p);
0 a61af66fc99e Initial load duke parents: diff changeset	788 public:
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	789 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	790 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	791 virtual void do_oop(narrowOop* p);
0 a61af66fc99e Initial load duke parents: diff changeset	792 };
a61af66fc99e Initial load duke parents: diff changeset	793
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	794 // Current unused
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	795 class FollowRootClosure: public OopsInGenClosure {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	796 private:
0 a61af66fc99e Initial load duke parents: diff changeset	797 ParCompactionManager* _compaction_manager;
a61af66fc99e Initial load duke parents: diff changeset	798 public:
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	799 FollowRootClosure(ParCompactionManager* cm) : _compaction_manager(cm) { }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	800 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	801 virtual void do_oop(narrowOop* p);
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	802 };
0 a61af66fc99e Initial load duke parents: diff changeset	803
a61af66fc99e Initial load duke parents: diff changeset	804 class FollowStackClosure: public VoidClosure {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	805 private:
0 a61af66fc99e Initial load duke parents: diff changeset	806 ParCompactionManager* _compaction_manager;
a61af66fc99e Initial load duke parents: diff changeset	807 public:
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	808 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	809 virtual void do_void();
0 a61af66fc99e Initial load duke parents: diff changeset	810 };
a61af66fc99e Initial load duke parents: diff changeset	811
a61af66fc99e Initial load duke parents: diff changeset	812 class AdjustPointerClosure: public OopsInGenClosure {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	813 private:
0 a61af66fc99e Initial load duke parents: diff changeset	814 bool _is_root;
a61af66fc99e Initial load duke parents: diff changeset	815 public:
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	816 AdjustPointerClosure(bool is_root) : _is_root(is_root) { }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	817 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	818 virtual void do_oop(narrowOop* p);
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	819 // 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	820 virtual void do_code_blob(CodeBlob* cb) const { }
0 a61af66fc99e Initial load duke parents: diff changeset	821 };
a61af66fc99e Initial load duke parents: diff changeset	822
a61af66fc99e Initial load duke parents: diff changeset	823 // Closure for verifying update of pointers. Does not
a61af66fc99e Initial load duke parents: diff changeset	824 // have any side effects.
a61af66fc99e Initial load duke parents: diff changeset	825 class VerifyUpdateClosure: public ParMarkBitMapClosure {
a61af66fc99e Initial load duke parents: diff changeset	826 const MutableSpace* _space; // Is this ever used?
a61af66fc99e Initial load duke parents: diff changeset	827
a61af66fc99e Initial load duke parents: diff changeset	828 public:
a61af66fc99e Initial load duke parents: diff changeset	829 VerifyUpdateClosure(ParCompactionManager* cm, const MutableSpace* sp) :
a61af66fc99e Initial load duke parents: diff changeset	830 ParMarkBitMapClosure(PSParallelCompact::mark_bitmap(), cm), _space(sp)
a61af66fc99e Initial load duke parents: diff changeset	831 { }
a61af66fc99e Initial load duke parents: diff changeset	832
a61af66fc99e Initial load duke parents: diff changeset	833 virtual IterationStatus do_addr(HeapWord* addr, size_t words);
a61af66fc99e Initial load duke parents: diff changeset	834
a61af66fc99e Initial load duke parents: diff changeset	835 const MutableSpace* space() { return _space; }
a61af66fc99e Initial load duke parents: diff changeset	836 };
a61af66fc99e Initial load duke parents: diff changeset	837
a61af66fc99e Initial load duke parents: diff changeset	838 // Closure for updating objects altered for debug checking
a61af66fc99e Initial load duke parents: diff changeset	839 class ResetObjectsClosure: public ParMarkBitMapClosure {
a61af66fc99e Initial load duke parents: diff changeset	840 public:
a61af66fc99e Initial load duke parents: diff changeset	841 ResetObjectsClosure(ParCompactionManager* cm):
a61af66fc99e Initial load duke parents: diff changeset	842 ParMarkBitMapClosure(PSParallelCompact::mark_bitmap(), cm)
a61af66fc99e Initial load duke parents: diff changeset	843 { }
a61af66fc99e Initial load duke parents: diff changeset	844
a61af66fc99e Initial load duke parents: diff changeset	845 virtual IterationStatus do_addr(HeapWord* addr, size_t words);
a61af66fc99e Initial load duke parents: diff changeset	846 };
a61af66fc99e Initial load duke parents: diff changeset	847
a61af66fc99e Initial load duke parents: diff changeset	848 friend class KeepAliveClosure;
a61af66fc99e Initial load duke parents: diff changeset	849 friend class FollowStackClosure;
a61af66fc99e Initial load duke parents: diff changeset	850 friend class AdjustPointerClosure;
a61af66fc99e Initial load duke parents: diff changeset	851 friend class FollowRootClosure;
a61af66fc99e Initial load duke parents: diff changeset	852 friend class instanceKlassKlass;
a61af66fc99e Initial load duke parents: diff changeset	853 friend class RefProcTaskProxy;
a61af66fc99e Initial load duke parents: diff changeset	854
a61af66fc99e Initial load duke parents: diff changeset	855 private:
a61af66fc99e Initial load duke parents: diff changeset	856 static elapsedTimer _accumulated_time;
a61af66fc99e Initial load duke parents: diff changeset	857 static unsigned int _total_invocations;
a61af66fc99e Initial load duke parents: diff changeset	858 static unsigned int _maximum_compaction_gc_num;
a61af66fc99e Initial load duke parents: diff changeset	859 static jlong _time_of_last_gc; // ms
a61af66fc99e Initial load duke parents: diff changeset	860 static CollectorCounters* _counters;
a61af66fc99e Initial load duke parents: diff changeset	861 static ParMarkBitMap _mark_bitmap;
a61af66fc99e Initial load duke parents: diff changeset	862 static ParallelCompactData _summary_data;
a61af66fc99e Initial load duke parents: diff changeset	863 static IsAliveClosure _is_alive_closure;
a61af66fc99e Initial load duke parents: diff changeset	864 static SpaceInfo _space_info[last_space_id];
a61af66fc99e Initial load duke parents: diff changeset	865 static bool _print_phases;
a61af66fc99e Initial load duke parents: diff changeset	866 static AdjustPointerClosure _adjust_root_pointer_closure;
a61af66fc99e Initial load duke parents: diff changeset	867 static AdjustPointerClosure _adjust_pointer_closure;
a61af66fc99e Initial load duke parents: diff changeset	868
a61af66fc99e Initial load duke parents: diff changeset	869 // Reference processing (used in ...follow_contents)
a61af66fc99e Initial load duke parents: diff changeset	870 static ReferenceProcessor* _ref_processor;
a61af66fc99e Initial load duke parents: diff changeset	871
a61af66fc99e Initial load duke parents: diff changeset	872 // Updated location of intArrayKlassObj.
a61af66fc99e Initial load duke parents: diff changeset	873 static klassOop _updated_int_array_klass_obj;
a61af66fc99e Initial load duke parents: diff changeset	874
a61af66fc99e Initial load duke parents: diff changeset	875 // Values computed at initialization and used by dead_wood_limiter().
a61af66fc99e Initial load duke parents: diff changeset	876 static double _dwl_mean;
a61af66fc99e Initial load duke parents: diff changeset	877 static double _dwl_std_dev;
a61af66fc99e Initial load duke parents: diff changeset	878 static double _dwl_first_term;
a61af66fc99e Initial load duke parents: diff changeset	879 static double _dwl_adjustment;
a61af66fc99e Initial load duke parents: diff changeset	880 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	881 static bool _dwl_initialized;
a61af66fc99e Initial load duke parents: diff changeset	882 #endif // #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	883
a61af66fc99e Initial load duke parents: diff changeset	884 private:
a61af66fc99e Initial load duke parents: diff changeset	885 // Closure accessors
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	886 static OopClosure* adjust_pointer_closure() { return (OopClosure*)&_adjust_pointer_closure; }
0 a61af66fc99e Initial load duke parents: diff changeset	887 static OopClosure* adjust_root_pointer_closure() { return (OopClosure*)&_adjust_root_pointer_closure; }
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	888 static BoolObjectClosure* is_alive_closure() { return (BoolObjectClosure*)&_is_alive_closure; }
0 a61af66fc99e Initial load duke parents: diff changeset	889
a61af66fc99e Initial load duke parents: diff changeset	890 static void initialize_space_info();
a61af66fc99e Initial load duke parents: diff changeset	891
a61af66fc99e Initial load duke parents: diff changeset	892 // Return true if details about individual phases should be printed.
a61af66fc99e Initial load duke parents: diff changeset	893 static inline bool print_phases();
a61af66fc99e Initial load duke parents: diff changeset	894
a61af66fc99e Initial load duke parents: diff changeset	895 // Clear the marking bitmap and summary data that cover the specified space.
a61af66fc99e Initial load duke parents: diff changeset	896 static void clear_data_covering_space(SpaceId id);
a61af66fc99e Initial load duke parents: diff changeset	897
a61af66fc99e Initial load duke parents: diff changeset	898 static void pre_compact(PreGCValues* pre_gc_values);
a61af66fc99e Initial load duke parents: diff changeset	899 static void post_compact();
a61af66fc99e Initial load duke parents: diff changeset	900
a61af66fc99e Initial load duke parents: diff changeset	901 // Mark live objects
a61af66fc99e Initial load duke parents: diff changeset	902 static void marking_phase(ParCompactionManager* cm,
a61af66fc99e Initial load duke parents: diff changeset	903 bool maximum_heap_compaction);
a61af66fc99e Initial load duke parents: diff changeset	904 static void follow_stack(ParCompactionManager* cm);
941 8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 579 diff changeset	905 static void follow_weak_klass_links();
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 579 diff changeset	906 static void follow_mdo_weak_refs();
0 a61af66fc99e Initial load duke parents: diff changeset	907
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	908 template <class T> static inline void adjust_pointer(T* p, bool is_root);
0 a61af66fc99e Initial load duke parents: diff changeset	909 static void adjust_root_pointer(oop* p) { adjust_pointer(p, true); }
a61af66fc99e Initial load duke parents: diff changeset	910
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	911 template <class T>
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	912 static inline void follow_root(ParCompactionManager* cm, T* p);
0 a61af66fc99e Initial load duke parents: diff changeset	913
a61af66fc99e Initial load duke parents: diff changeset	914 // Compute the dense prefix for the designated space. This is an experimental
a61af66fc99e Initial load duke parents: diff changeset	915 // implementation currently not used in production.
a61af66fc99e Initial load duke parents: diff changeset	916 static HeapWord* compute_dense_prefix_via_density(const SpaceId id,
a61af66fc99e Initial load duke parents: diff changeset	917 bool maximum_compaction);
a61af66fc99e Initial load duke parents: diff changeset	918
a61af66fc99e Initial load duke parents: diff changeset	919 // Methods used to compute the dense prefix.
a61af66fc99e Initial load duke parents: diff changeset	920
a61af66fc99e Initial load duke parents: diff changeset	921 // Compute the value of the normal distribution at x = density. The mean and
a61af66fc99e Initial load duke parents: diff changeset	922 // standard deviation are values saved by initialize_dead_wood_limiter().
a61af66fc99e Initial load duke parents: diff changeset	923 static inline double normal_distribution(double density);
a61af66fc99e Initial load duke parents: diff changeset	924
a61af66fc99e Initial load duke parents: diff changeset	925 // Initialize the static vars used by dead_wood_limiter().
a61af66fc99e Initial load duke parents: diff changeset	926 static void initialize_dead_wood_limiter();
a61af66fc99e Initial load duke parents: diff changeset	927
a61af66fc99e Initial load duke parents: diff changeset	928 // Return the percentage of space that can be treated as "dead wood" (i.e.,
a61af66fc99e Initial load duke parents: diff changeset	929 // not reclaimed).
a61af66fc99e Initial load duke parents: diff changeset	930 static double dead_wood_limiter(double density, size_t min_percent);
a61af66fc99e Initial load duke parents: diff changeset	931
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	932 // Find the first (left-most) region in the range [beg, end) that has at least
0 a61af66fc99e Initial load duke parents: diff changeset	933 // 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	934 // region in the space that is not completely live.
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	935 static RegionData* dead_wood_limit_region(const RegionData* beg,
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	936 const RegionData* end,
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	937 size_t dead_words);
0 a61af66fc99e Initial load duke parents: diff changeset	938
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	939 // Return a pointer to the first region in the range [beg, end) that is not
0 a61af66fc99e Initial load duke parents: diff changeset	940 // completely full.
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	941 static RegionData* first_dead_space_region(const RegionData* beg,
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	942 const RegionData* end);
0 a61af66fc99e Initial load duke parents: diff changeset	943
a61af66fc99e Initial load duke parents: diff changeset	944 // Return a value indicating the benefit or 'yield' if the compacted region
a61af66fc99e Initial load duke parents: diff changeset	945 // 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	946 // candidate region. Higher values are better.
0 a61af66fc99e Initial load duke parents: diff changeset	947 //
a61af66fc99e Initial load duke parents: diff changeset	948 // The value is based on the amount of space reclaimed vs. the costs of (a)
a61af66fc99e Initial load duke parents: diff changeset	949 // updating references in the dense prefix plus (b) copying objects and
a61af66fc99e Initial load duke parents: diff changeset	950 // updating references in the compacted region.
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	951 static inline double reclaimed_ratio(const RegionData* const candidate,
0 a61af66fc99e Initial load duke parents: diff changeset	952 HeapWord* const bottom,
a61af66fc99e Initial load duke parents: diff changeset	953 HeapWord* const top,
a61af66fc99e Initial load duke parents: diff changeset	954 HeapWord* const new_top);
a61af66fc99e Initial load duke parents: diff changeset	955
a61af66fc99e Initial load duke parents: diff changeset	956 // Compute the dense prefix for the designated space.
a61af66fc99e Initial load duke parents: diff changeset	957 static HeapWord* compute_dense_prefix(const SpaceId id,
a61af66fc99e Initial load duke parents: diff changeset	958 bool maximum_compaction);
a61af66fc99e Initial load duke parents: diff changeset	959
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	960 // 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	961 // 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	962 static inline bool dead_space_crosses_boundary(const RegionData* region,
0 a61af66fc99e Initial load duke parents: diff changeset	963 idx_t bit);
a61af66fc99e Initial load duke parents: diff changeset	964
a61af66fc99e Initial load duke parents: diff changeset	965 // Summary phase utility routine to fill dead space (if any) at the dense
a61af66fc99e Initial load duke parents: diff changeset	966 // prefix boundary. Should only be called if the the dense prefix is
a61af66fc99e Initial load duke parents: diff changeset	967 // non-empty.
a61af66fc99e Initial load duke parents: diff changeset	968 static void fill_dense_prefix_end(SpaceId id);
a61af66fc99e Initial load duke parents: diff changeset	969
482 7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	970 // 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	971 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	972
483 0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	973 #ifndef PRODUCT
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	974 // 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	975
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	976 // 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	977 // for the old and permanent generations.
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	978 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	979 size_t words);
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	980 // Include the new objects in the summary data.
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	981 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	982
496 b27c885f75f9 6786188: par compact - "SplitALot" stress mode should fill to_space jcoomes parents: 495 diff changeset	983 // 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	984 // are non-empty.
b27c885f75f9 6786188: par compact - "SplitALot" stress mode should fill to_space jcoomes parents: 495 diff changeset	985 static void provoke_split_fill_survivor(SpaceId id);
b27c885f75f9 6786188: par compact - "SplitALot" stress mode should fill to_space jcoomes parents: 495 diff changeset	986
483 0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	987 // 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	988 static void provoke_split(bool & maximum_compaction);
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	989 #endif
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 482 diff changeset	990
0 a61af66fc99e Initial load duke parents: diff changeset	991 static void summarize_spaces_quick();
a61af66fc99e Initial load duke parents: diff changeset	992 static void summarize_space(SpaceId id, bool maximum_compaction);
a61af66fc99e Initial load duke parents: diff changeset	993 static void summary_phase(ParCompactionManager* cm, bool maximum_compaction);
a61af66fc99e Initial load duke parents: diff changeset	994
a61af66fc99e Initial load duke parents: diff changeset	995 // Adjust addresses in roots. Does not adjust addresses in heap.
a61af66fc99e Initial load duke parents: diff changeset	996 static void adjust_roots();
a61af66fc99e Initial load duke parents: diff changeset	997
a61af66fc99e Initial load duke parents: diff changeset	998 // Serial code executed in preparation for the compaction phase.
a61af66fc99e Initial load duke parents: diff changeset	999 static void compact_prologue();
a61af66fc99e Initial load duke parents: diff changeset	1000
a61af66fc99e Initial load duke parents: diff changeset	1001 // Move objects to new locations.
a61af66fc99e Initial load duke parents: diff changeset	1002 static void compact_perm(ParCompactionManager* cm);
a61af66fc99e Initial load duke parents: diff changeset	1003 static void compact();
a61af66fc99e Initial load duke parents: diff changeset	1004
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1005 // 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	1006 static void enqueue_region_draining_tasks(GCTaskQueue* q,
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1007 uint parallel_gc_threads);
0 a61af66fc99e Initial load duke parents: diff changeset	1008
a61af66fc99e Initial load duke parents: diff changeset	1009 // Add dense prefix update tasks to the task queue.
a61af66fc99e Initial load duke parents: diff changeset	1010 static void enqueue_dense_prefix_tasks(GCTaskQueue* q,
a61af66fc99e Initial load duke parents: diff changeset	1011 uint parallel_gc_threads);
a61af66fc99e Initial load duke parents: diff changeset	1012
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1013 // Add region stealing tasks to the task queue.
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1014 static void enqueue_region_stealing_tasks(
0 a61af66fc99e Initial load duke parents: diff changeset	1015 GCTaskQueue* q,
a61af66fc99e Initial load duke parents: diff changeset	1016 ParallelTaskTerminator* terminator_ptr,
a61af66fc99e Initial load duke parents: diff changeset	1017 uint parallel_gc_threads);
a61af66fc99e Initial load duke parents: diff changeset	1018
a61af66fc99e Initial load duke parents: diff changeset	1019 // For debugging only - compacts the old gen serially
a61af66fc99e Initial load duke parents: diff changeset	1020 static void compact_serial(ParCompactionManager* cm);
a61af66fc99e Initial load duke parents: diff changeset	1021
a61af66fc99e Initial load duke parents: diff changeset	1022 // If objects are left in eden after a collection, try to move the boundary
a61af66fc99e Initial load duke parents: diff changeset	1023 // and absorb them into the old gen. Returns true if eden was emptied.
a61af66fc99e Initial load duke parents: diff changeset	1024 static bool absorb_live_data_from_eden(PSAdaptiveSizePolicy* size_policy,
a61af66fc99e Initial load duke parents: diff changeset	1025 PSYoungGen* young_gen,
a61af66fc99e Initial load duke parents: diff changeset	1026 PSOldGen* old_gen);
a61af66fc99e Initial load duke parents: diff changeset	1027
a61af66fc99e Initial load duke parents: diff changeset	1028 // Reset time since last full gc
a61af66fc99e Initial load duke parents: diff changeset	1029 static void reset_millis_since_last_gc();
a61af66fc99e Initial load duke parents: diff changeset	1030
a61af66fc99e Initial load duke parents: diff changeset	1031 protected:
a61af66fc99e Initial load duke parents: diff changeset	1032 #ifdef VALIDATE_MARK_SWEEP
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1033 static GrowableArray<void> _root_refs_stack;
0 a61af66fc99e Initial load duke parents: diff changeset	1034 static GrowableArray<oop> * _live_oops;
a61af66fc99e Initial load duke parents: diff changeset	1035 static GrowableArray<oop> * _live_oops_moved_to;
a61af66fc99e Initial load duke parents: diff changeset	1036 static GrowableArray<size_t>* _live_oops_size;
a61af66fc99e Initial load duke parents: diff changeset	1037 static size_t _live_oops_index;
a61af66fc99e Initial load duke parents: diff changeset	1038 static size_t _live_oops_index_at_perm;
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1039 static GrowableArray<void> _other_refs_stack;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1040 static GrowableArray<void> _adjusted_pointers;
0 a61af66fc99e Initial load duke parents: diff changeset	1041 static bool _pointer_tracking;
a61af66fc99e Initial load duke parents: diff changeset	1042 static bool _root_tracking;
a61af66fc99e Initial load duke parents: diff changeset	1043
a61af66fc99e Initial load duke parents: diff changeset	1044 // The following arrays are saved since the time of the last GC and
a61af66fc99e Initial load duke parents: diff changeset	1045 // assist in tracking down problems where someone has done an errant
a61af66fc99e Initial load duke parents: diff changeset	1046 // store into the heap, usually to an oop that wasn't properly
a61af66fc99e Initial load duke parents: diff changeset	1047 // handleized across a GC. If we crash or otherwise fail before the
a61af66fc99e Initial load duke parents: diff changeset	1048 // next GC, we can query these arrays to find out the object we had
a61af66fc99e Initial load duke parents: diff changeset	1049 // intended to do the store to (assuming it is still alive) and the
a61af66fc99e Initial load duke parents: diff changeset	1050 // offset within that object. Covered under RecordMarkSweepCompaction.
a61af66fc99e Initial load duke parents: diff changeset	1051 static GrowableArray<HeapWord> _cur_gc_live_oops;
a61af66fc99e Initial load duke parents: diff changeset	1052 static GrowableArray<HeapWord> _cur_gc_live_oops_moved_to;
a61af66fc99e Initial load duke parents: diff changeset	1053 static GrowableArray<size_t>* _cur_gc_live_oops_size;
a61af66fc99e Initial load duke parents: diff changeset	1054 static GrowableArray<HeapWord> _last_gc_live_oops;
a61af66fc99e Initial load duke parents: diff changeset	1055 static GrowableArray<HeapWord> _last_gc_live_oops_moved_to;
a61af66fc99e Initial load duke parents: diff changeset	1056 static GrowableArray<size_t>* _last_gc_live_oops_size;
a61af66fc99e Initial load duke parents: diff changeset	1057 #endif
a61af66fc99e Initial load duke parents: diff changeset	1058
a61af66fc99e Initial load duke parents: diff changeset	1059 public:
a61af66fc99e Initial load duke parents: diff changeset	1060 class MarkAndPushClosure: public OopClosure {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1061 private:
0 a61af66fc99e Initial load duke parents: diff changeset	1062 ParCompactionManager* _compaction_manager;
a61af66fc99e Initial load duke parents: diff changeset	1063 public:
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1064 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	1065 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	1066 virtual void do_oop(narrowOop* p);
0 a61af66fc99e Initial load duke parents: diff changeset	1067 };
a61af66fc99e Initial load duke parents: diff changeset	1068
a61af66fc99e Initial load duke parents: diff changeset	1069 PSParallelCompact();
a61af66fc99e Initial load duke parents: diff changeset	1070
a61af66fc99e Initial load duke parents: diff changeset	1071 // Convenient accessor for Universe::heap().
a61af66fc99e Initial load duke parents: diff changeset	1072 static ParallelScavengeHeap* gc_heap() {
a61af66fc99e Initial load duke parents: diff changeset	1073 return (ParallelScavengeHeap*)Universe::heap();
a61af66fc99e Initial load duke parents: diff changeset	1074 }
a61af66fc99e Initial load duke parents: diff changeset	1075
a61af66fc99e Initial load duke parents: diff changeset	1076 static void invoke(bool maximum_heap_compaction);
a61af66fc99e Initial load duke parents: diff changeset	1077 static void invoke_no_policy(bool maximum_heap_compaction);
a61af66fc99e Initial load duke parents: diff changeset	1078
a61af66fc99e Initial load duke parents: diff changeset	1079 static void post_initialize();
a61af66fc99e Initial load duke parents: diff changeset	1080 // Perform initialization for PSParallelCompact that requires
a61af66fc99e Initial load duke parents: diff changeset	1081 // allocations. This should be called during the VM initialization
a61af66fc99e Initial load duke parents: diff changeset	1082 // at a pointer where it would be appropriate to return a JNI_ENOMEM
a61af66fc99e Initial load duke parents: diff changeset	1083 // in the event of a failure.
a61af66fc99e Initial load duke parents: diff changeset	1084 static bool initialize();
a61af66fc99e Initial load duke parents: diff changeset	1085
a61af66fc99e Initial load duke parents: diff changeset	1086 // Public accessors
a61af66fc99e Initial load duke parents: diff changeset	1087 static elapsedTimer* accumulated_time() { return &_accumulated_time; }
a61af66fc99e Initial load duke parents: diff changeset	1088 static unsigned int total_invocations() { return _total_invocations; }
a61af66fc99e Initial load duke parents: diff changeset	1089 static CollectorCounters* counters() { return _counters; }
a61af66fc99e Initial load duke parents: diff changeset	1090
a61af66fc99e Initial load duke parents: diff changeset	1091 // Used to add tasks
a61af66fc99e Initial load duke parents: diff changeset	1092 static GCTaskManager* const gc_task_manager();
a61af66fc99e Initial load duke parents: diff changeset	1093 static klassOop updated_int_array_klass_obj() {
a61af66fc99e Initial load duke parents: diff changeset	1094 return _updated_int_array_klass_obj;
a61af66fc99e Initial load duke parents: diff changeset	1095 }
a61af66fc99e Initial load duke parents: diff changeset	1096
a61af66fc99e Initial load duke parents: diff changeset	1097 // Marking support
a61af66fc99e Initial load duke parents: diff changeset	1098 static inline bool mark_obj(oop obj);
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1099 // 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	1100 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	1101 T* p);
0 a61af66fc99e Initial load duke parents: diff changeset	1102
a61af66fc99e Initial load duke parents: diff changeset	1103 // Compaction support.
a61af66fc99e Initial load duke parents: diff changeset	1104 // Return true if p is in the range [beg_addr, end_addr).
a61af66fc99e Initial load duke parents: diff changeset	1105 static inline bool is_in(HeapWord* p, HeapWord* beg_addr, HeapWord* end_addr);
a61af66fc99e Initial load duke parents: diff changeset	1106 static inline bool is_in(oop* p, HeapWord* beg_addr, HeapWord* end_addr);
a61af66fc99e Initial load duke parents: diff changeset	1107
a61af66fc99e Initial load duke parents: diff changeset	1108 // Convenience wrappers for per-space data kept in _space_info.
a61af66fc99e Initial load duke parents: diff changeset	1109 static inline MutableSpace* space(SpaceId space_id);
a61af66fc99e Initial load duke parents: diff changeset	1110 static inline HeapWord* new_top(SpaceId space_id);
a61af66fc99e Initial load duke parents: diff changeset	1111 static inline HeapWord* dense_prefix(SpaceId space_id);
a61af66fc99e Initial load duke parents: diff changeset	1112 static inline ObjectStartArray* start_array(SpaceId space_id);
a61af66fc99e Initial load duke parents: diff changeset	1113
a61af66fc99e Initial load duke parents: diff changeset	1114 // Return true if the klass should be updated.
a61af66fc99e Initial load duke parents: diff changeset	1115 static inline bool should_update_klass(klassOop k);
a61af66fc99e Initial load duke parents: diff changeset	1116
a61af66fc99e Initial load duke parents: diff changeset	1117 // Move and update the live objects in the specified space.
a61af66fc99e Initial load duke parents: diff changeset	1118 static void move_and_update(ParCompactionManager* cm, SpaceId space_id);
a61af66fc99e Initial load duke parents: diff changeset	1119
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1120 // Process the end of the given region range in the dense prefix.
0 a61af66fc99e Initial load duke parents: diff changeset	1121 // This includes saving any object not updated.
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1122 static void dense_prefix_regions_epilogue(ParCompactionManager* cm,
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1123 size_t region_start_index,
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1124 size_t region_end_index,
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1125 idx_t exiting_object_offset,
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1126 idx_t region_offset_start,
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1127 idx_t region_offset_end);
0 a61af66fc99e Initial load duke parents: diff changeset	1128
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1129 // 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	1130 // in the region, update it's interior references. For each
0 a61af66fc99e Initial load duke parents: diff changeset	1131 // 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	1132 // 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	1133 // live object regardless of the region_index_end. None of the
0 a61af66fc99e Initial load duke parents: diff changeset	1134 // objects in the dense prefix move and dead space is dead
a61af66fc99e Initial load duke parents: diff changeset	1135 // (holds only dead objects that don't need any processing), so
a61af66fc99e Initial load duke parents: diff changeset	1136 // dead space can be filled in any order.
a61af66fc99e Initial load duke parents: diff changeset	1137 static void update_and_deadwood_in_dense_prefix(ParCompactionManager* cm,
a61af66fc99e Initial load duke parents: diff changeset	1138 SpaceId space_id,
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1139 size_t region_index_start,
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1140 size_t region_index_end);
0 a61af66fc99e Initial load duke parents: diff changeset	1141
a61af66fc99e Initial load duke parents: diff changeset	1142 // Return the address of the count + 1st live word in the range [beg, end).
a61af66fc99e Initial load duke parents: diff changeset	1143 static HeapWord* skip_live_words(HeapWord* beg, HeapWord* end, size_t count);
a61af66fc99e Initial load duke parents: diff changeset	1144
a61af66fc99e Initial load duke parents: diff changeset	1145 // 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	1146 // aligned to a region boundary.
0 a61af66fc99e Initial load duke parents: diff changeset	1147 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	1148 SpaceId src_space_id,
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1149 size_t src_region_idx);
0 a61af66fc99e Initial load duke parents: diff changeset	1150
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1151 // 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	1152 // new region return the region index. Parameter end_addr is the address one
0 a61af66fc99e Initial load duke parents: diff changeset	1153 // beyond the end of source range just processed. If necessary, switch to a
a61af66fc99e Initial load duke parents: diff changeset	1154 // new source space and set src_space_id (in-out parameter) and src_space_top
a61af66fc99e Initial load duke parents: diff changeset	1155 // (out parameter) accordingly.
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1156 static size_t next_src_region(MoveAndUpdateClosure& closure,
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1157 SpaceId& src_space_id,
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1158 HeapWord*& src_space_top,
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1159 HeapWord* end_addr);
0 a61af66fc99e Initial load duke parents: diff changeset	1160
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1161 // 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	1162 // 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	1163 // count for a region goes to 0 and it needs to be filled, enqueue it.
0 a61af66fc99e Initial load duke parents: diff changeset	1164 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	1165 SpaceId src_space_id,
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1166 size_t beg_region,
0 a61af66fc99e Initial load duke parents: diff changeset	1167 HeapWord* end_addr);
a61af66fc99e Initial load duke parents: diff changeset	1168
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1169 // 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	1170 static void fill_region(ParCompactionManager* cm, size_t region_idx);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1171 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	1172 fill_region(cm, region);
0 a61af66fc99e Initial load duke parents: diff changeset	1173 }
a61af66fc99e Initial load duke parents: diff changeset	1174
a61af66fc99e Initial load duke parents: diff changeset	1175 // Update the deferred objects in the space.
a61af66fc99e Initial load duke parents: diff changeset	1176 static void update_deferred_objects(ParCompactionManager* cm, SpaceId id);
a61af66fc99e Initial load duke parents: diff changeset	1177
a61af66fc99e Initial load duke parents: diff changeset	1178 // Mark pointer and follow contents.
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1179 template <class T>
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1180 static inline void mark_and_follow(ParCompactionManager* cm, T* p);
0 a61af66fc99e Initial load duke parents: diff changeset	1181
a61af66fc99e Initial load duke parents: diff changeset	1182 static ParMarkBitMap* mark_bitmap() { return &_mark_bitmap; }
a61af66fc99e Initial load duke parents: diff changeset	1183 static ParallelCompactData& summary_data() { return _summary_data; }
a61af66fc99e Initial load duke parents: diff changeset	1184
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1185 static inline void adjust_pointer(oop* p) { adjust_pointer(p, false); }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1186 static inline void adjust_pointer(narrowOop* p) { adjust_pointer(p, false); }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1187
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1188 template <class T>
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1189 static inline void adjust_pointer(T* p,
0 a61af66fc99e Initial load duke parents: diff changeset	1190 HeapWord* beg_addr,
a61af66fc99e Initial load duke parents: diff changeset	1191 HeapWord* end_addr);
a61af66fc99e Initial load duke parents: diff changeset	1192
a61af66fc99e Initial load duke parents: diff changeset	1193 // Reference Processing
a61af66fc99e Initial load duke parents: diff changeset	1194 static ReferenceProcessor* const ref_processor() { return _ref_processor; }
a61af66fc99e Initial load duke parents: diff changeset	1195
a61af66fc99e Initial load duke parents: diff changeset	1196 // Return the SpaceId for the given address.
a61af66fc99e Initial load duke parents: diff changeset	1197 static SpaceId space_id(HeapWord* addr);
a61af66fc99e Initial load duke parents: diff changeset	1198
a61af66fc99e Initial load duke parents: diff changeset	1199 // Time since last full gc (in milliseconds).
a61af66fc99e Initial load duke parents: diff changeset	1200 static jlong millis_since_last_gc();
a61af66fc99e Initial load duke parents: diff changeset	1201
a61af66fc99e Initial load duke parents: diff changeset	1202 #ifdef VALIDATE_MARK_SWEEP
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1203 static void track_adjusted_pointer(void* p, bool isroot);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1204 static void check_adjust_pointer(void* p);
0 a61af66fc99e Initial load duke parents: diff changeset	1205 static void track_interior_pointers(oop obj);
a61af66fc99e Initial load duke parents: diff changeset	1206 static void check_interior_pointers();
a61af66fc99e Initial load duke parents: diff changeset	1207
a61af66fc99e Initial load duke parents: diff changeset	1208 static void reset_live_oop_tracking(bool at_perm);
a61af66fc99e Initial load duke parents: diff changeset	1209 static void register_live_oop(oop p, size_t size);
a61af66fc99e Initial load duke parents: diff changeset	1210 static void validate_live_oop(oop p, size_t size);
a61af66fc99e Initial load duke parents: diff changeset	1211 static void live_oop_moved_to(HeapWord* q, size_t size, HeapWord* compaction_top);
a61af66fc99e Initial load duke parents: diff changeset	1212 static void compaction_complete();
a61af66fc99e Initial load duke parents: diff changeset	1213
a61af66fc99e Initial load duke parents: diff changeset	1214 // Querying operation of RecordMarkSweepCompaction results.
a61af66fc99e Initial load duke parents: diff changeset	1215 // Finds and prints the current base oop and offset for a word
a61af66fc99e Initial load duke parents: diff changeset	1216 // within an oop that was live during the last GC. Helpful for
a61af66fc99e Initial load duke parents: diff changeset	1217 // tracking down heap stomps.
a61af66fc99e Initial load duke parents: diff changeset	1218 static void print_new_location_of_heap_address(HeapWord* q);
a61af66fc99e Initial load duke parents: diff changeset	1219 #endif // #ifdef VALIDATE_MARK_SWEEP
a61af66fc99e Initial load duke parents: diff changeset	1220
a61af66fc99e Initial load duke parents: diff changeset	1221 // Call backs for class unloading
a61af66fc99e Initial load duke parents: diff changeset	1222 // Update subklass/sibling/implementor links at end of marking.
a61af66fc99e Initial load duke parents: diff changeset	1223 static void revisit_weak_klass_link(ParCompactionManager* cm, Klass* k);
a61af66fc99e Initial load duke parents: diff changeset	1224
941 8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 579 diff changeset	1225 // Clear unmarked oops in MDOs at the end of marking.
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 579 diff changeset	1226 static void revisit_mdo(ParCompactionManager* cm, DataLayout* p);
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 579 diff changeset	1227
0 a61af66fc99e Initial load duke parents: diff changeset	1228 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	1229 // Debugging support.
a61af66fc99e Initial load duke parents: diff changeset	1230 static const char* space_names[last_space_id];
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1231 static void print_region_ranges();
0 a61af66fc99e Initial load duke parents: diff changeset	1232 static void print_dense_prefix_stats(const char* const algorithm,
a61af66fc99e Initial load duke parents: diff changeset	1233 const SpaceId id,
a61af66fc99e Initial load duke parents: diff changeset	1234 const bool maximum_compaction,
a61af66fc99e Initial load duke parents: diff changeset	1235 HeapWord* const addr);
482 7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1236 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	1237 HeapWord* dst_beg, HeapWord* dst_end,
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1238 SpaceId src_space_id,
7c2386d67889 6765745: par compact - allow young gen spaces to be split jcoomes parents: 481 diff changeset	1239 HeapWord* src_beg, HeapWord* src_end);
0 a61af66fc99e Initial load duke parents: diff changeset	1240 #endif // #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	1241
a61af66fc99e Initial load duke parents: diff changeset	1242 #ifdef ASSERT
495 234c22e54b98 6784849: par compact - can fail when to_space is non-empty jcoomes parents: 483 diff changeset	1243 // 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	1244 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	1245 // Verify that all the regions have been emptied.
0 a61af66fc99e Initial load duke parents: diff changeset	1246 static void verify_complete(SpaceId space_id);
a61af66fc99e Initial load duke parents: diff changeset	1247 #endif // #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	1248 };
a61af66fc99e Initial load duke parents: diff changeset	1249
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1250 inline bool PSParallelCompact::mark_obj(oop obj) {
0 a61af66fc99e Initial load duke parents: diff changeset	1251 const int obj_size = obj->size();
a61af66fc99e Initial load duke parents: diff changeset	1252 if (mark_bitmap()->mark_obj(obj, obj_size)) {
a61af66fc99e Initial load duke parents: diff changeset	1253 _summary_data.add_obj(obj, obj_size);
a61af66fc99e Initial load duke parents: diff changeset	1254 return true;
a61af66fc99e Initial load duke parents: diff changeset	1255 } else {
a61af66fc99e Initial load duke parents: diff changeset	1256 return false;
a61af66fc99e Initial load duke parents: diff changeset	1257 }
a61af66fc99e Initial load duke parents: diff changeset	1258 }
a61af66fc99e Initial load duke parents: diff changeset	1259
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1260 template <class T>
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1261 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	1262 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	1263 "roots shouldn't be things within the heap");
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1264 #ifdef VALIDATE_MARK_SWEEP
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1265 if (ValidateMarkSweep) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1266 guarantee(!_root_refs_stack->contains(p), "should only be in here once");
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1267 _root_refs_stack->push(p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1268 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1269 #endif
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1270 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	1271 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	1272 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	1273 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	1274 if (mark_obj(obj)) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1275 obj->follow_contents(cm);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1276 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1277 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1278 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1279 follow_stack(cm);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1280 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1281
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1282 template <class T>
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1283 inline void PSParallelCompact::mark_and_follow(ParCompactionManager* cm,
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1284 T* p) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1285 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	1286 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	1287 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	1288 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	1289 if (mark_obj(obj)) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1290 obj->follow_contents(cm);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1291 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1292 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1293 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1294 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1295
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1296 template <class T>
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1297 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	1298 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	1299 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	1300 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	1301 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	1302 if (mark_obj(obj)) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1303 // This thread marked the object and owns the subsequent processing of it.
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1304 cm->save_for_scanning(obj);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1305 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1306 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1307 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1308 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1309
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1310 template <class T>
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1311 inline void PSParallelCompact::adjust_pointer(T* p, bool isroot) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1312 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	1313 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	1314 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	1315 oop new_obj = (oop)summary_data().calc_new_pointer(obj);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1316 assert(new_obj != NULL \|\| // is forwarding ptr?
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1317 obj->is_shared(), // never forwarded?
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1318 "should be forwarded");
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1319 // 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	1320 if (new_obj != NULL) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1321 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	1322 "should be in object space");
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1323 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	1324 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1325 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1326 VALIDATE_MARK_SWEEP_ONLY(track_adjusted_pointer(p, isroot));
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1327 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1328
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1329 template <class T>
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1330 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	1331 #ifdef VALIDATE_MARK_SWEEP
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1332 if (ValidateMarkSweep) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1333 if (!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	1334 _root_refs_stack->push(p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1335 } else {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1336 _other_refs_stack->push(p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1337 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1338 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1339 #endif
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1340 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	1341 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1342
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1343 inline bool PSParallelCompact::print_phases() {
0 a61af66fc99e Initial load duke parents: diff changeset	1344 return _print_phases;
a61af66fc99e Initial load duke parents: diff changeset	1345 }
a61af66fc99e Initial load duke parents: diff changeset	1346
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1347 inline double PSParallelCompact::normal_distribution(double density) {
0 a61af66fc99e Initial load duke parents: diff changeset	1348 assert(_dwl_initialized, "uninitialized");
a61af66fc99e Initial load duke parents: diff changeset	1349 const double squared_term = (density - _dwl_mean) / _dwl_std_dev;
a61af66fc99e Initial load duke parents: diff changeset	1350 return _dwl_first_term * exp(-0.5 * squared_term * squared_term);
a61af66fc99e Initial load duke parents: diff changeset	1351 }
a61af66fc99e Initial load duke parents: diff changeset	1352
a61af66fc99e Initial load duke parents: diff changeset	1353 inline bool
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1354 PSParallelCompact::dead_space_crosses_boundary(const RegionData* region,
0 a61af66fc99e Initial load duke parents: diff changeset	1355 idx_t bit)
a61af66fc99e Initial load duke parents: diff changeset	1356 {
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 269 diff changeset	1357 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	1358 assert(_summary_data.region_to_addr(region) == _mark_bitmap.bit_to_addr(bit),
0 a61af66fc99e Initial load duke parents: diff changeset	1359 "sanity check");
a61af66fc99e Initial load duke parents: diff changeset	1360
a61af66fc99e Initial load duke parents: diff changeset	1361 // 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	1362 // 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	1363 // 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	1364 return region->partial_obj_size() == 0 &&
0 a61af66fc99e Initial load duke parents: diff changeset	1365 !_mark_bitmap.is_obj_beg(bit) &&
a61af66fc99e Initial load duke parents: diff changeset	1366 !_mark_bitmap.is_obj_end(bit - 1);
a61af66fc99e Initial load duke parents: diff changeset	1367 }
a61af66fc99e Initial load duke parents: diff changeset	1368
a61af66fc99e Initial load duke parents: diff changeset	1369 inline bool
a61af66fc99e Initial load duke parents: diff changeset	1370 PSParallelCompact::is_in(HeapWord* p, HeapWord* beg_addr, HeapWord* end_addr) {
a61af66fc99e Initial load duke parents: diff changeset	1371 return p >= beg_addr && p < end_addr;
a61af66fc99e Initial load duke parents: diff changeset	1372 }
a61af66fc99e Initial load duke parents: diff changeset	1373
a61af66fc99e Initial load duke parents: diff changeset	1374 inline bool
a61af66fc99e Initial load duke parents: diff changeset	1375 PSParallelCompact::is_in(oop* p, HeapWord* beg_addr, HeapWord* end_addr) {
a61af66fc99e Initial load duke parents: diff changeset	1376 return is_in((HeapWord*)p, beg_addr, end_addr);
a61af66fc99e Initial load duke parents: diff changeset	1377 }
a61af66fc99e Initial load duke parents: diff changeset	1378
a61af66fc99e Initial load duke parents: diff changeset	1379 inline MutableSpace* PSParallelCompact::space(SpaceId id) {
a61af66fc99e Initial load duke parents: diff changeset	1380 assert(id < last_space_id, "id out of range");
a61af66fc99e Initial load duke parents: diff changeset	1381 return _space_info[id].space();
a61af66fc99e Initial load duke parents: diff changeset	1382 }
a61af66fc99e Initial load duke parents: diff changeset	1383
a61af66fc99e Initial load duke parents: diff changeset	1384 inline HeapWord* PSParallelCompact::new_top(SpaceId id) {
a61af66fc99e Initial load duke parents: diff changeset	1385 assert(id < last_space_id, "id out of range");
a61af66fc99e Initial load duke parents: diff changeset	1386 return _space_info[id].new_top();
a61af66fc99e Initial load duke parents: diff changeset	1387 }
a61af66fc99e Initial load duke parents: diff changeset	1388
a61af66fc99e Initial load duke parents: diff changeset	1389 inline HeapWord* PSParallelCompact::dense_prefix(SpaceId id) {
a61af66fc99e Initial load duke parents: diff changeset	1390 assert(id < last_space_id, "id out of range");
a61af66fc99e Initial load duke parents: diff changeset	1391 return _space_info[id].dense_prefix();
a61af66fc99e Initial load duke parents: diff changeset	1392 }
a61af66fc99e Initial load duke parents: diff changeset	1393
a61af66fc99e Initial load duke parents: diff changeset	1394 inline ObjectStartArray* PSParallelCompact::start_array(SpaceId id) {
a61af66fc99e Initial load duke parents: diff changeset	1395 assert(id < last_space_id, "id out of range");
a61af66fc99e Initial load duke parents: diff changeset	1396 return _space_info[id].start_array();
a61af66fc99e Initial load duke parents: diff changeset	1397 }
a61af66fc99e Initial load duke parents: diff changeset	1398
a61af66fc99e Initial load duke parents: diff changeset	1399 inline bool PSParallelCompact::should_update_klass(klassOop k) {
a61af66fc99e Initial load duke parents: diff changeset	1400 return ((HeapWord*) k) >= dense_prefix(perm_space_id);
a61af66fc99e Initial load duke parents: diff changeset	1401 }
a61af66fc99e Initial load duke parents: diff changeset	1402
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1403 template <class T>
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1404 inline void PSParallelCompact::adjust_pointer(T* p,
0 a61af66fc99e Initial load duke parents: diff changeset	1405 HeapWord* beg_addr,
a61af66fc99e Initial load duke parents: diff changeset	1406 HeapWord* end_addr) {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1407 if (is_in((HeapWord*)p, beg_addr, end_addr)) {
0 a61af66fc99e Initial load duke parents: diff changeset	1408 adjust_pointer(p);
a61af66fc99e Initial load duke parents: diff changeset	1409 }
a61af66fc99e Initial load duke parents: diff changeset	1410 }
a61af66fc99e Initial load duke parents: diff changeset	1411
495 234c22e54b98 6784849: par compact - can fail when to_space is non-empty jcoomes parents: 483 diff changeset	1412 #ifdef ASSERT
234c22e54b98 6784849: par compact - can fail when to_space is non-empty jcoomes parents: 483 diff changeset	1413 inline void
234c22e54b98 6784849: par compact - can fail when to_space is non-empty jcoomes parents: 483 diff changeset	1414 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	1415 {
234c22e54b98 6784849: par compact - can fail when to_space is non-empty jcoomes parents: 483 diff changeset	1416 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	1417 "must move left or to a different space");
234c22e54b98 6784849: par compact - can fail when to_space is non-empty jcoomes parents: 483 diff changeset	1418 }
234c22e54b98 6784849: par compact - can fail when to_space is non-empty jcoomes parents: 483 diff changeset	1419 #endif // ASSERT
234c22e54b98 6784849: par compact - can fail when to_space is non-empty jcoomes parents: 483 diff changeset	1420
0 a61af66fc99e Initial load duke parents: diff changeset	1421 class MoveAndUpdateClosure: public ParMarkBitMapClosure {
a61af66fc99e Initial load duke parents: diff changeset	1422 public:
a61af66fc99e Initial load duke parents: diff changeset	1423 inline MoveAndUpdateClosure(ParMarkBitMap* bitmap, ParCompactionManager* cm,
a61af66fc99e Initial load duke parents: diff changeset	1424 ObjectStartArray* start_array,
a61af66fc99e Initial load duke parents: diff changeset	1425 HeapWord* destination, size_t words);
a61af66fc99e Initial load duke parents: diff changeset	1426
a61af66fc99e Initial load duke parents: diff changeset	1427 // Accessors.
a61af66fc99e Initial load duke parents: diff changeset	1428 HeapWord* destination() const { return _destination; }
a61af66fc99e Initial load duke parents: diff changeset	1429
a61af66fc99e Initial load duke parents: diff changeset	1430 // If the object will fit (size <= words_remaining()), copy it to the current
a61af66fc99e Initial load duke parents: diff changeset	1431 // destination, update the interior oops and the start array and return either
a61af66fc99e Initial load duke parents: diff changeset	1432 // full (if the closure is full) or incomplete. If the object will not fit,
a61af66fc99e Initial load duke parents: diff changeset	1433 // return would_overflow.
a61af66fc99e Initial load duke parents: diff changeset	1434 virtual IterationStatus do_addr(HeapWord* addr, size_t size);
a61af66fc99e Initial load duke parents: diff changeset	1435
a61af66fc99e Initial load duke parents: diff changeset	1436 // Copy enough words to fill this closure, starting at source(). Interior
a61af66fc99e Initial load duke parents: diff changeset	1437 // oops and the start array are not updated. Return full.
a61af66fc99e Initial load duke parents: diff changeset	1438 IterationStatus copy_until_full();
a61af66fc99e Initial load duke parents: diff changeset	1439
a61af66fc99e Initial load duke parents: diff changeset	1440 // Copy enough words to fill this closure or to the end of an object,
a61af66fc99e Initial load duke parents: diff changeset	1441 // whichever is smaller, starting at source(). Interior oops and the start
a61af66fc99e Initial load duke parents: diff changeset	1442 // array are not updated.
a61af66fc99e Initial load duke parents: diff changeset	1443 void copy_partial_obj();
a61af66fc99e Initial load duke parents: diff changeset	1444
a61af66fc99e Initial load duke parents: diff changeset	1445 protected:
a61af66fc99e Initial load duke parents: diff changeset	1446 // Update variables to indicate that word_count words were processed.
a61af66fc99e Initial load duke parents: diff changeset	1447 inline void update_state(size_t word_count);
a61af66fc99e Initial load duke parents: diff changeset	1448
a61af66fc99e Initial load duke parents: diff changeset	1449 protected:
a61af66fc99e Initial load duke parents: diff changeset	1450 ObjectStartArray* const _start_array;
a61af66fc99e Initial load duke parents: diff changeset	1451 HeapWord* _destination; // Next addr to be written.
a61af66fc99e Initial load duke parents: diff changeset	1452 };
a61af66fc99e Initial load duke parents: diff changeset	1453
a61af66fc99e Initial load duke parents: diff changeset	1454 inline
a61af66fc99e Initial load duke parents: diff changeset	1455 MoveAndUpdateClosure::MoveAndUpdateClosure(ParMarkBitMap* bitmap,
a61af66fc99e Initial load duke parents: diff changeset	1456 ParCompactionManager* cm,
a61af66fc99e Initial load duke parents: diff changeset	1457 ObjectStartArray* start_array,
a61af66fc99e Initial load duke parents: diff changeset	1458 HeapWord* destination,
a61af66fc99e Initial load duke parents: diff changeset	1459 size_t words) :
a61af66fc99e Initial load duke parents: diff changeset	1460 ParMarkBitMapClosure(bitmap, cm, words), _start_array(start_array)
a61af66fc99e Initial load duke parents: diff changeset	1461 {
a61af66fc99e Initial load duke parents: diff changeset	1462 _destination = destination;
a61af66fc99e Initial load duke parents: diff changeset	1463 }
a61af66fc99e Initial load duke parents: diff changeset	1464
a61af66fc99e Initial load duke parents: diff changeset	1465 inline void MoveAndUpdateClosure::update_state(size_t words)
a61af66fc99e Initial load duke parents: diff changeset	1466 {
a61af66fc99e Initial load duke parents: diff changeset	1467 decrement_words_remaining(words);
a61af66fc99e Initial load duke parents: diff changeset	1468 _source += words;
a61af66fc99e Initial load duke parents: diff changeset	1469 _destination += words;
a61af66fc99e Initial load duke parents: diff changeset	1470 }
a61af66fc99e Initial load duke parents: diff changeset	1471
a61af66fc99e Initial load duke parents: diff changeset	1472 class UpdateOnlyClosure: public ParMarkBitMapClosure {
a61af66fc99e Initial load duke parents: diff changeset	1473 private:
a61af66fc99e Initial load duke parents: diff changeset	1474 const PSParallelCompact::SpaceId _space_id;
a61af66fc99e Initial load duke parents: diff changeset	1475 ObjectStartArray* const _start_array;
a61af66fc99e Initial load duke parents: diff changeset	1476
a61af66fc99e Initial load duke parents: diff changeset	1477 public:
a61af66fc99e Initial load duke parents: diff changeset	1478 UpdateOnlyClosure(ParMarkBitMap* mbm,
a61af66fc99e Initial load duke parents: diff changeset	1479 ParCompactionManager* cm,
a61af66fc99e Initial load duke parents: diff changeset	1480 PSParallelCompact::SpaceId space_id);
a61af66fc99e Initial load duke parents: diff changeset	1481
a61af66fc99e Initial load duke parents: diff changeset	1482 // Update the object.
a61af66fc99e Initial load duke parents: diff changeset	1483 virtual IterationStatus do_addr(HeapWord* addr, size_t words);
a61af66fc99e Initial load duke parents: diff changeset	1484
a61af66fc99e Initial load duke parents: diff changeset	1485 inline void do_addr(HeapWord* addr);
a61af66fc99e Initial load duke parents: diff changeset	1486 };
a61af66fc99e Initial load duke parents: diff changeset	1487
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1488 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	1489 {
0 a61af66fc99e Initial load duke parents: diff changeset	1490 _start_array->allocate_block(addr);
a61af66fc99e Initial load duke parents: diff changeset	1491 oop(addr)->update_contents(compaction_manager());
a61af66fc99e Initial load duke parents: diff changeset	1492 }
a61af66fc99e Initial load duke parents: diff changeset	1493
481 7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 376 diff changeset	1494 class FillClosure: public ParMarkBitMapClosure
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 376 diff changeset	1495 {
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 376 diff changeset	1496 public:
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	1497 FillClosure(ParCompactionManager* cm, PSParallelCompact::SpaceId space_id) :
0 a61af66fc99e Initial load duke parents: diff changeset	1498 ParMarkBitMapClosure(PSParallelCompact::mark_bitmap(), cm),
481 7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 376 diff changeset	1499 _start_array(PSParallelCompact::start_array(space_id))
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 376 diff changeset	1500 {
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 376 diff changeset	1501 assert(space_id == PSParallelCompact::perm_space_id \|\|
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 376 diff changeset	1502 space_id == PSParallelCompact::old_space_id,
0 a61af66fc99e Initial load duke parents: diff changeset	1503 "cannot use FillClosure in the young gen");
a61af66fc99e Initial load duke parents: diff changeset	1504 }
a61af66fc99e Initial load duke parents: diff changeset	1505
a61af66fc99e Initial load duke parents: diff changeset	1506 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	1507 CollectedHeap::fill_with_objects(addr, size);
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 376 diff changeset	1508 HeapWord* const end = addr + size;
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 376 diff changeset	1509 do {
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 376 diff changeset	1510 _start_array->allocate_block(addr);
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 376 diff changeset	1511 addr += oop(addr)->size();
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 376 diff changeset	1512 } while (addr < end);
0 a61af66fc99e Initial load duke parents: diff changeset	1513 return ParMarkBitMap::incomplete;
a61af66fc99e Initial load duke parents: diff changeset	1514 }
a61af66fc99e Initial load duke parents: diff changeset	1515
a61af66fc99e Initial load duke parents: diff changeset	1516 private:
481 7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 376 diff changeset	1517 ObjectStartArray* const _start_array;
0 a61af66fc99e Initial load duke parents: diff changeset	1518 };

Mercurial > hg > graal-compiler

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