--- /dev/null 2016-05-31 09:42:47.975716356 -0700 +++ new/src/jdk.vm.compiler/share/classes/org.graalvm.compiler.hotspot.test/src/org/graalvm/compiler/hotspot/test/CompressedOopTest.java 2016-12-09 00:49:05.429260110 -0800 @@ -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 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 cas = (AtomicReference) 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 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 queue = (ArrayDeque) c1; + queue.add(c2); + } + + @Test + public void test8() throws Exception { + HotSpotInstalledCode installedBenchmarkCode = getInstalledCode("unmodListTest", Object.class); + List 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 queue = (ArrayList) 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 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 queue = (ArrayList) 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 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 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() { + + } + } +}