Mercurial > hg > graal-jvmci-8
annotate src/cpu/sparc/vm/copy_sparc.hpp @ 2368:dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
6627787: CMS: JVM refuses to start up with -Xms16m -Xmx16m
7000125: CMS: Anti-monotone young gen sizing with respect to maximum whole heap size specification
7027529: CMS: retire CMSUseOldDefaults flag
Summary: Simplify CMS heap sizing code, relying on ergonomic initial sizing consistent with other collectors for the most part, controlling only young gen sizing to rein in pause times. Make CMS young gen sizing default statically cpu-dependant. Remove inconsistencies wrt generation sizing and policy code, allowing for the fixing for 6627787 and 7000125. For 7027529, retire the flag CMSUseOldDefaults which had been introduced as a bridge from JDK 5 to JDK 6 a number of years ago.
Reviewed-by: brutisso, poonam
| author | ysr |
|---|---|
| date | Wed, 16 Mar 2011 10:37:08 -0700 |
| parents | f95d63e2154a |
| children | baf763f388e6 |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 1972 | 2 * Copyright (c) 2003, 2010, 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 CPU_SPARC_VM_COPY_SPARC_HPP |
| 26 #define CPU_SPARC_VM_COPY_SPARC_HPP | |
| 27 | |
| 0 | 28 // Inline functions for memory copy and fill. |
| 29 | |
| 30 static void pd_conjoint_words(HeapWord* from, HeapWord* to, size_t count) { | |
| 31 (void)memmove(to, from, count * HeapWordSize); | |
| 32 } | |
| 33 | |
| 34 static void pd_disjoint_words(HeapWord* from, HeapWord* to, size_t count) { | |
| 35 switch (count) { | |
| 36 case 8: to[7] = from[7]; | |
| 37 case 7: to[6] = from[6]; | |
| 38 case 6: to[5] = from[5]; | |
| 39 case 5: to[4] = from[4]; | |
| 40 case 4: to[3] = from[3]; | |
| 41 case 3: to[2] = from[2]; | |
| 42 case 2: to[1] = from[1]; | |
| 43 case 1: to[0] = from[0]; | |
| 44 case 0: break; | |
| 45 default: (void)memcpy(to, from, count * HeapWordSize); | |
| 46 break; | |
| 47 } | |
| 48 } | |
| 49 | |
| 50 static void pd_disjoint_words_atomic(HeapWord* from, HeapWord* to, size_t count) { | |
| 51 switch (count) { | |
| 52 case 8: to[7] = from[7]; | |
| 53 case 7: to[6] = from[6]; | |
| 54 case 6: to[5] = from[5]; | |
| 55 case 5: to[4] = from[4]; | |
| 56 case 4: to[3] = from[3]; | |
| 57 case 3: to[2] = from[2]; | |
| 58 case 2: to[1] = from[1]; | |
| 59 case 1: to[0] = from[0]; | |
| 60 case 0: break; | |
| 61 default: while (count-- > 0) { | |
| 62 *to++ = *from++; | |
| 63 } | |
| 64 break; | |
| 65 } | |
| 66 } | |
| 67 | |
| 68 static void pd_aligned_conjoint_words(HeapWord* from, HeapWord* to, size_t count) { | |
| 69 (void)memmove(to, from, count * HeapWordSize); | |
| 70 } | |
| 71 | |
| 72 static void pd_aligned_disjoint_words(HeapWord* from, HeapWord* to, size_t count) { | |
| 73 pd_disjoint_words(from, to, count); | |
| 74 } | |
| 75 | |
| 76 static void pd_conjoint_bytes(void* from, void* to, size_t count) { | |
| 77 (void)memmove(to, from, count); | |
| 78 } | |
| 79 | |
| 80 static void pd_conjoint_bytes_atomic(void* from, void* to, size_t count) { | |
| 81 (void)memmove(to, from, count); | |
| 82 } | |
| 83 | |
| 84 static void pd_conjoint_jshorts_atomic(jshort* from, jshort* to, size_t count) { | |
| 85 // FIXME | |
| 86 (void)memmove(to, from, count << LogBytesPerShort); | |
| 87 } | |
| 88 | |
| 89 static void pd_conjoint_jints_atomic(jint* from, jint* to, size_t count) { | |
| 90 // FIXME | |
| 91 (void)memmove(to, from, count << LogBytesPerInt); | |
| 92 } | |
| 93 | |
| 94 static void pd_conjoint_jlongs_atomic(jlong* from, jlong* to, size_t count) { | |
| 95 #ifdef _LP64 | |
| 96 assert(BytesPerLong == BytesPerOop, "jlongs and oops must be the same size"); | |
| 97 pd_conjoint_oops_atomic((oop*)from, (oop*)to, count); | |
| 98 #else | |
| 99 // Guarantee use of ldd/std via some asm code, because compiler won't. | |
| 100 // See solaris_sparc.il. | |
| 101 _Copy_conjoint_jlongs_atomic(from, to, count); | |
| 102 #endif | |
| 103 } | |
| 104 | |
| 105 static void pd_conjoint_oops_atomic(oop* from, oop* to, size_t count) { | |
| 106 // Do better than this: inline memmove body NEEDS CLEANUP | |
| 107 if (from > to) { | |
| 108 while (count-- > 0) { | |
| 109 // Copy forwards | |
| 110 *to++ = *from++; | |
| 111 } | |
| 112 } else { | |
| 113 from += count - 1; | |
| 114 to += count - 1; | |
| 115 while (count-- > 0) { | |
| 116 // Copy backwards | |
| 117 *to-- = *from--; | |
| 118 } | |
| 119 } | |
| 120 } | |
| 121 | |
| 122 static void pd_arrayof_conjoint_bytes(HeapWord* from, HeapWord* to, size_t count) { | |
| 123 pd_conjoint_bytes_atomic(from, to, count); | |
| 124 } | |
| 125 | |
| 126 static void pd_arrayof_conjoint_jshorts(HeapWord* from, HeapWord* to, size_t count) { | |
| 127 pd_conjoint_jshorts_atomic((jshort*)from, (jshort*)to, count); | |
| 128 } | |
| 129 | |
| 130 static void pd_arrayof_conjoint_jints(HeapWord* from, HeapWord* to, size_t count) { | |
| 131 pd_conjoint_jints_atomic((jint*)from, (jint*)to, count); | |
| 132 } | |
| 133 | |
| 134 static void pd_arrayof_conjoint_jlongs(HeapWord* from, HeapWord* to, size_t count) { | |
| 135 pd_conjoint_jlongs_atomic((jlong*)from, (jlong*)to, count); | |
| 136 } | |
| 137 | |
| 138 static void pd_arrayof_conjoint_oops(HeapWord* from, HeapWord* to, size_t count) { | |
| 139 pd_conjoint_oops_atomic((oop*)from, (oop*)to, count); | |
| 140 } | |
| 141 | |
| 142 static void pd_fill_to_words(HeapWord* tohw, size_t count, juint value) { | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
143 #ifdef _LP64 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
144 guarantee(mask_bits((uintptr_t)tohw, right_n_bits(LogBytesPerLong)) == 0, |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
145 "unaligned fill words"); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
146 julong* to = (julong*)tohw; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
147 julong v = ((julong)value << 32) | value; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
148 while (count-- > 0) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
149 *to++ = v; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
150 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
151 #else // _LP64 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
152 juint* to = (juint*)tohw; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
153 while (count-- > 0) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
154 *to++ = value; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
155 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
156 #endif // _LP64 |
| 0 | 157 } |
| 158 | |
| 159 static void pd_fill_to_aligned_words(HeapWord* tohw, size_t count, juint value) { | |
|
1571
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
196
diff
changeset
|
160 assert(MinObjAlignmentInBytes >= BytesPerLong, "need alternate implementation"); |
| 0 | 161 |
| 162 julong* to = (julong*)tohw; | |
| 163 julong v = ((julong)value << 32) | value; | |
| 164 // If count is odd, odd will be equal to 1 on 32-bit platform | |
| 165 // and be equal to 0 on 64-bit platform. | |
| 166 size_t odd = count % (BytesPerLong / HeapWordSize) ; | |
| 167 | |
|
1571
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
196
diff
changeset
|
168 size_t aligned_count = align_object_offset(count - odd) / HeapWordsPerLong; |
| 0 | 169 julong* end = ((julong*)tohw) + aligned_count - 1; |
| 170 while (to <= end) { | |
| 171 DEBUG_ONLY(count -= BytesPerLong / HeapWordSize ;) | |
| 172 *to++ = v; | |
| 173 } | |
| 174 assert(count == odd, "bad bounds on loop filling to aligned words"); | |
| 175 if (odd) { | |
| 176 *((juint*)to) = value; | |
| 177 | |
| 178 } | |
| 179 } | |
| 180 | |
| 181 static void pd_fill_to_bytes(void* to, size_t count, jubyte value) { | |
| 182 (void)memset(to, value, count); | |
| 183 } | |
| 184 | |
| 185 static void pd_zero_to_words(HeapWord* tohw, size_t count) { | |
| 186 pd_fill_to_words(tohw, count, 0); | |
| 187 } | |
| 188 | |
| 189 static void pd_zero_to_bytes(void* to, size_t count) { | |
| 190 (void)memset(to, 0, count); | |
| 191 } | |
| 1972 | 192 |
| 193 #endif // CPU_SPARC_VM_COPY_SPARC_HPP |