Mercurial > hg > graal-compiler
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 | 1 /* |
579 | 2 * Copyright 2005-2009 Sun Microsystems, Inc. All Rights Reserved. |
0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
4 * | |
5 * This code is free software; you can redistribute it and/or modify it | |
6 * under the terms of the GNU General Public License version 2 only, as | |
7 * published by the Free Software Foundation. | |
8 * | |
9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
12 * version 2 for more details (a copy is included in the LICENSE file that | |
13 * accompanied this code). | |
14 * | |
15 * You should have received a copy of the GNU General Public License version | |
16 * 2 along with this work; if not, write to the Free Software Foundation, | |
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
18 * | |
19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, | |
20 * CA 95054 USA or visit www.sun.com if you need additional information or | |
21 * have any questions. | |
22 * | |
23 */ | |
24 | |
25 class ParallelScavengeHeap; | |
26 class PSAdaptiveSizePolicy; | |
27 class PSYoungGen; | |
28 class PSOldGen; | |
29 class PSPermGen; | |
30 class ParCompactionManager; | |
31 class ParallelTaskTerminator; | |
32 class PSParallelCompact; | |
33 class GCTaskManager; | |
34 class GCTaskQueue; | |
35 class PreGCValues; | |
36 class MoveAndUpdateClosure; | |
37 class RefProcTaskExecutor; | |
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 | 156 class SpaceInfo |
157 { | |
158 public: | |
159 MutableSpace* space() const { return _space; } | |
160 | |
161 // Where the free space will start after the collection. Valid only after the | |
162 // summary phase completes. | |
163 HeapWord* new_top() const { return _new_top; } | |
164 | |
165 // Allows new_top to be set. | |
166 HeapWord** new_top_addr() { return &_new_top; } | |
167 | |
168 // Where the smallest allowable dense prefix ends (used only for perm gen). | |
169 HeapWord* min_dense_prefix() const { return _min_dense_prefix; } | |
170 | |
171 // Where the dense prefix ends, or the compacted region begins. | |
172 HeapWord* dense_prefix() const { return _dense_prefix; } | |
173 | |
174 // The start array for the (generation containing the) space, or NULL if there | |
175 // is no start array. | |
176 ObjectStartArray* start_array() const { return _start_array; } | |
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 | 180 void set_space(MutableSpace* s) { _space = s; } |
181 void set_new_top(HeapWord* addr) { _new_top = addr; } | |
182 void set_min_dense_prefix(HeapWord* addr) { _min_dense_prefix = addr; } | |
183 void set_dense_prefix(HeapWord* addr) { _dense_prefix = addr; } | |
184 void set_start_array(ObjectStartArray* s) { _start_array = s; } | |
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 | 188 private: |
189 MutableSpace* _space; | |
190 HeapWord* _new_top; | |
191 HeapWord* _min_dense_prefix; | |
192 HeapWord* _dense_prefix; | |
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 | 195 }; |
196 | |
197 class ParallelCompactData | |
198 { | |
199 public: | |
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 | 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 | 211 |
375
81cd571500b0
6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents:
269
diff
changeset
|
212 class RegionData |
0 | 213 { |
214 public: | |
375
81cd571500b0
6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents:
269
diff
changeset
|
215 // Destination address of the region. |
0 | 216 HeapWord* destination() const { return _destination; } |
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 | 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 | 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 | 225 // time, so the same field is used to save space. |
226 HeapWord* deferred_obj_addr() const { return _partial_obj_addr; } | |
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 | 229 HeapWord* partial_obj_addr() const { return _partial_obj_addr; } |
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 | 232 size_t partial_obj_size() const { return _partial_obj_size; } |
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 | 238 size_t live_obj_size() const { return _dc_and_los & los_mask; } |
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 | 241 size_t data_size() const { return partial_obj_size() + live_obj_size(); } |
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 | 245 // values of destination_count are |
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 | 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 | 254 // decremented (atomically) and when it reaches 0, it can be claimed and |
255 // then filled. | |
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 | 259 // been filled, the destination_count should be set to the completed value |
260 // (dc_completed). | |
261 inline uint destination_count() const; | |
262 inline uint destination_count_raw() const; | |
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 | 265 inline HeapWord* data_location() const; |
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 | 268 inline HeapWord* highest_ref() const; |
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 | 271 // been completed. |
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 | 275 // can be completed. |
276 bool available() const { return _dc_and_los < dc_one; } | |
277 bool claimed() const { return _dc_and_los >= dc_claimed; } | |
278 bool completed() const { return _dc_and_los >= dc_completed; } | |
279 | |
280 // These are not atomic. | |
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 | 283 void set_deferred_obj_addr(HeapWord* addr) { _partial_obj_addr = addr; } |
284 void set_partial_obj_addr(HeapWord* addr) { _partial_obj_addr = addr; } | |
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 | 287 } |
288 | |
289 inline void set_destination_count(uint count); | |
290 inline void set_live_obj_size(size_t words); | |
291 inline void set_data_location(HeapWord* addr); | |
292 inline void set_completed(); | |
293 inline bool claim_unsafe(); | |
294 | |
295 // These are atomic. | |
296 inline void add_live_obj(size_t words); | |
297 inline void set_highest_ref(HeapWord* addr); | |
298 inline void decrement_destination_count(); | |
299 inline bool claim(); | |
300 | |
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 | 304 |
305 // Constants for manipulating the _dc_and_los field, which holds both the | |
306 // destination count and live obj size. The live obj size lives at the | |
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 | 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 | 320 #ifdef ASSERT |
321 // These enable optimizations that are only partially implemented. Use | |
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 | 325 #endif // #ifdef ASSERT |
326 | |
327 #ifdef ASSERT | |
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 | 330 private: |
331 #endif | |
332 }; | |
333 | |
334 public: | |
335 ParallelCompactData(); | |
336 bool initialize(MemRegion covered_region); | |
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 | 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 | 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 | 346 |
347 void add_obj(HeapWord* addr, size_t len); | |
348 void add_obj(oop p, size_t len) { add_obj((HeapWord*)p, len); } | |
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 | 353 void summarize_dense_prefix(HeapWord* beg, HeapWord* end); |
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 | 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 | 363 |
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 | 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 | 368 } |
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 | 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 | 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 | 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 | 384 |
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 | 387 |
388 // Return the new location of the object p after the | |
389 // the compaction. | |
390 HeapWord* calc_new_pointer(HeapWord* addr); | |
391 | |
392 HeapWord* calc_new_pointer(oop p) { | |
393 return calc_new_pointer((HeapWord*) p); | |
394 } | |
395 | |
396 // Return the updated address for the given klass | |
397 klassOop calc_new_klass(klassOop); | |
398 | |
399 #ifdef ASSERT | |
400 void verify_clear(const PSVirtualSpace* vspace); | |
401 void verify_clear(); | |
402 #endif // #ifdef ASSERT | |
403 | |
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 | 406 PSVirtualSpace* create_vspace(size_t count, size_t element_size); |
407 | |
408 private: | |
409 HeapWord* _region_start; | |
410 #ifdef ASSERT | |
411 HeapWord* _region_end; | |
412 #endif // #ifdef ASSERT | |
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 | 417 }; |
418 | |
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 | 421 { |
422 return _dc_and_los & dc_mask; | |
423 } | |
424 | |
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 | 427 { |
428 return destination_count_raw() >> dc_shift; | |
429 } | |
430 | |
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 | 433 { |
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 | 436 _dc_and_los = (count << dc_shift) | live_sz; |
437 } | |
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 | 440 { |
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 | 443 } |
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 | 446 { |
447 assert(_dc_and_los < dc_claimed, "already claimed"); | |
448 assert(_dc_and_los >= dc_one, "count would go negative"); | |
449 Atomic::add((int)dc_mask, (volatile int*)&_dc_and_los); | |
450 } | |
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 | 453 { |
454 DEBUG_ONLY(return _data_location;) | |
455 NOT_DEBUG(return NULL;) | |
456 } | |
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 | 459 { |
460 DEBUG_ONLY(return _highest_ref;) | |
461 NOT_DEBUG(return NULL;) | |
462 } | |
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 | 465 { |
466 DEBUG_ONLY(_data_location = addr;) | |
467 } | |
468 | |
375
81cd571500b0
6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents:
269
diff
changeset
|
469 inline void ParallelCompactData::RegionData::set_completed() |
0 | 470 { |
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 | 473 } |
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 | 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 | 478 { |
479 if (available()) { | |
480 _dc_and_los |= dc_claimed; | |
481 return true; | |
482 } | |
483 return false; | |
484 } | |
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 | 487 { |
488 assert(words <= (size_t)los_mask - live_obj_size(), "overflow"); | |
489 Atomic::add((int) words, (volatile int*) &_dc_and_los); | |
490 } | |
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 | 493 { |
494 #ifdef ASSERT | |
495 HeapWord* tmp = _highest_ref; | |
496 while (addr > tmp) { | |
497 tmp = (HeapWord*)Atomic::cmpxchg_ptr(addr, &_highest_ref, tmp); | |
498 } | |
499 #endif // #ifdef ASSERT | |
500 } | |
501 | |
375
81cd571500b0
6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents:
269
diff
changeset
|
502 inline bool ParallelCompactData::RegionData::claim() |
0 | 503 { |
504 const int los = (int) live_obj_size(); | |
505 const int old = Atomic::cmpxchg(dc_claimed | los, | |
506 (volatile int*) &_dc_and_los, los); | |
507 return old == los; | |
508 } | |
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 | 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 | 515 } |
516 | |
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 | 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 | 523 } |
524 | |
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 | 527 { |
528 assert(addr >= _region_start, "bad addr"); | |
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 | 531 } |
532 | |
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 | 535 { |
536 assert(addr >= _region_start, "bad addr"); | |
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 | 539 } |
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 | 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 | 545 } |
546 | |
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 | 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 | 552 } |
553 | |
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 | 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 | 559 } |
560 | |
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 | 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 | 567 } |
568 | |
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 | 571 { |
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 | 575 } |
576 | |
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 | 579 { |
580 assert(addr >= _region_start, "bad addr"); | |
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 | 583 } |
584 | |
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 | 587 { |
375
81cd571500b0
6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents:
269
diff
changeset
|
588 return region_offset(addr) == 0; |
0 | 589 } |
590 | |
591 // Abstract closure for use with ParMarkBitMap::iterate(), which will invoke the | |
592 // do_addr() method. | |
593 // | |
594 // The closure is initialized with the number of heap words to process | |
595 // (words_remaining()), and becomes 'full' when it reaches 0. The do_addr() | |
596 // methods in subclasses should update the total as words are processed. Since | |
597 // only one subclass actually uses this mechanism to terminate iteration, the | |
598 // default initial value is > 0. The implementation is here and not in the | |
599 // single subclass that uses it to avoid making is_full() virtual, and thus | |
600 // adding a virtual call per live object. | |
601 | |
602 class ParMarkBitMapClosure: public StackObj { | |
603 public: | |
604 typedef ParMarkBitMap::idx_t idx_t; | |
605 typedef ParMarkBitMap::IterationStatus IterationStatus; | |
606 | |
607 public: | |
608 inline ParMarkBitMapClosure(ParMarkBitMap* mbm, ParCompactionManager* cm, | |
609 size_t words = max_uintx); | |
610 | |
611 inline ParCompactionManager* compaction_manager() const; | |
612 inline ParMarkBitMap* bitmap() const; | |
613 inline size_t words_remaining() const; | |
614 inline bool is_full() const; | |
615 inline HeapWord* source() const; | |
616 | |
617 inline void set_source(HeapWord* addr); | |
618 | |
619 virtual IterationStatus do_addr(HeapWord* addr, size_t words) = 0; | |
620 | |
621 protected: | |
622 inline void decrement_words_remaining(size_t words); | |
623 | |
624 private: | |
625 ParMarkBitMap* const _bitmap; | |
626 ParCompactionManager* const _compaction_manager; | |
627 DEBUG_ONLY(const size_t _initial_words_remaining;) // Useful in debugger. | |
628 size_t _words_remaining; // Words left to copy. | |
629 | |
630 protected: | |
631 HeapWord* _source; // Next addr that would be read. | |
632 }; | |
633 | |
634 inline | |
635 ParMarkBitMapClosure::ParMarkBitMapClosure(ParMarkBitMap* bitmap, | |
636 ParCompactionManager* cm, | |
637 size_t words): | |
638 _bitmap(bitmap), _compaction_manager(cm) | |
639 #ifdef ASSERT | |
640 , _initial_words_remaining(words) | |
641 #endif | |
642 { | |
643 _words_remaining = words; | |
644 _source = NULL; | |
645 } | |
646 | |
647 inline ParCompactionManager* ParMarkBitMapClosure::compaction_manager() const { | |
648 return _compaction_manager; | |
649 } | |
650 | |
651 inline ParMarkBitMap* ParMarkBitMapClosure::bitmap() const { | |
652 return _bitmap; | |
653 } | |
654 | |
655 inline size_t ParMarkBitMapClosure::words_remaining() const { | |
656 return _words_remaining; | |
657 } | |
658 | |
659 inline bool ParMarkBitMapClosure::is_full() const { | |
660 return words_remaining() == 0; | |
661 } | |
662 | |
663 inline HeapWord* ParMarkBitMapClosure::source() const { | |
664 return _source; | |
665 } | |
666 | |
667 inline void ParMarkBitMapClosure::set_source(HeapWord* addr) { | |
668 _source = addr; | |
669 } | |
670 | |
671 inline void ParMarkBitMapClosure::decrement_words_remaining(size_t words) { | |
672 assert(_words_remaining >= words, "processed too many words"); | |
673 _words_remaining -= words; | |
674 } | |
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 | 763 class PSParallelCompact : AllStatic { |
764 public: | |
765 // Convenient access to type names. | |
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 | 768 |
769 typedef enum { | |
770 perm_space_id, old_space_id, eden_space_id, | |
771 from_space_id, to_space_id, last_space_id | |
772 } SpaceId; | |
773 | |
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 | 776 // |
777 class IsAliveClosure: public BoolObjectClosure { | |
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 | 781 }; |
782 | |
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 | 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 | 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 | 792 }; |
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 | 797 ParCompactionManager* _compaction_manager; |
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 | 803 |
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 | 806 ParCompactionManager* _compaction_manager; |
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 | 810 }; |
811 | |
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 | 814 bool _is_root; |
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 | 821 }; |
822 | |
823 // Closure for verifying update of pointers. Does not | |
824 // have any side effects. | |
825 class VerifyUpdateClosure: public ParMarkBitMapClosure { | |
826 const MutableSpace* _space; // Is this ever used? | |
827 | |
828 public: | |
829 VerifyUpdateClosure(ParCompactionManager* cm, const MutableSpace* sp) : | |
830 ParMarkBitMapClosure(PSParallelCompact::mark_bitmap(), cm), _space(sp) | |
831 { } | |
832 | |
833 virtual IterationStatus do_addr(HeapWord* addr, size_t words); | |
834 | |
835 const MutableSpace* space() { return _space; } | |
836 }; | |
837 | |
838 // Closure for updating objects altered for debug checking | |
839 class ResetObjectsClosure: public ParMarkBitMapClosure { | |
840 public: | |
841 ResetObjectsClosure(ParCompactionManager* cm): | |
842 ParMarkBitMapClosure(PSParallelCompact::mark_bitmap(), cm) | |
843 { } | |
844 | |
845 virtual IterationStatus do_addr(HeapWord* addr, size_t words); | |
846 }; | |
847 | |
848 friend class KeepAliveClosure; | |
849 friend class FollowStackClosure; | |
850 friend class AdjustPointerClosure; | |
851 friend class FollowRootClosure; | |
852 friend class instanceKlassKlass; | |
853 friend class RefProcTaskProxy; | |
854 | |
855 private: | |
856 static elapsedTimer _accumulated_time; | |
857 static unsigned int _total_invocations; | |
858 static unsigned int _maximum_compaction_gc_num; | |
859 static jlong _time_of_last_gc; // ms | |
860 static CollectorCounters* _counters; | |
861 static ParMarkBitMap _mark_bitmap; | |
862 static ParallelCompactData _summary_data; | |
863 static IsAliveClosure _is_alive_closure; | |
864 static SpaceInfo _space_info[last_space_id]; | |
865 static bool _print_phases; | |
866 static AdjustPointerClosure _adjust_root_pointer_closure; | |
867 static AdjustPointerClosure _adjust_pointer_closure; | |
868 | |
869 // Reference processing (used in ...follow_contents) | |
870 static ReferenceProcessor* _ref_processor; | |
871 | |
872 // Updated location of intArrayKlassObj. | |
873 static klassOop _updated_int_array_klass_obj; | |
874 | |
875 // Values computed at initialization and used by dead_wood_limiter(). | |
876 static double _dwl_mean; | |
877 static double _dwl_std_dev; | |
878 static double _dwl_first_term; | |
879 static double _dwl_adjustment; | |
880 #ifdef ASSERT | |
881 static bool _dwl_initialized; | |
882 #endif // #ifdef ASSERT | |
883 | |
884 private: | |
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 | 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 | 889 |
890 static void initialize_space_info(); | |
891 | |
892 // Return true if details about individual phases should be printed. | |
893 static inline bool print_phases(); | |
894 | |
895 // Clear the marking bitmap and summary data that cover the specified space. | |
896 static void clear_data_covering_space(SpaceId id); | |
897 | |
898 static void pre_compact(PreGCValues* pre_gc_values); | |
899 static void post_compact(); | |
900 | |
901 // Mark live objects | |
902 static void marking_phase(ParCompactionManager* cm, | |
903 bool maximum_heap_compaction); | |
904 static void follow_stack(ParCompactionManager* cm); | |
941 | 905 static void follow_weak_klass_links(); |
906 static void follow_mdo_weak_refs(); | |
0 | 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 | 909 static void adjust_root_pointer(oop* p) { adjust_pointer(p, true); } |
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 | 913 |
914 // Compute the dense prefix for the designated space. This is an experimental | |
915 // implementation currently not used in production. | |
916 static HeapWord* compute_dense_prefix_via_density(const SpaceId id, | |
917 bool maximum_compaction); | |
918 | |
919 // Methods used to compute the dense prefix. | |
920 | |
921 // Compute the value of the normal distribution at x = density. The mean and | |
922 // standard deviation are values saved by initialize_dead_wood_limiter(). | |
923 static inline double normal_distribution(double density); | |
924 | |
925 // Initialize the static vars used by dead_wood_limiter(). | |
926 static void initialize_dead_wood_limiter(); | |
927 | |
928 // Return the percentage of space that can be treated as "dead wood" (i.e., | |
929 // not reclaimed). | |
930 static double dead_wood_limiter(double density, size_t min_percent); | |
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 | 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 | 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 | 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 | 943 |
944 // Return a value indicating the benefit or 'yield' if the compacted region | |
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 | 947 // |
948 // The value is based on the amount of space reclaimed vs. the costs of (a) | |
949 // updating references in the dense prefix plus (b) copying objects and | |
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 | 952 HeapWord* const bottom, |
953 HeapWord* const top, | |
954 HeapWord* const new_top); | |
955 | |
956 // Compute the dense prefix for the designated space. | |
957 static HeapWord* compute_dense_prefix(const SpaceId id, | |
958 bool maximum_compaction); | |
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 | 963 idx_t bit); |
964 | |
965 // Summary phase utility routine to fill dead space (if any) at the dense | |
966 // prefix boundary. Should only be called if the the dense prefix is | |
967 // non-empty. | |
968 static void fill_dense_prefix_end(SpaceId id); | |
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 | 991 static void summarize_spaces_quick(); |
992 static void summarize_space(SpaceId id, bool maximum_compaction); | |
993 static void summary_phase(ParCompactionManager* cm, bool maximum_compaction); | |
994 | |
995 // Adjust addresses in roots. Does not adjust addresses in heap. | |
996 static void adjust_roots(); | |
997 | |
998 // Serial code executed in preparation for the compaction phase. | |
999 static void compact_prologue(); | |
1000 | |
1001 // Move objects to new locations. | |
1002 static void compact_perm(ParCompactionManager* cm); | |
1003 static void compact(); | |
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 | 1008 |
1009 // Add dense prefix update tasks to the task queue. | |
1010 static void enqueue_dense_prefix_tasks(GCTaskQueue* q, | |
1011 uint parallel_gc_threads); | |
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 | 1015 GCTaskQueue* q, |
1016 ParallelTaskTerminator* terminator_ptr, | |
1017 uint parallel_gc_threads); | |
1018 | |
1019 // For debugging only - compacts the old gen serially | |
1020 static void compact_serial(ParCompactionManager* cm); | |
1021 | |
1022 // If objects are left in eden after a collection, try to move the boundary | |
1023 // and absorb them into the old gen. Returns true if eden was emptied. | |
1024 static bool absorb_live_data_from_eden(PSAdaptiveSizePolicy* size_policy, | |
1025 PSYoungGen* young_gen, | |
1026 PSOldGen* old_gen); | |
1027 | |
1028 // Reset time since last full gc | |
1029 static void reset_millis_since_last_gc(); | |
1030 | |
1031 protected: | |
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 | 1034 static GrowableArray<oop> * _live_oops; |
1035 static GrowableArray<oop> * _live_oops_moved_to; | |
1036 static GrowableArray<size_t>* _live_oops_size; | |
1037 static size_t _live_oops_index; | |
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 | 1041 static bool _pointer_tracking; |
1042 static bool _root_tracking; | |
1043 | |
1044 // The following arrays are saved since the time of the last GC and | |
1045 // assist in tracking down problems where someone has done an errant | |
1046 // store into the heap, usually to an oop that wasn't properly | |
1047 // handleized across a GC. If we crash or otherwise fail before the | |
1048 // next GC, we can query these arrays to find out the object we had | |
1049 // intended to do the store to (assuming it is still alive) and the | |
1050 // offset within that object. Covered under RecordMarkSweepCompaction. | |
1051 static GrowableArray<HeapWord*> * _cur_gc_live_oops; | |
1052 static GrowableArray<HeapWord*> * _cur_gc_live_oops_moved_to; | |
1053 static GrowableArray<size_t>* _cur_gc_live_oops_size; | |
1054 static GrowableArray<HeapWord*> * _last_gc_live_oops; | |
1055 static GrowableArray<HeapWord*> * _last_gc_live_oops_moved_to; | |
1056 static GrowableArray<size_t>* _last_gc_live_oops_size; | |
1057 #endif | |
1058 | |
1059 public: | |
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 | 1062 ParCompactionManager* _compaction_manager; |
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 | 1067 }; |
1068 | |
1069 PSParallelCompact(); | |
1070 | |
1071 // Convenient accessor for Universe::heap(). | |
1072 static ParallelScavengeHeap* gc_heap() { | |
1073 return (ParallelScavengeHeap*)Universe::heap(); | |
1074 } | |
1075 | |
1076 static void invoke(bool maximum_heap_compaction); | |
1077 static void invoke_no_policy(bool maximum_heap_compaction); | |
1078 | |
1079 static void post_initialize(); | |
1080 // Perform initialization for PSParallelCompact that requires | |
1081 // allocations. This should be called during the VM initialization | |
1082 // at a pointer where it would be appropriate to return a JNI_ENOMEM | |
1083 // in the event of a failure. | |
1084 static bool initialize(); | |
1085 | |
1086 // Public accessors | |
1087 static elapsedTimer* accumulated_time() { return &_accumulated_time; } | |
1088 static unsigned int total_invocations() { return _total_invocations; } | |
1089 static CollectorCounters* counters() { return _counters; } | |
1090 | |
1091 // Used to add tasks | |
1092 static GCTaskManager* const gc_task_manager(); | |
1093 static klassOop updated_int_array_klass_obj() { | |
1094 return _updated_int_array_klass_obj; | |
1095 } | |
1096 | |
1097 // Marking support | |
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 | 1102 |
1103 // Compaction support. | |
1104 // Return true if p is in the range [beg_addr, end_addr). | |
1105 static inline bool is_in(HeapWord* p, HeapWord* beg_addr, HeapWord* end_addr); | |
1106 static inline bool is_in(oop* p, HeapWord* beg_addr, HeapWord* end_addr); | |
1107 | |
1108 // Convenience wrappers for per-space data kept in _space_info. | |
1109 static inline MutableSpace* space(SpaceId space_id); | |
1110 static inline HeapWord* new_top(SpaceId space_id); | |
1111 static inline HeapWord* dense_prefix(SpaceId space_id); | |
1112 static inline ObjectStartArray* start_array(SpaceId space_id); | |
1113 | |
1114 // Return true if the klass should be updated. | |
1115 static inline bool should_update_klass(klassOop k); | |
1116 | |
1117 // Move and update the live objects in the specified space. | |
1118 static void move_and_update(ParCompactionManager* cm, SpaceId space_id); | |
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 | 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 | 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 | 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 | 1134 // objects in the dense prefix move and dead space is dead |
1135 // (holds only dead objects that don't need any processing), so | |
1136 // dead space can be filled in any order. | |
1137 static void update_and_deadwood_in_dense_prefix(ParCompactionManager* cm, | |
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 | 1141 |
1142 // Return the address of the count + 1st live word in the range [beg, end). | |
1143 static HeapWord* skip_live_words(HeapWord* beg, HeapWord* end, size_t count); | |
1144 | |
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 | 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 | 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 | 1153 // beyond the end of source range just processed. If necessary, switch to a |
1154 // new source space and set src_space_id (in-out parameter) and src_space_top | |
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 | 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 | 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 | 1167 HeapWord* end_addr); |
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 | 1173 } |
1174 | |
1175 // Update the deferred objects in the space. | |
1176 static void update_deferred_objects(ParCompactionManager* cm, SpaceId id); | |
1177 | |
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 | 1181 |
1182 static ParMarkBitMap* mark_bitmap() { return &_mark_bitmap; } | |
1183 static ParallelCompactData& summary_data() { return _summary_data; } | |
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 | 1190 HeapWord* beg_addr, |
1191 HeapWord* end_addr); | |
1192 | |
1193 // Reference Processing | |
1194 static ReferenceProcessor* const ref_processor() { return _ref_processor; } | |
1195 | |
1196 // Return the SpaceId for the given address. | |
1197 static SpaceId space_id(HeapWord* addr); | |
1198 | |
1199 // Time since last full gc (in milliseconds). | |
1200 static jlong millis_since_last_gc(); | |
1201 | |
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 | 1205 static void track_interior_pointers(oop obj); |
1206 static void check_interior_pointers(); | |
1207 | |
1208 static void reset_live_oop_tracking(bool at_perm); | |
1209 static void register_live_oop(oop p, size_t size); | |
1210 static void validate_live_oop(oop p, size_t size); | |
1211 static void live_oop_moved_to(HeapWord* q, size_t size, HeapWord* compaction_top); | |
1212 static void compaction_complete(); | |
1213 | |
1214 // Querying operation of RecordMarkSweepCompaction results. | |
1215 // Finds and prints the current base oop and offset for a word | |
1216 // within an oop that was live during the last GC. Helpful for | |
1217 // tracking down heap stomps. | |
1218 static void print_new_location_of_heap_address(HeapWord* q); | |
1219 #endif // #ifdef VALIDATE_MARK_SWEEP | |
1220 | |
1221 // Call backs for class unloading | |
1222 // Update subklass/sibling/implementor links at end of marking. | |
1223 static void revisit_weak_klass_link(ParCompactionManager* cm, Klass* k); | |
1224 | |
941 | 1225 // Clear unmarked oops in MDOs at the end of marking. |
1226 static void revisit_mdo(ParCompactionManager* cm, DataLayout* p); | |
1227 | |
0 | 1228 #ifndef PRODUCT |
1229 // Debugging support. | |
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 | 1232 static void print_dense_prefix_stats(const char* const algorithm, |
1233 const SpaceId id, | |
1234 const bool maximum_compaction, | |
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 | 1240 #endif // #ifndef PRODUCT |
1241 | |
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 | 1246 static void verify_complete(SpaceId space_id); |
1247 #endif // #ifdef ASSERT | |
1248 }; | |
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 | 1251 const int obj_size = obj->size(); |
1252 if (mark_bitmap()->mark_obj(obj, obj_size)) { | |
1253 _summary_data.add_obj(obj, obj_size); | |
1254 return true; | |
1255 } else { | |
1256 return false; | |
1257 } | |
1258 } | |
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 | 1344 return _print_phases; |
1345 } | |
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 | 1348 assert(_dwl_initialized, "uninitialized"); |
1349 const double squared_term = (density - _dwl_mean) / _dwl_std_dev; | |
1350 return _dwl_first_term * exp(-0.5 * squared_term * squared_term); | |
1351 } | |
1352 | |
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 | 1355 idx_t bit) |
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 | 1359 "sanity check"); |
1360 | |
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 | 1365 !_mark_bitmap.is_obj_beg(bit) && |
1366 !_mark_bitmap.is_obj_end(bit - 1); | |
1367 } | |
1368 | |
1369 inline bool | |
1370 PSParallelCompact::is_in(HeapWord* p, HeapWord* beg_addr, HeapWord* end_addr) { | |
1371 return p >= beg_addr && p < end_addr; | |
1372 } | |
1373 | |
1374 inline bool | |
1375 PSParallelCompact::is_in(oop* p, HeapWord* beg_addr, HeapWord* end_addr) { | |
1376 return is_in((HeapWord*)p, beg_addr, end_addr); | |
1377 } | |
1378 | |
1379 inline MutableSpace* PSParallelCompact::space(SpaceId id) { | |
1380 assert(id < last_space_id, "id out of range"); | |
1381 return _space_info[id].space(); | |
1382 } | |
1383 | |
1384 inline HeapWord* PSParallelCompact::new_top(SpaceId id) { | |
1385 assert(id < last_space_id, "id out of range"); | |
1386 return _space_info[id].new_top(); | |
1387 } | |
1388 | |
1389 inline HeapWord* PSParallelCompact::dense_prefix(SpaceId id) { | |
1390 assert(id < last_space_id, "id out of range"); | |
1391 return _space_info[id].dense_prefix(); | |
1392 } | |
1393 | |
1394 inline ObjectStartArray* PSParallelCompact::start_array(SpaceId id) { | |
1395 assert(id < last_space_id, "id out of range"); | |
1396 return _space_info[id].start_array(); | |
1397 } | |
1398 | |
1399 inline bool PSParallelCompact::should_update_klass(klassOop k) { | |
1400 return ((HeapWord*) k) >= dense_prefix(perm_space_id); | |
1401 } | |
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 | 1405 HeapWord* beg_addr, |
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 | 1408 adjust_pointer(p); |
1409 } | |
1410 } | |
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 | 1421 class MoveAndUpdateClosure: public ParMarkBitMapClosure { |
1422 public: | |
1423 inline MoveAndUpdateClosure(ParMarkBitMap* bitmap, ParCompactionManager* cm, | |
1424 ObjectStartArray* start_array, | |
1425 HeapWord* destination, size_t words); | |
1426 | |
1427 // Accessors. | |
1428 HeapWord* destination() const { return _destination; } | |
1429 | |
1430 // If the object will fit (size <= words_remaining()), copy it to the current | |
1431 // destination, update the interior oops and the start array and return either | |
1432 // full (if the closure is full) or incomplete. If the object will not fit, | |
1433 // return would_overflow. | |
1434 virtual IterationStatus do_addr(HeapWord* addr, size_t size); | |
1435 | |
1436 // Copy enough words to fill this closure, starting at source(). Interior | |
1437 // oops and the start array are not updated. Return full. | |
1438 IterationStatus copy_until_full(); | |
1439 | |
1440 // Copy enough words to fill this closure or to the end of an object, | |
1441 // whichever is smaller, starting at source(). Interior oops and the start | |
1442 // array are not updated. | |
1443 void copy_partial_obj(); | |
1444 | |
1445 protected: | |
1446 // Update variables to indicate that word_count words were processed. | |
1447 inline void update_state(size_t word_count); | |
1448 | |
1449 protected: | |
1450 ObjectStartArray* const _start_array; | |
1451 HeapWord* _destination; // Next addr to be written. | |
1452 }; | |
1453 | |
1454 inline | |
1455 MoveAndUpdateClosure::MoveAndUpdateClosure(ParMarkBitMap* bitmap, | |
1456 ParCompactionManager* cm, | |
1457 ObjectStartArray* start_array, | |
1458 HeapWord* destination, | |
1459 size_t words) : | |
1460 ParMarkBitMapClosure(bitmap, cm, words), _start_array(start_array) | |
1461 { | |
1462 _destination = destination; | |
1463 } | |
1464 | |
1465 inline void MoveAndUpdateClosure::update_state(size_t words) | |
1466 { | |
1467 decrement_words_remaining(words); | |
1468 _source += words; | |
1469 _destination += words; | |
1470 } | |
1471 | |
1472 class UpdateOnlyClosure: public ParMarkBitMapClosure { | |
1473 private: | |
1474 const PSParallelCompact::SpaceId _space_id; | |
1475 ObjectStartArray* const _start_array; | |
1476 | |
1477 public: | |
1478 UpdateOnlyClosure(ParMarkBitMap* mbm, | |
1479 ParCompactionManager* cm, | |
1480 PSParallelCompact::SpaceId space_id); | |
1481 | |
1482 // Update the object. | |
1483 virtual IterationStatus do_addr(HeapWord* addr, size_t words); | |
1484 | |
1485 inline void do_addr(HeapWord* addr); | |
1486 }; | |
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 | 1490 _start_array->allocate_block(addr); |
1491 oop(addr)->update_contents(compaction_manager()); | |
1492 } | |
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 | 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 | 1503 "cannot use FillClosure in the young gen"); |
1504 } | |
1505 | |
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 | 1513 return ParMarkBitMap::incomplete; |
1514 } | |
1515 | |
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 | 1518 }; |