--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.hotspot.test/src/org/graalvm/compiler/hotspot/test/CompressedOopTest.java Tue Sep 12 19:03:39 2017 +0200
@@ -0,0 +1,450 @@
+/*
+ * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package org.graalvm.compiler.hotspot.test;
+
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicReference;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import org.graalvm.compiler.core.test.GraalCompilerTest;
+
+import jdk.vm.ci.hotspot.HotSpotInstalledCode;
+import jdk.vm.ci.meta.ResolvedJavaMethod;
+
+/**
+ * The following tests perform object/array equality and assignments in various ways. The selected
+ * cases have been the problematic ones while implementing the Compressed Oops support.
+ */
+public class CompressedOopTest extends GraalCompilerTest {
+
+ private HotSpotInstalledCode getInstalledCode(String name, Class<?>... parameterTypes) throws Exception {
+ final ResolvedJavaMethod javaMethod = getResolvedJavaMethod(getClass(), name, parameterTypes);
+ final HotSpotInstalledCode installedBenchmarkCode = (HotSpotInstalledCode) getCode(javaMethod);
+ return installedBenchmarkCode;
+ }
+
+ @Test
+ public void test() throws Exception {
+ HotSpotInstalledCode installedBenchmarkCode = getInstalledCode("fieldTest", Object.class);
+ Container c1 = new Container();
+ Assert.assertEquals(c1.b, installedBenchmarkCode.executeVarargs(c1));
+ }
+
+ public static Object fieldTest(Object c1) {
+ ((Container) c1).a = ((Container) c1).b;
+ return ((Container) c1).a;
+ }
+
+ @Test
+ public void test1() throws Exception {
+ HotSpotInstalledCode installedBenchmarkCode = getInstalledCode("arrayTest", Object.class, Object.class, Object.class);
+ ArrayContainer ac = new ArrayContainer();
+ Assert.assertEquals(ac.a[9], installedBenchmarkCode.executeVarargs(ac.a, 0, 9));
+ Assert.assertEquals(ac.a[8], installedBenchmarkCode.executeVarargs(ac.a, 1, 8));
+ Assert.assertEquals(ac.a[7], installedBenchmarkCode.executeVarargs(ac.a, 2, 7));
+ Assert.assertEquals(ac.a[6], installedBenchmarkCode.executeVarargs(ac.a, 3, 6));
+ Assert.assertEquals(ac.a[5], installedBenchmarkCode.executeVarargs(ac.a, 4, 5));
+ Assert.assertEquals(ac.a[4], installedBenchmarkCode.executeVarargs(ac.a, 5, 4));
+ Assert.assertEquals(ac.a[3], installedBenchmarkCode.executeVarargs(ac.a, 6, 3));
+ Assert.assertEquals(ac.a[2], installedBenchmarkCode.executeVarargs(ac.a, 7, 2));
+ Assert.assertEquals(ac.a[1], installedBenchmarkCode.executeVarargs(ac.a, 8, 1));
+ Assert.assertEquals(ac.a[0], installedBenchmarkCode.executeVarargs(ac.a, 9, 0));
+ }
+
+ public static Object arrayTest(Object c1, Object c2, Object c3) {
+ Object[] array = (Object[]) c1;
+ int initialIndex = ((Integer) c2).intValue();
+ int replacingIndex = ((Integer) c3).intValue();
+ array[initialIndex] = array[replacingIndex];
+ return array[initialIndex];
+ }
+
+ @Test
+ public void test2() throws Exception {
+ HotSpotInstalledCode installedBenchmarkCode = getInstalledCode("arrayCopyTest", Object.class, Object.class);
+ ArrayContainer source = new ArrayContainer();
+ ArrayContainer destination = new ArrayContainer();
+ Assert.assertEquals(source.a.length, destination.a.length);
+ Assert.assertFalse(Arrays.equals(source.a, destination.a));
+ installedBenchmarkCode.executeVarargs(source.a, destination.a);
+ Assert.assertArrayEquals(source.a, destination.a);
+ }
+
+ public static void arrayCopyTest(Object c1, Object c2) {
+ Object[] source = (Object[]) c1;
+ Object[] destination = (Object[]) c2;
+ System.arraycopy(source, 0, destination, 0, source.length);
+ }
+
+ @Test
+ public void test3() throws Exception {
+ HotSpotInstalledCode installedBenchmarkCode = getInstalledCode("compareAndSwapTest", Object.class, Object.class, Object.class);
+ Object initial = new Object();
+ Object replacement = new Object();
+ AtomicReference<Object> cas = new AtomicReference<>();
+ Assert.assertEquals(cas.get(), null);
+ installedBenchmarkCode.executeVarargs(cas, null, initial);
+ Assert.assertEquals(cas.get(), initial);
+ installedBenchmarkCode.executeVarargs(cas, initial, replacement);
+ Assert.assertEquals(cas.get(), replacement);
+ }
+
+ @SuppressWarnings("unchecked")
+ public static void compareAndSwapTest(Object c1, Object c2, Object c3) throws ClassCastException {
+ AtomicReference<Object> cas = (AtomicReference<Object>) c1;
+ cas.compareAndSet(c2, c3);
+ }
+
+ @Test
+ public void test4() throws Exception {
+ HotSpotInstalledCode installedBenchmarkCode = getInstalledCode("charArrayCopyTest", Object.class, Object.class, Object.class);
+ StringContainer1 source1 = new StringContainer1();
+ StringContainer2 source2 = new StringContainer2();
+ char[] result = new char[source1.value.length + source2.value.length];
+ installedBenchmarkCode.executeVarargs(source1.value, source2.value, result);
+ Assert.assertArrayEquals(new char[]{'T', 'e', 's', 't', ' ', 'S', 't', 'r', 'i', 'n', 'g'}, result);
+ }
+
+ public static char[] charArrayCopyTest(Object c1, Object c2, Object c3) {
+ char[] source1 = (char[]) c1;
+ char[] source2 = (char[]) c2;
+ char[] result = (char[]) c3;
+ for (int i = 0; i < source1.length; i++) {
+ result[i] = source1[i];
+ }
+
+ for (int i = 0; i < source2.length; i++) {
+ result[source1.length + i] = source2[i];
+ }
+ return result;
+ }
+
+ @Test
+ public void test5() throws Exception {
+ HotSpotInstalledCode installedBenchmarkCode = getInstalledCode("charContainerArrayCopyTest", Object.class, Object.class, Object.class);
+ StringContainer1 source1 = new StringContainer1();
+ StringContainer2 source2 = new StringContainer2();
+ char[] result = new char[source1.value.length + source2.value.length];
+ installedBenchmarkCode.executeVarargs(source1, source2, result);
+ Assert.assertArrayEquals(new char[]{'T', 'e', 's', 't', ' ', 'S', 't', 'r', 'i', 'n', 'g'}, result);
+ }
+
+ public static char[] charContainerArrayCopyTest(Object c1, Object c2, Object c3) {
+ char[] source1 = ((StringContainer1) c1).value;
+ char[] source2 = ((StringContainer2) c2).value;
+ char[] result = (char[]) c3;
+ for (int i = 0; i < source1.length; i++) {
+ result[i] = source1[i];
+ }
+ for (int i = 0; i < source2.length; i++) {
+ result[source1.length + i] = source2[i];
+ }
+ return result;
+ }
+
+ @Test
+ public void test6() throws Exception {
+ HotSpotInstalledCode installedBenchmarkCode = getInstalledCode("stringCopyTest", Object.class, Object.class);
+ String a = new String("Test ");
+ String b = new String("String");
+ String c = (String) installedBenchmarkCode.executeVarargs(a, b);
+ Assert.assertTrue(c.equals("Test String"));
+ }
+
+ public static String stringCopyTest(Object c1, Object c2) {
+ String source = (String) c1;
+ String destination = (String) c2;
+ return source + destination;
+ }
+
+ @Test
+ public void test7() throws Exception {
+ HotSpotInstalledCode installedBenchmarkCode = getInstalledCode("queueTest", Object.class, Object.class);
+ ArrayDeque<Object> q = new ArrayDeque<>();
+ Object[] objects = new Object[512];
+ for (int i = 0; i < objects.length; i++) {
+ objects[i] = new Object();
+ }
+ int j = 0;
+ while (j < objects.length) {
+ if (!installedBenchmarkCode.isValid()) {
+ // This can get invalidated due to lack of MDO update
+ installedBenchmarkCode = getInstalledCode("queueTest", Object.class, Object.class);
+ }
+ installedBenchmarkCode.executeVarargs(q, objects[j]);
+ j++;
+ }
+
+ System.gc();
+ Assert.assertTrue(q.size() == objects.length);
+ Assert.assertTrue(!q.isEmpty());
+ j = 0;
+ while (j < objects.length) {
+ Assert.assertTrue(objects[j] == q.remove());
+ j++;
+ }
+
+ Assert.assertTrue(q.size() == 0);
+ Assert.assertTrue(q.isEmpty());
+ }
+
+ @SuppressWarnings("unchecked")
+ public static void queueTest(Object c1, Object c2) {
+ ArrayDeque<Object> queue = (ArrayDeque<Object>) c1;
+ queue.add(c2);
+ }
+
+ @Test
+ public void test8() throws Exception {
+ HotSpotInstalledCode installedBenchmarkCode = getInstalledCode("unmodListTest", Object.class);
+ List<Object> list = new ArrayList<>();
+ for (int i = 0; i < 512; i++) {
+ list.add(new Object());
+ }
+ Object[] array = (Object[]) installedBenchmarkCode.executeVarargs(list);
+ Assert.assertTrue(list.size() == array.length);
+ int i = 0;
+ for (Object obj : list) {
+ Assert.assertTrue(obj == array[i]);
+ i++;
+ }
+ }
+
+ @SuppressWarnings("unchecked")
+ public static Object[] unmodListTest(Object c1) {
+ List<Object> queue = (ArrayList<Object>) c1;
+ Object[] result = Collections.unmodifiableCollection(queue).toArray(new Object[queue.size()]);
+ return result;
+ }
+
+ @Test
+ public void test9() throws Exception {
+ HotSpotInstalledCode installedBenchmarkCode = getInstalledCode("unmodListTest", Object.class);
+ List<Object> list = new ArrayList<>();
+ Object[] array = (Object[]) installedBenchmarkCode.executeVarargs(list);
+ Assert.assertTrue(list.size() == array.length);
+ }
+
+ public void test10() throws Exception {
+ HotSpotInstalledCode installedBenchmarkCode = getInstalledCode("constantTest", Object.class);
+ Container c = new Container();
+ Assert.assertFalse((boolean) installedBenchmarkCode.executeVarargs(c));
+ }
+
+ public static Boolean constantTest(Object c1) {
+ ConstantContainer container = (ConstantContainer) c1;
+ return container.a.equals(container.b);
+ }
+
+ @Test
+ public void test11() throws Exception {
+ HotSpotInstalledCode installedBenchmarkCode = getInstalledCode("stringEqualsTest", Object.class, Object.class);
+ String s1 = new String("Test");
+ String s2 = new String("Test");
+ boolean result = ((Boolean) (installedBenchmarkCode.executeVarargs(s1, s2))).booleanValue();
+ Assert.assertTrue(result);
+ }
+
+ public static Boolean stringEqualsTest(Object c1, Object c2) {
+ return ((String) c1).equals(c2);
+ }
+
+ @Test
+ public void test12() throws Exception {
+ HotSpotInstalledCode installedBenchmarkCode = getInstalledCode("stringConstantEqualsTest", Object.class);
+ String s1 = new String("Test");
+ boolean result = ((Boolean) (installedBenchmarkCode.executeVarargs(s1))).booleanValue();
+ Assert.assertTrue(result);
+ }
+
+ public static Boolean stringConstantEqualsTest(Object c1) {
+ return "Test".equals(c1);
+ }
+
+ @SuppressWarnings("unchecked")
+ public static Object[] unmodListTestByte(Object c1) {
+ List<Byte> queue = (ArrayList<Byte>) c1;
+ Byte[] result = Collections.unmodifiableCollection(queue).toArray(new Byte[queue.size()]);
+ return result;
+ }
+
+ @Test
+ public void test13() throws Exception {
+ HotSpotInstalledCode installedBenchmarkCode = getInstalledCode("unmodListTestByte", Object.class);
+ List<Byte> list = new ArrayList<>();
+ Byte[] array = (Byte[]) installedBenchmarkCode.executeVarargs(list);
+ Assert.assertTrue(list.size() == array.length);
+ }
+
+ @Test
+ public void test14() throws Exception {
+ HotSpotInstalledCode installedBenchmarkCode = getInstalledCode("stringBuilderTest", Object.class, Object.class);
+ StringBuilder buffer = new StringBuilder("TestTestTestTestTestTestTest");
+ Assert.assertTrue(buffer.length() == 28);
+ String a = new String("TestTestTestTestTestTestTest");
+ installedBenchmarkCode.executeVarargs(buffer, a.toCharArray());
+ Assert.assertTrue(buffer.length() == 56);
+ Assert.assertTrue(buffer.toString().equals("TestTestTestTestTestTestTestTestTestTestTestTestTestTest"));
+ }
+
+ public static void stringBuilderTest(Object c1, Object c2) {
+ StringBuilder source = (StringBuilder) c1;
+ char[] add = (char[]) c2;
+ for (int i = 0; i < add.length; i++) {
+ source.append(add[i]);
+ }
+ }
+
+ @Test
+ public void test15() throws Exception {
+ HotSpotInstalledCode installedBenchmarkCode = getInstalledCode("stringBuilderTestIn");
+ installedBenchmarkCode.executeVarargs();
+ }
+
+ public static void stringBuilderTestIn() {
+ StringBuilder buffer = new StringBuilder("TestTestTestTestTestTestTest");
+ Assert.assertTrue(buffer.length() == 28);
+ String a = new String("TestTestTestTestTestTestTest");
+ char[] add = a.toCharArray();
+ for (int i = 0; i < add.length; i++) {
+ buffer.append(add[i]);
+ }
+ Assert.assertTrue(buffer.length() == 56);
+ Assert.assertTrue(buffer.toString().equals("TestTestTestTestTestTestTestTestTestTestTestTestTestTest"));
+ }
+
+ @Test
+ public void test16() throws Exception {
+ HotSpotInstalledCode installedBenchmarkCode = getInstalledCode("stringBuilderArrayCopy");
+ installedBenchmarkCode.executeVarargs();
+ }
+
+ public static void stringBuilderArrayCopy() {
+ StringBuilder buffer = new StringBuilder("TestTestTestTestTestTestTest");
+ Assert.assertTrue(buffer.length() == 28);
+ String a = new String("TestTestTestTestTestTestTest");
+ char[] dst = new char[buffer.length() * 2];
+ System.arraycopy(buffer.toString().toCharArray(), 0, dst, 0, buffer.length());
+ System.arraycopy(a.toCharArray(), 0, dst, buffer.length(), buffer.length());
+ Assert.assertTrue(dst.length == 56);
+ Assert.assertTrue(new String(dst).equals("TestTestTestTestTestTestTestTestTestTestTestTestTestTest"));
+ }
+
+ @Test
+ public void test17() throws Exception {
+ HotSpotInstalledCode installedBenchmarkCode = getInstalledCode("stringFormat");
+ installedBenchmarkCode.executeVarargs();
+ }
+
+ public static void stringFormat() {
+ String.format("Hello %d", 0);
+ String.format("Hello %d", -11);
+ String.format("Hello %d", -2147483648);
+ }
+
+ @Test
+ public void test18() throws Exception {
+ HotSpotInstalledCode installedBenchmarkCode = getInstalledCode("stringBuilder");
+ StringBuilder b = (StringBuilder) installedBenchmarkCode.executeVarargs();
+ Assert.assertTrue(b.capacity() == 16);
+ Assert.assertTrue(b.length() == 0);
+ }
+
+ public static Object stringBuilder() {
+ return new StringBuilder();
+ }
+
+ static class Container {
+
+ public Object a = new Object();
+ public Object b = new Object();
+ }
+
+ static class ArrayContainer {
+
+ public Object[] a = new Object[10];
+
+ ArrayContainer() {
+ for (int i = 0; i < 10; i++) {
+ a[i] = new Object();
+ }
+ }
+ }
+
+ static class HashMapContainer {
+
+ public HashMap<Object, Object> a = new HashMap<>();
+
+ HashMapContainer() {
+ for (int i = 0; i < 10; i++) {
+ a.put(new Object(), new Object());
+ }
+ }
+ }
+
+ static class StringContainer1 {
+
+ public char[] value = new char[5];
+
+ StringContainer1() {
+ value[0] = 'T';
+ value[1] = 'e';
+ value[2] = 's';
+ value[3] = 't';
+ value[4] = ' ';
+
+ }
+ }
+
+ static class StringContainer2 {
+
+ public char[] value = new char[6];
+
+ StringContainer2() {
+ value[0] = 'S';
+ value[1] = 't';
+ value[2] = 'r';
+ value[3] = 'i';
+ value[4] = 'n';
+ value[5] = 'g';
+ }
+ }
+
+ static class ConstantContainer {
+
+ public final Object a = new Object();
+ public final Object b = new Object();
+
+ ConstantContainer() {
+
+ }
+ }
+}