test/hotspot/jtreg/compiler/loopopts/TestMoveStoresOutOfLoops.java - platform/libcore - Git at Google

 /*
  * Copyright (c) 2015, 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.
  */

 /**
  * @test
  * @bug 8080289 8189067
  * @summary Move stores out of loops if possible
  *
  * @run main/othervm -XX:-UseOnStackReplacement -XX:-BackgroundCompilation
  *      -XX:CompileCommand=dontinline,compiler.loopopts.TestMoveStoresOutOfLoops::test*
  *      compiler.loopopts.TestMoveStoresOutOfLoops
  */

 package compiler.loopopts;

 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
 import java.util.HashMap;
 import java.util.function.Function;

 public class TestMoveStoresOutOfLoops {

     private static long[] array = new long[10];
     private static long[] array2 = new long[10];
     private static boolean[] array3 = new boolean[1000];
     private static int[] array4 = new int[1000];
     private static byte[] byte_array = new byte[10];

     // Array store should be moved out of the loop, value stored
     // should be 999, the loop should be eliminated
     static void test_after_1(int idx) {
         for (int i = 0; i < 1000; i++) {
             array[idx] = i;
         }
     }

     // Array store can't be moved out of loop because of following
     // non loop invariant array access
     static void test_after_2(int idx) {
         for (int i = 0; i < 1000; i++) {
             array[idx] = i;
             array2[i%10] = i;
         }
     }

     // Array store can't be moved out of loop because of following
     // use
     static void test_after_3(int idx) {
         for (int i = 0; i < 1000; i++) {
             array[idx] = i;
             if (array[0] == -1) {
                 break;
             }
         }
     }

     // Array store can't be moved out of loop because of preceding
     // use
     static void test_after_4(int idx) {
         for (int i = 0; i < 1000; i++) {
             if (array[0] == -2) {
                 break;
             }
             array[idx] = i;
         }
     }

     // All array stores should be moved out of the loop, one after
     // the other
     static void test_after_5(int idx) {
         for (int i = 0; i < 1000; i++) {
             array[idx] = i;
             array[idx+1] = i;
             array[idx+2] = i;
             array[idx+3] = i;
             array[idx+4] = i;
             array[idx+5] = i;
         }
     }

     // Array store can be moved after the loop but needs to be
     // cloned on both exit paths
     static void test_after_6(int idx) {
         for (int i = 0; i < 1000; i++) {
             array[idx] = i;
             if (array3[i]) {
                 return;
             }
         }
     }

     // Array store can be moved out of the inner loop
     static void test_after_7(int idx) {
         for (int i = 0; i < 1000; i++) {
             for (int j = 0; j <= 42; j++) {
                 array4[i] = j;
             }
         }
     }

     // Optimize out redundant stores
     static void test_stores_1(int ignored) {
         array[0] = 0;
         array[1] = 1;
         array[2] = 2;
         array[0] = 0;
         array[1] = 1;
         array[2] = 2;
     }

     static void test_stores_2(int idx) {
         array[idx+0] = 0;
         array[idx+1] = 1;
         array[idx+2] = 2;
         array[idx+0] = 0;
         array[idx+1] = 1;
         array[idx+2] = 2;
     }

     static void test_stores_3(int idx) {
         byte_array[idx+0] = 0;
         byte_array[idx+1] = 1;
         byte_array[idx+2] = 2;
         byte_array[idx+0] = 0;
         byte_array[idx+1] = 1;
         byte_array[idx+2] = 2;
     }

     // Array store can be moved out of the loop before the loop header
     static void test_before_1(int idx) {
         for (int i = 0; i < 1000; i++) {
             array[idx] = 999;
         }
     }

     // Array store can't be moved out of the loop before the loop
     // header because there's more than one store on this slice
     static void test_before_2(int idx) {
         for (int i = 0; i < 1000; i++) {
             array[idx] = 999;
             array[i%2] = 0;
         }
     }

     // Array store can't be moved out of the loop before the loop
     // header because of use before store
     static int test_before_3(int idx) {
         int res = 0;
         for (int i = 0; i < 1000; i++) {
             res += array[i%10];
             array[idx] = 999;
         }
         return res;
     }

     // Array store can't be moved out of the loop before the loop
     // header because of possible early exit
     static void test_before_4(int idx) {
         for (int i = 0; i < 1000; i++) {
             if (idx / (i+1) > 0) {
                 return;
             }
             array[idx] = 999;
         }
     }

     // Array store can't be moved out of the loop before the loop
     // header because it doesn't postdominate the loop head
     static void test_before_5(int idx) {
         for (int i = 0; i < 1000; i++) {
             if (i % 2 == 0) {
                 array[idx] = 999;
             }
         }
     }

     // Array store can be moved out of the loop before the loop header
     static int test_before_6(int idx) {
         int res = 0;
         for (int i = 0; i < 1000; i++) {
             if (i%2 == 1) {
                 res *= 2;
             } else {
                 res++;
             }
             array[idx] = 999;
         }
         return res;
     }

     final HashMap<String,Method> tests = new HashMap<>();
     {
         for (Method m : this.getClass().getDeclaredMethods()) {
             if (m.getName().matches("test_(before|after|stores)_[0-9]+")) {
                 assert(Modifier.isStatic(m.getModifiers())) : m;
                 tests.put(m.getName(), m);
             }
         }
     }

     boolean success = true;
     void doTest(String name, Runnable init, Function<String, Boolean> check) throws Exception {
         Method m = tests.get(name);
         for (int i = 0; i < 20000; i++) {
             init.run();
             m.invoke(null, 0);
             success = success && check.apply(name);
             if (!success) {
                 break;
             }
         }
     }

     static void array_init() {
         array[0] = -1;
     }

     static boolean array_check(String name) {
         boolean success = true;
         if (array[0] != 999) {
             success = false;
             System.out.println(name + " failed: array[0] = " + array[0]);
         }
         return success;
     }

     static void array_init2() {
         for (int i = 0; i < 6; i++) {
             array[i] = -1;
         }
     }

     static boolean array_check2(String name) {
         boolean success = true;
         for (int i = 0; i < 6; i++) {
             if (array[i] != 999) {
                 success = false;
                 System.out.println(name + " failed: array[" + i + "] = " + array[i]);
             }
         }
         return success;
     }

     static void array_init3() {
         for (int i = 0; i < 3; i++) {
             array[i] = -1;
         }
     }

     static boolean array_check3(String name) {
         boolean success = true;
         for (int i = 0; i < 3; i++) {
             if (array[i] != i) {
                 success = false;
                 System.out.println(name + " failed: array[" + i + "] = " + array[i]);
             }
         }
         return success;
     }

     static void array_init4() {
         for (int i = 0; i < 3; i++) {
             byte_array[i] = -1;
         }
     }

     static boolean array_check4(String name) {
         boolean success = true;
         for (int i = 0; i < 3; i++) {
             if (byte_array[i] != i) {
                 success = false;
                 System.out.println(name + " failed: byte_array[" + i + "] = " + byte_array[i]);
             }
         }
         return success;
     }

     static boolean array_check5(String name) {
         boolean success = true;
         for (int i = 0; i < 1000; i++) {
             if (array4[i] != 42) {
                 success = false;
                 System.out.println(name + " failed: array[" + i + "] = " + array4[i]);
             }
         }
         return success;
     }

     static public void main(String[] args) throws Exception {
         TestMoveStoresOutOfLoops test = new TestMoveStoresOutOfLoops();
         test.doTest("test_after_1", TestMoveStoresOutOfLoops::array_init, TestMoveStoresOutOfLoops::array_check);
         test.doTest("test_after_2", TestMoveStoresOutOfLoops::array_init, TestMoveStoresOutOfLoops::array_check);
         test.doTest("test_after_3", TestMoveStoresOutOfLoops::array_init, TestMoveStoresOutOfLoops::array_check);
         test.doTest("test_after_4", TestMoveStoresOutOfLoops::array_init, TestMoveStoresOutOfLoops::array_check);
         test.doTest("test_after_5", TestMoveStoresOutOfLoops::array_init2, TestMoveStoresOutOfLoops::array_check2);
         test.doTest("test_after_6", TestMoveStoresOutOfLoops::array_init, TestMoveStoresOutOfLoops::array_check);
         array3[999] = true;
         test.doTest("test_after_6", TestMoveStoresOutOfLoops::array_init, TestMoveStoresOutOfLoops::array_check);
         test.doTest("test_after_7", TestMoveStoresOutOfLoops::array_init, TestMoveStoresOutOfLoops::array_check5);

         test.doTest("test_stores_1", TestMoveStoresOutOfLoops::array_init3, TestMoveStoresOutOfLoops::array_check3);
         test.doTest("test_stores_2", TestMoveStoresOutOfLoops::array_init3, TestMoveStoresOutOfLoops::array_check3);
         test.doTest("test_stores_3", TestMoveStoresOutOfLoops::array_init4, TestMoveStoresOutOfLoops::array_check4);

         test.doTest("test_before_1", TestMoveStoresOutOfLoops::array_init, TestMoveStoresOutOfLoops::array_check);
         test.doTest("test_before_2", TestMoveStoresOutOfLoops::array_init, TestMoveStoresOutOfLoops::array_check);
         test.doTest("test_before_3", TestMoveStoresOutOfLoops::array_init, TestMoveStoresOutOfLoops::array_check);
         test.doTest("test_before_4", TestMoveStoresOutOfLoops::array_init, TestMoveStoresOutOfLoops::array_check);
         test.doTest("test_before_5", TestMoveStoresOutOfLoops::array_init, TestMoveStoresOutOfLoops::array_check);
         test.doTest("test_before_6", TestMoveStoresOutOfLoops::array_init, TestMoveStoresOutOfLoops::array_check);

         if (!test.success) {
             throw new RuntimeException("Some tests failed");
         }
     }
 }
	/*
	* Copyright (c) 2015, 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.
	*/

	/**
	* @test
	* @bug 8080289 8189067
	* @summary Move stores out of loops if possible
	*
	* @run main/othervm -XX:-UseOnStackReplacement -XX:-BackgroundCompilation
	* -XX:CompileCommand=dontinline,compiler.loopopts.TestMoveStoresOutOfLoops::test*
	* compiler.loopopts.TestMoveStoresOutOfLoops
	*/

	package compiler.loopopts;

	import java.lang.reflect.Method;
	import java.lang.reflect.Modifier;
	import java.util.HashMap;
	import java.util.function.Function;

	public class TestMoveStoresOutOfLoops {

	private static long[] array = new long[10];
	private static long[] array2 = new long[10];
	private static boolean[] array3 = new boolean[1000];
	private static int[] array4 = new int[1000];
	private static byte[] byte_array = new byte[10];

	// Array store should be moved out of the loop, value stored
	// should be 999, the loop should be eliminated
	static void test_after_1(int idx) {
	for (int i = 0; i < 1000; i++) {
	array[idx] = i;
	}
	}

	// Array store can't be moved out of loop because of following
	// non loop invariant array access
	static void test_after_2(int idx) {
	for (int i = 0; i < 1000; i++) {
	array[idx] = i;
	array2[i%10] = i;
	}
	}

	// Array store can't be moved out of loop because of following
	// use
	static void test_after_3(int idx) {
	for (int i = 0; i < 1000; i++) {
	array[idx] = i;
	if (array[0] == -1) {
	break;
	}
	}
	}

	// Array store can't be moved out of loop because of preceding
	// use
	static void test_after_4(int idx) {
	for (int i = 0; i < 1000; i++) {
	if (array[0] == -2) {
	break;
	}
	array[idx] = i;
	}
	}

	// All array stores should be moved out of the loop, one after
	// the other
	static void test_after_5(int idx) {
	for (int i = 0; i < 1000; i++) {
	array[idx] = i;
	array[idx+1] = i;
	array[idx+2] = i;
	array[idx+3] = i;
	array[idx+4] = i;
	array[idx+5] = i;
	}
	}

	// Array store can be moved after the loop but needs to be
	// cloned on both exit paths
	static void test_after_6(int idx) {
	for (int i = 0; i < 1000; i++) {
	array[idx] = i;
	if (array3[i]) {
	return;
	}
	}
	}

	// Array store can be moved out of the inner loop
	static void test_after_7(int idx) {
	for (int i = 0; i < 1000; i++) {
	for (int j = 0; j <= 42; j++) {
	array4[i] = j;
	}
	}
	}

	// Optimize out redundant stores
	static void test_stores_1(int ignored) {
	array[0] = 0;
	array[1] = 1;
	array[2] = 2;
	array[0] = 0;
	array[1] = 1;
	array[2] = 2;
	}

	static void test_stores_2(int idx) {
	array[idx+0] = 0;
	array[idx+1] = 1;
	array[idx+2] = 2;
	array[idx+0] = 0;
	array[idx+1] = 1;
	array[idx+2] = 2;
	}

	static void test_stores_3(int idx) {
	byte_array[idx+0] = 0;
	byte_array[idx+1] = 1;
	byte_array[idx+2] = 2;
	byte_array[idx+0] = 0;
	byte_array[idx+1] = 1;
	byte_array[idx+2] = 2;
	}

	// Array store can be moved out of the loop before the loop header
	static void test_before_1(int idx) {
	for (int i = 0; i < 1000; i++) {
	array[idx] = 999;
	}
	}

	// Array store can't be moved out of the loop before the loop
	// header because there's more than one store on this slice
	static void test_before_2(int idx) {
	for (int i = 0; i < 1000; i++) {
	array[idx] = 999;
	array[i%2] = 0;
	}
	}

	// Array store can't be moved out of the loop before the loop
	// header because of use before store
	static int test_before_3(int idx) {
	int res = 0;
	for (int i = 0; i < 1000; i++) {
	res += array[i%10];
	array[idx] = 999;
	}
	return res;
	}

	// Array store can't be moved out of the loop before the loop
	// header because of possible early exit
	static void test_before_4(int idx) {
	for (int i = 0; i < 1000; i++) {
	if (idx / (i+1) > 0) {
	return;
	}
	array[idx] = 999;
	}
	}

	// Array store can't be moved out of the loop before the loop
	// header because it doesn't postdominate the loop head
	static void test_before_5(int idx) {
	for (int i = 0; i < 1000; i++) {
	if (i % 2 == 0) {
	array[idx] = 999;
	}
	}
	}

	// Array store can be moved out of the loop before the loop header
	static int test_before_6(int idx) {
	int res = 0;
	for (int i = 0; i < 1000; i++) {
	if (i%2 == 1) {
	res *= 2;
	} else {
	res++;
	}
	array[idx] = 999;
	}
	return res;
	}

	final HashMap<String,Method> tests = new HashMap<>();
	{
	for (Method m : this.getClass().getDeclaredMethods()) {
	if (m.getName().matches("test_(before\|after\|stores)_[0-9]+")) {
	assert(Modifier.isStatic(m.getModifiers())) : m;
	tests.put(m.getName(), m);
	}
	}
	}

	boolean success = true;
	void doTest(String name, Runnable init, Function<String, Boolean> check) throws Exception {
	Method m = tests.get(name);
	for (int i = 0; i < 20000; i++) {
	init.run();
	m.invoke(null, 0);
	success = success && check.apply(name);
	if (!success) {
	break;
	}
	}
	}

	static void array_init() {
	array[0] = -1;
	}

	static boolean array_check(String name) {
	boolean success = true;
	if (array[0] != 999) {
	success = false;
	System.out.println(name + " failed: array[0] = " + array[0]);
	}
	return success;
	}

	static void array_init2() {
	for (int i = 0; i < 6; i++) {
	array[i] = -1;
	}
	}

	static boolean array_check2(String name) {
	boolean success = true;
	for (int i = 0; i < 6; i++) {
	if (array[i] != 999) {
	success = false;
	System.out.println(name + " failed: array[" + i + "] = " + array[i]);
	}
	}
	return success;
	}

	static void array_init3() {
	for (int i = 0; i < 3; i++) {
	array[i] = -1;
	}
	}

	static boolean array_check3(String name) {
	boolean success = true;
	for (int i = 0; i < 3; i++) {
	if (array[i] != i) {
	success = false;
	System.out.println(name + " failed: array[" + i + "] = " + array[i]);
	}
	}
	return success;
	}

	static void array_init4() {
	for (int i = 0; i < 3; i++) {
	byte_array[i] = -1;
	}
	}

	static boolean array_check4(String name) {
	boolean success = true;
	for (int i = 0; i < 3; i++) {
	if (byte_array[i] != i) {
	success = false;
	System.out.println(name + " failed: byte_array[" + i + "] = " + byte_array[i]);
	}
	}
	return success;
	}

	static boolean array_check5(String name) {
	boolean success = true;
	for (int i = 0; i < 1000; i++) {
	if (array4[i] != 42) {
	success = false;
	System.out.println(name + " failed: array[" + i + "] = " + array4[i]);
	}
	}
	return success;
	}

	static public void main(String[] args) throws Exception {
	TestMoveStoresOutOfLoops test = new TestMoveStoresOutOfLoops();
	test.doTest("test_after_1", TestMoveStoresOutOfLoops::array_init, TestMoveStoresOutOfLoops::array_check);
	test.doTest("test_after_2", TestMoveStoresOutOfLoops::array_init, TestMoveStoresOutOfLoops::array_check);
	test.doTest("test_after_3", TestMoveStoresOutOfLoops::array_init, TestMoveStoresOutOfLoops::array_check);
	test.doTest("test_after_4", TestMoveStoresOutOfLoops::array_init, TestMoveStoresOutOfLoops::array_check);
	test.doTest("test_after_5", TestMoveStoresOutOfLoops::array_init2, TestMoveStoresOutOfLoops::array_check2);
	test.doTest("test_after_6", TestMoveStoresOutOfLoops::array_init, TestMoveStoresOutOfLoops::array_check);
	array3[999] = true;
	test.doTest("test_after_6", TestMoveStoresOutOfLoops::array_init, TestMoveStoresOutOfLoops::array_check);
	test.doTest("test_after_7", TestMoveStoresOutOfLoops::array_init, TestMoveStoresOutOfLoops::array_check5);

	test.doTest("test_stores_1", TestMoveStoresOutOfLoops::array_init3, TestMoveStoresOutOfLoops::array_check3);
	test.doTest("test_stores_2", TestMoveStoresOutOfLoops::array_init3, TestMoveStoresOutOfLoops::array_check3);
	test.doTest("test_stores_3", TestMoveStoresOutOfLoops::array_init4, TestMoveStoresOutOfLoops::array_check4);

	test.doTest("test_before_1", TestMoveStoresOutOfLoops::array_init, TestMoveStoresOutOfLoops::array_check);
	test.doTest("test_before_2", TestMoveStoresOutOfLoops::array_init, TestMoveStoresOutOfLoops::array_check);
	test.doTest("test_before_3", TestMoveStoresOutOfLoops::array_init, TestMoveStoresOutOfLoops::array_check);
	test.doTest("test_before_4", TestMoveStoresOutOfLoops::array_init, TestMoveStoresOutOfLoops::array_check);
	test.doTest("test_before_5", TestMoveStoresOutOfLoops::array_init, TestMoveStoresOutOfLoops::array_check);
	test.doTest("test_before_6", TestMoveStoresOutOfLoops::array_init, TestMoveStoresOutOfLoops::array_check);

	if (!test.success) {
	throw new RuntimeException("Some tests failed");
	}
	}
	}