Mercurial > hg > truffle
annotate src/share/vm/utilities/copy.hpp @ 8733:9def4075da6d
8008079: G1: Add nextObject routine to CMBitMapRO and replace nextWord
Summary: Update the task local finger to the start of the next object when marking aborts, in order to avoid the redundant scanning of all 0's when the marking task restarts, if otherwise updating to the next word. In addition, reuse the routine nextObject() in routine iterate().
Reviewed-by: johnc, ysr
Contributed-by: tamao <tao.mao@oracle.com>
| author | tamao |
|---|---|
| date | Tue, 05 Mar 2013 15:36:56 -0800 |
| parents | 1d1603768966 |
| children |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
2426
1d1603768966
7010070: Update all 2010 Oracle-changed OpenJDK files to have the proper copyright dates - second pass
trims
parents:
2192
diff
changeset
|
2 * Copyright (c) 2003, 2011, Oracle and/or its affiliates. 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 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
196
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
196
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
196
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_UTILITIES_COPY_HPP |
| 26 #define SHARE_VM_UTILITIES_COPY_HPP | |
| 27 | |
| 28 #include "runtime/stubRoutines.hpp" | |
| 29 | |
| 0 | 30 // Assembly code for platforms that need it. |
| 31 extern "C" { | |
| 32 void _Copy_conjoint_words(HeapWord* from, HeapWord* to, size_t count); | |
| 33 void _Copy_disjoint_words(HeapWord* from, HeapWord* to, size_t count); | |
| 34 | |
| 35 void _Copy_conjoint_words_atomic(HeapWord* from, HeapWord* to, size_t count); | |
| 36 void _Copy_disjoint_words_atomic(HeapWord* from, HeapWord* to, size_t count); | |
| 37 | |
| 38 void _Copy_aligned_conjoint_words(HeapWord* from, HeapWord* to, size_t count); | |
| 39 void _Copy_aligned_disjoint_words(HeapWord* from, HeapWord* to, size_t count); | |
| 40 | |
| 41 void _Copy_conjoint_bytes(void* from, void* to, size_t count); | |
| 42 | |
| 43 void _Copy_conjoint_bytes_atomic (void* from, void* to, size_t count); | |
| 44 void _Copy_conjoint_jshorts_atomic(jshort* from, jshort* to, size_t count); | |
| 45 void _Copy_conjoint_jints_atomic (jint* from, jint* to, size_t count); | |
| 46 void _Copy_conjoint_jlongs_atomic (jlong* from, jlong* to, size_t count); | |
| 47 void _Copy_conjoint_oops_atomic (oop* from, oop* to, size_t count); | |
| 48 | |
| 49 void _Copy_arrayof_conjoint_bytes (HeapWord* from, HeapWord* to, size_t count); | |
| 50 void _Copy_arrayof_conjoint_jshorts(HeapWord* from, HeapWord* to, size_t count); | |
| 51 void _Copy_arrayof_conjoint_jints (HeapWord* from, HeapWord* to, size_t count); | |
| 52 void _Copy_arrayof_conjoint_jlongs (HeapWord* from, HeapWord* to, size_t count); | |
| 53 void _Copy_arrayof_conjoint_oops (HeapWord* from, HeapWord* to, size_t count); | |
| 54 } | |
| 55 | |
| 56 class Copy : AllStatic { | |
| 57 public: | |
| 58 // Block copy methods have four attributes. We don't define all possibilities. | |
|
1571
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
196
diff
changeset
|
59 // alignment: aligned to BytesPerLong |
| 0 | 60 // arrayof: arraycopy operation with both operands aligned on the same |
| 61 // boundary as the first element of an array of the copy unit. | |
| 62 // This is currently a HeapWord boundary on all platforms, except | |
| 63 // for long and double arrays, which are aligned on an 8-byte | |
| 64 // boundary on all platforms. | |
| 65 // arraycopy operations are implicitly atomic on each array element. | |
| 66 // overlap: disjoint or conjoint. | |
| 67 // copy unit: bytes or words (i.e., HeapWords) or oops (i.e., pointers). | |
| 68 // atomicity: atomic or non-atomic on the copy unit. | |
| 69 // | |
| 70 // Names are constructed thusly: | |
| 71 // | |
| 72 // [ 'aligned_' | 'arrayof_' ] | |
| 73 // ('conjoint_' | 'disjoint_') | |
| 74 // ('words' | 'bytes' | 'jshorts' | 'jints' | 'jlongs' | 'oops') | |
| 75 // [ '_atomic' ] | |
| 76 // | |
| 77 // Except in the arrayof case, whatever the alignment is, we assume we can copy | |
|
1571
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
196
diff
changeset
|
78 // whole alignment units. E.g., if BytesPerLong is 2x word alignment, an odd |
| 0 | 79 // count may copy an extra word. In the arrayof case, we are allowed to copy |
| 80 // only the number of copy units specified. | |
|
1603
d93949c5bdcc
6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents:
1579
diff
changeset
|
81 // |
|
d93949c5bdcc
6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents:
1579
diff
changeset
|
82 // All callees check count for 0. |
|
d93949c5bdcc
6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents:
1579
diff
changeset
|
83 // |
| 0 | 84 |
| 85 // HeapWords | |
| 86 | |
| 87 // Word-aligned words, conjoint, not atomic on each word | |
| 88 static void conjoint_words(HeapWord* from, HeapWord* to, size_t count) { | |
| 89 assert_params_ok(from, to, LogHeapWordSize); | |
| 90 pd_conjoint_words(from, to, count); | |
| 91 } | |
| 92 | |
| 93 // Word-aligned words, disjoint, not atomic on each word | |
| 94 static void disjoint_words(HeapWord* from, HeapWord* to, size_t count) { | |
| 95 assert_params_ok(from, to, LogHeapWordSize); | |
| 96 assert_disjoint(from, to, count); | |
| 97 pd_disjoint_words(from, to, count); | |
| 98 } | |
| 99 | |
| 100 // Word-aligned words, disjoint, atomic on each word | |
| 101 static void disjoint_words_atomic(HeapWord* from, HeapWord* to, size_t count) { | |
| 102 assert_params_ok(from, to, LogHeapWordSize); | |
| 103 assert_disjoint(from, to, count); | |
| 104 pd_disjoint_words_atomic(from, to, count); | |
| 105 } | |
| 106 | |
| 107 // Object-aligned words, conjoint, not atomic on each word | |
| 108 static void aligned_conjoint_words(HeapWord* from, HeapWord* to, size_t count) { | |
| 109 assert_params_aligned(from, to); | |
| 110 pd_aligned_conjoint_words(from, to, count); | |
| 111 } | |
| 112 | |
| 113 // Object-aligned words, disjoint, not atomic on each word | |
| 114 static void aligned_disjoint_words(HeapWord* from, HeapWord* to, size_t count) { | |
| 115 assert_params_aligned(from, to); | |
| 116 assert_disjoint(from, to, count); | |
| 117 pd_aligned_disjoint_words(from, to, count); | |
| 118 } | |
| 119 | |
| 120 // bytes, jshorts, jints, jlongs, oops | |
| 121 | |
| 122 // bytes, conjoint, not atomic on each byte (not that it matters) | |
|
1603
d93949c5bdcc
6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents:
1579
diff
changeset
|
123 static void conjoint_jbytes(void* from, void* to, size_t count) { |
| 0 | 124 pd_conjoint_bytes(from, to, count); |
| 125 } | |
| 126 | |
| 127 // bytes, conjoint, atomic on each byte (not that it matters) | |
|
1603
d93949c5bdcc
6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents:
1579
diff
changeset
|
128 static void conjoint_jbytes_atomic(void* from, void* to, size_t count) { |
| 0 | 129 pd_conjoint_bytes(from, to, count); |
| 130 } | |
| 131 | |
| 132 // jshorts, conjoint, atomic on each jshort | |
| 133 static void conjoint_jshorts_atomic(jshort* from, jshort* to, size_t count) { | |
| 134 assert_params_ok(from, to, LogBytesPerShort); | |
| 135 pd_conjoint_jshorts_atomic(from, to, count); | |
| 136 } | |
| 137 | |
| 138 // jints, conjoint, atomic on each jint | |
| 139 static void conjoint_jints_atomic(jint* from, jint* to, size_t count) { | |
| 140 assert_params_ok(from, to, LogBytesPerInt); | |
| 141 pd_conjoint_jints_atomic(from, to, count); | |
| 142 } | |
| 143 | |
| 144 // jlongs, conjoint, atomic on each jlong | |
| 145 static void conjoint_jlongs_atomic(jlong* from, jlong* to, size_t count) { | |
| 146 assert_params_ok(from, to, LogBytesPerLong); | |
| 147 pd_conjoint_jlongs_atomic(from, to, count); | |
| 148 } | |
| 149 | |
| 150 // oops, conjoint, atomic on each oop | |
| 151 static void conjoint_oops_atomic(oop* from, oop* to, size_t count) { | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
152 assert_params_ok(from, to, LogBytesPerHeapOop); |
| 0 | 153 pd_conjoint_oops_atomic(from, to, count); |
| 154 } | |
| 155 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
156 // overloaded for UseCompressedOops |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
157 static void conjoint_oops_atomic(narrowOop* from, narrowOop* to, size_t count) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
158 assert(sizeof(narrowOop) == sizeof(jint), "this cast is wrong"); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
159 assert_params_ok(from, to, LogBytesPerInt); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
160 pd_conjoint_jints_atomic((jint*)from, (jint*)to, count); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
161 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
162 |
| 0 | 163 // Copy a span of memory. If the span is an integral number of aligned |
| 164 // longs, words, or ints, copy those units atomically. | |
| 165 // The largest atomic transfer unit is 8 bytes, or the largest power | |
| 166 // of two which divides all of from, to, and size, whichever is smaller. | |
| 167 static void conjoint_memory_atomic(void* from, void* to, size_t size); | |
| 168 | |
| 169 // bytes, conjoint array, atomic on each byte (not that it matters) | |
|
1603
d93949c5bdcc
6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents:
1579
diff
changeset
|
170 static void arrayof_conjoint_jbytes(HeapWord* from, HeapWord* to, size_t count) { |
| 0 | 171 pd_arrayof_conjoint_bytes(from, to, count); |
| 172 } | |
| 173 | |
| 174 // jshorts, conjoint array, atomic on each jshort | |
| 175 static void arrayof_conjoint_jshorts(HeapWord* from, HeapWord* to, size_t count) { | |
| 176 assert_params_ok(from, to, LogBytesPerShort); | |
| 177 pd_arrayof_conjoint_jshorts(from, to, count); | |
| 178 } | |
| 179 | |
| 180 // jints, conjoint array, atomic on each jint | |
| 181 static void arrayof_conjoint_jints(HeapWord* from, HeapWord* to, size_t count) { | |
| 182 assert_params_ok(from, to, LogBytesPerInt); | |
| 183 pd_arrayof_conjoint_jints(from, to, count); | |
| 184 } | |
| 185 | |
| 186 // jlongs, conjoint array, atomic on each jlong | |
| 187 static void arrayof_conjoint_jlongs(HeapWord* from, HeapWord* to, size_t count) { | |
| 188 assert_params_ok(from, to, LogBytesPerLong); | |
| 189 pd_arrayof_conjoint_jlongs(from, to, count); | |
| 190 } | |
| 191 | |
| 192 // oops, conjoint array, atomic on each oop | |
| 193 static void arrayof_conjoint_oops(HeapWord* from, HeapWord* to, size_t count) { | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
194 assert_params_ok(from, to, LogBytesPerHeapOop); |
| 0 | 195 pd_arrayof_conjoint_oops(from, to, count); |
| 196 } | |
| 197 | |
| 198 // Known overlap methods | |
| 199 | |
| 200 // Copy word-aligned words from higher to lower addresses, not atomic on each word | |
| 201 inline static void conjoint_words_to_lower(HeapWord* from, HeapWord* to, size_t byte_count) { | |
| 202 // byte_count is in bytes to check its alignment | |
| 203 assert_params_ok(from, to, LogHeapWordSize); | |
| 204 assert_byte_count_ok(byte_count, HeapWordSize); | |
| 205 | |
| 206 size_t count = (size_t)round_to(byte_count, HeapWordSize) >> LogHeapWordSize; | |
| 207 assert(to <= from || from + count <= to, "do not overwrite source data"); | |
| 208 | |
| 209 while (count-- > 0) { | |
| 210 *to++ = *from++; | |
| 211 } | |
| 212 } | |
| 213 | |
| 214 // Copy word-aligned words from lower to higher addresses, not atomic on each word | |
| 215 inline static void conjoint_words_to_higher(HeapWord* from, HeapWord* to, size_t byte_count) { | |
| 216 // byte_count is in bytes to check its alignment | |
| 217 assert_params_ok(from, to, LogHeapWordSize); | |
| 218 assert_byte_count_ok(byte_count, HeapWordSize); | |
| 219 | |
| 220 size_t count = (size_t)round_to(byte_count, HeapWordSize) >> LogHeapWordSize; | |
| 221 assert(from <= to || to + count <= from, "do not overwrite source data"); | |
| 222 | |
| 223 from += count - 1; | |
| 224 to += count - 1; | |
| 225 while (count-- > 0) { | |
| 226 *to-- = *from--; | |
| 227 } | |
| 228 } | |
| 229 | |
| 230 // Fill methods | |
| 231 | |
| 232 // Fill word-aligned words, not atomic on each word | |
| 233 // set_words | |
| 234 static void fill_to_words(HeapWord* to, size_t count, juint value = 0) { | |
| 235 assert_params_ok(to, LogHeapWordSize); | |
| 236 pd_fill_to_words(to, count, value); | |
| 237 } | |
| 238 | |
| 239 static void fill_to_aligned_words(HeapWord* to, size_t count, juint value = 0) { | |
| 240 assert_params_aligned(to); | |
| 241 pd_fill_to_aligned_words(to, count, value); | |
| 242 } | |
| 243 | |
| 244 // Fill bytes | |
| 245 static void fill_to_bytes(void* to, size_t count, jubyte value = 0) { | |
| 246 pd_fill_to_bytes(to, count, value); | |
| 247 } | |
| 248 | |
| 249 // Fill a span of memory. If the span is an integral number of aligned | |
| 250 // longs, words, or ints, store to those units atomically. | |
| 251 // The largest atomic transfer unit is 8 bytes, or the largest power | |
| 252 // of two which divides both to and size, whichever is smaller. | |
| 253 static void fill_to_memory_atomic(void* to, size_t size, jubyte value = 0); | |
| 254 | |
| 255 // Zero-fill methods | |
| 256 | |
| 257 // Zero word-aligned words, not atomic on each word | |
| 258 static void zero_to_words(HeapWord* to, size_t count) { | |
| 259 assert_params_ok(to, LogHeapWordSize); | |
| 260 pd_zero_to_words(to, count); | |
| 261 } | |
| 262 | |
| 263 // Zero bytes | |
| 264 static void zero_to_bytes(void* to, size_t count) { | |
| 265 pd_zero_to_bytes(to, count); | |
| 266 } | |
| 267 | |
| 268 private: | |
| 269 static bool params_disjoint(HeapWord* from, HeapWord* to, size_t count) { | |
| 270 if (from < to) { | |
| 271 return pointer_delta(to, from) >= count; | |
| 272 } | |
| 273 return pointer_delta(from, to) >= count; | |
| 274 } | |
| 275 | |
| 276 // These methods raise a fatal if they detect a problem. | |
| 277 | |
| 278 static void assert_disjoint(HeapWord* from, HeapWord* to, size_t count) { | |
| 279 #ifdef ASSERT | |
| 280 if (!params_disjoint(from, to, count)) | |
| 281 basic_fatal("source and dest overlap"); | |
| 282 #endif | |
| 283 } | |
| 284 | |
| 285 static void assert_params_ok(void* from, void* to, intptr_t log_align) { | |
| 286 #ifdef ASSERT | |
| 287 if (mask_bits((uintptr_t)from, right_n_bits(log_align)) != 0) | |
| 288 basic_fatal("not aligned"); | |
| 289 if (mask_bits((uintptr_t)to, right_n_bits(log_align)) != 0) | |
| 290 basic_fatal("not aligned"); | |
| 291 #endif | |
| 292 } | |
| 293 | |
| 294 static void assert_params_ok(HeapWord* to, intptr_t log_align) { | |
| 295 #ifdef ASSERT | |
| 296 if (mask_bits((uintptr_t)to, right_n_bits(log_align)) != 0) | |
| 297 basic_fatal("not word aligned"); | |
| 298 #endif | |
| 299 } | |
| 300 static void assert_params_aligned(HeapWord* from, HeapWord* to) { | |
| 301 #ifdef ASSERT | |
|
1571
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
196
diff
changeset
|
302 if (mask_bits((uintptr_t)from, BytesPerLong-1) != 0) |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
196
diff
changeset
|
303 basic_fatal("not long aligned"); |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
196
diff
changeset
|
304 if (mask_bits((uintptr_t)to, BytesPerLong-1) != 0) |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
196
diff
changeset
|
305 basic_fatal("not long aligned"); |
| 0 | 306 #endif |
| 307 } | |
| 308 | |
| 309 static void assert_params_aligned(HeapWord* to) { | |
| 310 #ifdef ASSERT | |
|
1571
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
196
diff
changeset
|
311 if (mask_bits((uintptr_t)to, BytesPerLong-1) != 0) |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
196
diff
changeset
|
312 basic_fatal("not long aligned"); |
| 0 | 313 #endif |
| 314 } | |
| 315 | |
| 316 static void assert_byte_count_ok(size_t byte_count, size_t unit_size) { | |
| 317 #ifdef ASSERT | |
| 318 if ((size_t)round_to(byte_count, unit_size) != byte_count) { | |
| 319 basic_fatal("byte count must be aligned"); | |
| 320 } | |
| 321 #endif | |
| 322 } | |
| 323 | |
| 324 // Platform dependent implementations of the above methods. | |
| 1972 | 325 #ifdef TARGET_ARCH_x86 |
| 326 # include "copy_x86.hpp" | |
| 327 #endif | |
| 328 #ifdef TARGET_ARCH_sparc | |
| 329 # include "copy_sparc.hpp" | |
| 330 #endif | |
| 331 #ifdef TARGET_ARCH_zero | |
| 332 # include "copy_zero.hpp" | |
| 333 #endif | |
|
2192
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
1972
diff
changeset
|
334 #ifdef TARGET_ARCH_arm |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
1972
diff
changeset
|
335 # include "copy_arm.hpp" |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
1972
diff
changeset
|
336 #endif |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
1972
diff
changeset
|
337 #ifdef TARGET_ARCH_ppc |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
1972
diff
changeset
|
338 # include "copy_ppc.hpp" |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
1972
diff
changeset
|
339 #endif |
| 1972 | 340 |
| 0 | 341 }; |
| 1972 | 342 |
| 343 #endif // SHARE_VM_UTILITIES_COPY_HPP |