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 8138583

    27  * @summary Add C2 AArch64 Superword support for scalar sum reduction optimizations : float abs & neg test

    28  * @requires os.arch=="aarch64"

    29  *

    30  * @run main/othervm -XX:+IgnoreUnrecognizedVMOptions -XX:LoopUnrollLimit=250

    31  *      -XX:CompileThresholdScaling=0.1

    32  *      -XX:+SuperWordReductions

    33  *      -XX:LoopMaxUnroll=2

    34  *      compiler.loopopts.superword.SumRedAbsNeg_Double

    35  * @run main/othervm -XX:+IgnoreUnrecognizedVMOptions -XX:LoopUnrollLimit=250

    36  *      -XX:CompileThresholdScaling=0.1

    37  *      -XX:-SuperWordReductions

    38  *      -XX:LoopMaxUnroll=2

    39  *      compiler.loopopts.superword.SumRedAbsNeg_Double

    40  *

    41  * @run main/othervm -XX:+IgnoreUnrecognizedVMOptions -XX:LoopUnrollLimit=250

    42  *      -XX:CompileThresholdScaling=0.1

    43  *      -XX:+SuperWordReductions

    44  *      -XX:LoopMaxUnroll=4

    45  *      compiler.loopopts.superword.SumRedAbsNeg_Double

    46  * @run main/othervm -XX:+IgnoreUnrecognizedVMOptions -XX:LoopUnrollLimit=250

    47  *      -XX:CompileThresholdScaling=0.1

    48  *      -XX:-SuperWordReductions

    49  *      -XX:LoopMaxUnroll=4

    50  *      compiler.loopopts.superword.SumRedAbsNeg_Double

    51  *

    52  * @run main/othervm -XX:+IgnoreUnrecognizedVMOptions -XX:LoopUnrollLimit=250

    53  *      -XX:CompileThresholdScaling=0.1

    54  *      -XX:+SuperWordReductions

    55  *      -XX:LoopMaxUnroll=8

    56  *      compiler.loopopts.superword.SumRedAbsNeg_Double

    57  * @run main/othervm -XX:+IgnoreUnrecognizedVMOptions -XX:LoopUnrollLimit=250

    58  *      -XX:CompileThresholdScaling=0.1

    59  *      -XX:-SuperWordReductions

    60  *      -XX:LoopMaxUnroll=8

    61  *      compiler.loopopts.superword.SumRedAbsNeg_Double

    62  *

    63  * @run main/othervm -XX:+IgnoreUnrecognizedVMOptions -XX:LoopUnrollLimit=250

    64  *      -XX:CompileThresholdScaling=0.1

    65  *      -XX:+SuperWordReductions

    66  *      -XX:LoopMaxUnroll=16

    67  *      compiler.loopopts.superword.SumRedAbsNeg_Double

    68  * @run main/othervm -XX:+IgnoreUnrecognizedVMOptions -XX:LoopUnrollLimit=250

    69  *      -XX:CompileThresholdScaling=0.1

    70  *      -XX:-SuperWordReductions

    71  *      -XX:LoopMaxUnroll=16

    72  *      compiler.loopopts.superword.SumRedAbsNeg_Double

    73  */

    74 

    75 package compiler.loopopts.superword;

    76 

    77 public class SumRedAbsNeg_Float {

    78     public static void main(String[] args) throws Exception {

    79         float[] a = new float[256 * 1024];

    80         float[] b = new float[256 * 1024];

    81         float[] c = new float[256 * 1024];

    82         float[] d = new float[256 * 1024];

    83         sumReductionInit(a, b, c);

    84         float total = 0;

    85         float valid = (float) 4.611686E18;

    86 

    87         for (int j = 0; j < 2000; j++) {

    88             total = sumReductionImplement(a, b, c, d, total);

    89         }

    90 

    91         if (total == valid) {

    92             System.out.println("Success");

    93         } else {

    94             System.out.println("Invalid sum of elements variable in total: " + total);

    95             System.out.println("Expected value = " + valid);

    96             throw new Exception("Failed");

    97         }

    98     }

    99 

   100     public static void sumReductionInit(

   101             float[] a,

   102             float[] b,

   103             float[] c) {

   104         for (int j = 0; j < 1; j++) {

   105             for (int i = 0; i < a.length; i++) {

   106                 a[i] = i * 1 + j;

   107                 b[i] = i * 1 - j;

   108                 c[i] = i + j;

   109             }

   110         }

   111     }

   112 

   113     public static float sumReductionImplement(

   114             float[] a,

   115             float[] b,

   116             float[] c,

   117             float[] d,

   118             float total) {

   119         for (int i = 0; i < a.length; i++) {

   120             d[i] = Math.abs(-a[i] * -b[i]) + Math.abs(-a[i] * -c[i]) + Math.abs(-b[i] * -c[i]);

   121             total += d[i];

   122         }

   123         return total;

   124     }

   125 

   126 }