1 /*
2 * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24 /*
25 * @test
26 * @bug 8143628
27 * @summary Test unsafe access for int
28 *
29 * @modules java.base/jdk.internal.misc
30 * @run testng/othervm -Diters=100 -Xint compiler.unsafe.JdkInternalMiscUnsafeAccessTestInt
31 * @run testng/othervm -Diters=20000 -XX:TieredStopAtLevel=1 compiler.unsafe.JdkInternalMiscUnsafeAccessTestInt
32 * @run testng/othervm -Diters=20000 -XX:-TieredCompilation compiler.unsafe.JdkInternalMiscUnsafeAccessTestInt
33 * @run testng/othervm -Diters=20000 compiler.unsafe.JdkInternalMiscUnsafeAccessTestInt
34 */
35
36 package compiler.unsafe;
37
38 import org.testng.annotations.Test;
39
40 import java.lang.reflect.Field;
41
42 import static org.testng.Assert.*;
43
44 public class JdkInternalMiscUnsafeAccessTestInt {
45 static final int ITERS = Integer.getInteger("iters", 1);
46 static final int WEAK_ATTEMPTS = Integer.getInteger("weakAttempts", 10);
47
48 static final jdk.internal.misc.Unsafe UNSAFE;
49
50 static final long V_OFFSET;
51
52 static final Object STATIC_V_BASE;
53
54 static final long STATIC_V_OFFSET;
55
56 static int ARRAY_OFFSET;
57
58 static int ARRAY_SHIFT;
59
60 static {
61 try {
62 Field f = jdk.internal.misc.Unsafe.class.getDeclaredField("theUnsafe");
63 f.setAccessible(true);
64 UNSAFE = (jdk.internal.misc.Unsafe) f.get(null);
65 } catch (Exception e) {
66 throw new RuntimeException("Unable to get Unsafe instance.", e);
67 }
68
69 try {
70 Field staticVField = JdkInternalMiscUnsafeAccessTestInt.class.getDeclaredField("static_v");
71 STATIC_V_BASE = UNSAFE.staticFieldBase(staticVField);
72 STATIC_V_OFFSET = UNSAFE.staticFieldOffset(staticVField);
73 } catch (Exception e) {
74 throw new RuntimeException(e);
75 }
76
77 try {
78 Field vField = JdkInternalMiscUnsafeAccessTestInt.class.getDeclaredField("v");
79 V_OFFSET = UNSAFE.objectFieldOffset(vField);
80 } catch (Exception e) {
81 throw new RuntimeException(e);
82 }
83
84 ARRAY_OFFSET = UNSAFE.arrayBaseOffset(int[].class);
85 int ascale = UNSAFE.arrayIndexScale(int[].class);
86 ARRAY_SHIFT = 31 - Integer.numberOfLeadingZeros(ascale);
87 }
88
89 static int static_v;
90
91 int v;
92
93 @Test
94 public void testFieldInstance() {
95 JdkInternalMiscUnsafeAccessTestInt t = new JdkInternalMiscUnsafeAccessTestInt();
96 for (int c = 0; c < ITERS; c++) {
97 testAccess(t, V_OFFSET);
98 }
99 }
100
101 @Test
102 public void testFieldStatic() {
103 for (int c = 0; c < ITERS; c++) {
104 testAccess(STATIC_V_BASE, STATIC_V_OFFSET);
105 }
106 }
107
108 @Test
109 public void testArray() {
110 int[] array = new int[10];
111 for (int c = 0; c < ITERS; c++) {
112 for (int i = 0; i < array.length; i++) {
113 testAccess(array, (((long) i) << ARRAY_SHIFT) + ARRAY_OFFSET);
114 }
115 }
116 }
117
118 @Test
119 public void testArrayOffHeap() {
120 int size = 10;
121 long address = UNSAFE.allocateMemory(size << ARRAY_SHIFT);
122 try {
123 for (int c = 0; c < ITERS; c++) {
124 for (int i = 0; i < size; i++) {
125 testAccess(null, (((long) i) << ARRAY_SHIFT) + address);
126 }
127 }
128 } finally {
129 UNSAFE.freeMemory(address);
130 }
131 }
132
133 @Test
134 public void testArrayOffHeapDirect() {
135 int size = 10;
136 long address = UNSAFE.allocateMemory(size << ARRAY_SHIFT);
137 try {
138 for (int c = 0; c < ITERS; c++) {
139 for (int i = 0; i < size; i++) {
140 testAccess((((long) i) << ARRAY_SHIFT) + address);
141 }
142 }
143 } finally {
144 UNSAFE.freeMemory(address);
145 }
146 }
147
148 static void testAccess(Object base, long offset) {
149 // Plain
150 {
151 UNSAFE.putInt(base, offset, 0x01234567);
152 int x = UNSAFE.getInt(base, offset);
153 assertEquals(x, 0x01234567, "set int value");
154 }
155
156 // Volatile
157 {
158 UNSAFE.putIntVolatile(base, offset, 0x89ABCDEF);
159 int x = UNSAFE.getIntVolatile(base, offset);
160 assertEquals(x, 0x89ABCDEF, "putVolatile int value");
161 }
162
163
164 // Lazy
165 {
166 UNSAFE.putIntRelease(base, offset, 0x01234567);
167 int x = UNSAFE.getIntAcquire(base, offset);
168 assertEquals(x, 0x01234567, "putRelease int value");
169 }
170
171 // Opaque
172 {
173 UNSAFE.putIntOpaque(base, offset, 0x89ABCDEF);
174 int x = UNSAFE.getIntOpaque(base, offset);
175 assertEquals(x, 0x89ABCDEF, "putOpaque int value");
176 }
177
178 // Unaligned
179 {
180 UNSAFE.putIntUnaligned(base, offset, 0x89ABCDEF);
181 int x = UNSAFE.getIntUnaligned(base, offset);
182 assertEquals(x, 0x89ABCDEF, "putUnaligned int value");
183 }
184
185 {
186 UNSAFE.putIntUnaligned(base, offset, 0x01234567, true);
187 int x = UNSAFE.getIntUnaligned(base, offset, true);
188 assertEquals(x, 0x01234567, "putUnaligned big endian int value");
189 }
190
191 {
192 UNSAFE.putIntUnaligned(base, offset, 0x89ABCDEF, false);
193 int x = UNSAFE.getIntUnaligned(base, offset, false);
194 assertEquals(x, 0x89ABCDEF, "putUnaligned little endian int value");
195 }
196
197 UNSAFE.putInt(base, offset, 0x01234567);
198
199 // Compare
200 {
201 boolean r = UNSAFE.compareAndSwapInt(base, offset, 0x01234567, 0x89ABCDEF);
202 assertEquals(r, true, "success compareAndSwap int");
203 int x = UNSAFE.getInt(base, offset);
204 assertEquals(x, 0x89ABCDEF, "success compareAndSwap int value");
205 }
206
207 {
208 boolean r = UNSAFE.compareAndSwapInt(base, offset, 0x01234567, 0xCAFEBABE);
209 assertEquals(r, false, "failing compareAndSwap int");
210 int x = UNSAFE.getInt(base, offset);
211 assertEquals(x, 0x89ABCDEF, "failing compareAndSwap int value");
212 }
213
214 // Advanced compare
215 {
216 int r = UNSAFE.compareAndExchangeIntVolatile(base, offset, 0x89ABCDEF, 0x01234567);
217 assertEquals(r, 0x89ABCDEF, "success compareAndExchangeVolatile int");
218 int x = UNSAFE.getInt(base, offset);
219 assertEquals(x, 0x01234567, "success compareAndExchangeVolatile int value");
220 }
221
222 {
223 int r = UNSAFE.compareAndExchangeIntVolatile(base, offset, 0x89ABCDEF, 0xCAFEBABE);
224 assertEquals(r, 0x01234567, "failing compareAndExchangeVolatile int");
225 int x = UNSAFE.getInt(base, offset);
226 assertEquals(x, 0x01234567, "failing compareAndExchangeVolatile int value");
227 }
228
229 {
230 int r = UNSAFE.compareAndExchangeIntAcquire(base, offset, 0x01234567, 0x89ABCDEF);
231 assertEquals(r, 0x01234567, "success compareAndExchangeAcquire int");
232 int x = UNSAFE.getInt(base, offset);
233 assertEquals(x, 0x89ABCDEF, "success compareAndExchangeAcquire int value");
234 }
235
236 {
237 int r = UNSAFE.compareAndExchangeIntAcquire(base, offset, 0x01234567, 0xCAFEBABE);
238 assertEquals(r, 0x89ABCDEF, "failing compareAndExchangeAcquire int");
239 int x = UNSAFE.getInt(base, offset);
240 assertEquals(x, 0x89ABCDEF, "failing compareAndExchangeAcquire int value");
241 }
242
243 {
244 int r = UNSAFE.compareAndExchangeIntRelease(base, offset, 0x89ABCDEF, 0x01234567);
245 assertEquals(r, 0x89ABCDEF, "success compareAndExchangeRelease int");
246 int x = UNSAFE.getInt(base, offset);
247 assertEquals(x, 0x01234567, "success compareAndExchangeRelease int value");
248 }
249
250 {
251 int r = UNSAFE.compareAndExchangeIntRelease(base, offset, 0x89ABCDEF, 0xCAFEBABE);
252 assertEquals(r, 0x01234567, "failing compareAndExchangeRelease int");
253 int x = UNSAFE.getInt(base, offset);
254 assertEquals(x, 0x01234567, "failing compareAndExchangeRelease int value");
255 }
256
257 {
258 boolean success = false;
259 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
260 success = UNSAFE.weakCompareAndSwapInt(base, offset, 0x01234567, 0x89ABCDEF);
261 }
262 assertEquals(success, true, "weakCompareAndSwap int");
263 int x = UNSAFE.getInt(base, offset);
264 assertEquals(x, 0x89ABCDEF, "weakCompareAndSwap int value");
265 }
266
267 {
268 boolean success = false;
269 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
270 success = UNSAFE.weakCompareAndSwapIntAcquire(base, offset, 0x89ABCDEF, 0x01234567);
271 }
272 assertEquals(success, true, "weakCompareAndSwapAcquire int");
273 int x = UNSAFE.getInt(base, offset);
274 assertEquals(x, 0x01234567, "weakCompareAndSwapAcquire int");
275 }
276
277 {
278 boolean success = false;
279 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
280 success = UNSAFE.weakCompareAndSwapIntRelease(base, offset, 0x01234567, 0x89ABCDEF);
281 }
282 assertEquals(success, true, "weakCompareAndSwapRelease int");
283 int x = UNSAFE.getInt(base, offset);
284 assertEquals(x, 0x89ABCDEF, "weakCompareAndSwapRelease int");
285 }
286
287 {
288 boolean success = false;
289 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
290 success = UNSAFE.weakCompareAndSwapIntVolatile(base, offset, 0x89ABCDEF, 0x01234567);
291 }
292 assertEquals(success, true, "weakCompareAndSwapVolatile int");
293 int x = UNSAFE.getInt(base, offset);
294 assertEquals(x, 0x01234567, "weakCompareAndSwapVolatile int");
295 }
296
297 UNSAFE.putInt(base, offset, 0x89ABCDEF);
298
299 // Compare set and get
300 {
301 int o = UNSAFE.getAndSetInt(base, offset, 0x01234567);
302 assertEquals(o, 0x89ABCDEF, "getAndSet int");
303 int x = UNSAFE.getInt(base, offset);
304 assertEquals(x, 0x01234567, "getAndSet int value");
305 }
306
307 UNSAFE.putInt(base, offset, 0x01234567);
308
309 // get and add, add and get
310 {
311 int o = UNSAFE.getAndAddInt(base, offset, 0x89ABCDEF);
312 assertEquals(o, 0x01234567, "getAndAdd int");
313 int x = UNSAFE.getInt(base, offset);
314 assertEquals(x, (int)(0x01234567 + 0x89ABCDEF), "getAndAdd int");
315 }
316 }
317
318 static void testAccess(long address) {
319 // Plain
320 {
321 UNSAFE.putInt(address, 0x01234567);
322 int x = UNSAFE.getInt(address);
323 assertEquals(x, 0x01234567, "set int value");
324 }
325 }
326 }
327