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 jdk.unsupported/sun.misc
30 * @run testng/othervm -Diters=100 -Xint compiler.unsafe.SunMiscUnsafeAccessTestInt
31 * @run testng/othervm -Diters=20000 -XX:TieredStopAtLevel=1 compiler.unsafe.SunMiscUnsafeAccessTestInt
32 * @run testng/othervm -Diters=20000 -XX:-TieredCompilation compiler.unsafe.SunMiscUnsafeAccessTestInt
33 * @run testng/othervm -Diters=20000 compiler.unsafe.SunMiscUnsafeAccessTestInt
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 SunMiscUnsafeAccessTestInt {
45 static final int ITERS = Integer.getInteger("iters", 1);
46 static final int WEAK_ATTEMPTS = Integer.getInteger("weakAttempts", 10);
47
48 static final sun.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 = sun.misc.Unsafe.class.getDeclaredField("theUnsafe");
63 f.setAccessible(true);
64 UNSAFE = (sun.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 = SunMiscUnsafeAccessTestInt.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 = SunMiscUnsafeAccessTestInt.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 SunMiscUnsafeAccessTestInt t = new SunMiscUnsafeAccessTestInt();
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 // Lazy
164 {
165 UNSAFE.putOrderedInt(base, offset, 0x01234567);
166 int x = UNSAFE.getIntVolatile(base, offset);
167 assertEquals(x, 0x01234567, "putRelease int value");
168 }
169
170
171
172 UNSAFE.putInt(base, offset, 0x01234567);
173
174 // Compare
175 {
176 boolean r = UNSAFE.compareAndSwapInt(base, offset, 0x01234567, 0x89ABCDEF);
177 assertEquals(r, true, "success compareAndSwap int");
178 int x = UNSAFE.getInt(base, offset);
179 assertEquals(x, 0x89ABCDEF, "success compareAndSwap int value");
180 }
181
182 {
183 boolean r = UNSAFE.compareAndSwapInt(base, offset, 0x01234567, 0xCAFEBABE);
184 assertEquals(r, false, "failing compareAndSwap int");
185 int x = UNSAFE.getInt(base, offset);
186 assertEquals(x, 0x89ABCDEF, "failing compareAndSwap int value");
187 }
188
189 UNSAFE.putInt(base, offset, 0x89ABCDEF);
190
191 // Compare set and get
192 {
193 int o = UNSAFE.getAndSetInt(base, offset, 0x01234567);
194 assertEquals(o, 0x89ABCDEF, "getAndSet int");
195 int x = UNSAFE.getInt(base, offset);
196 assertEquals(x, 0x01234567, "getAndSet int value");
197 }
198
199 UNSAFE.putInt(base, offset, 0x01234567);
200
201 // get and add, add and get
202 {
203 int o = UNSAFE.getAndAddInt(base, offset, 0x89ABCDEF);
204 assertEquals(o, 0x01234567, "getAndAdd int");
205 int x = UNSAFE.getInt(base, offset);
206 assertEquals(x, (int)(0x01234567 + 0x89ABCDEF), "getAndAdd int");
207 }
208 }
209
210 static void testAccess(long address) {
211 // Plain
212 {
213 UNSAFE.putInt(address, 0x01234567);
214 int x = UNSAFE.getInt(address);
215 assertEquals(x, 0x01234567, "set int value");
216 }
217 }
218 }
219