| /* |
| * Copyright (C) 2017 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| /** |
| * Tests for simple integral reductions: same type for accumulator and data. |
| */ |
| public class Main { |
| |
| static final int N = 500; |
| static final int M = 100; |
| |
| // |
| // Basic reductions in loops. |
| // |
| |
| // TODO: vectorize these (second step of b/64091002 plan) |
| |
| private static byte reductionByte(byte[] x) { |
| byte sum = 0; |
| for (int i = 0; i < x.length; i++) { |
| sum += x[i]; |
| } |
| return sum; |
| } |
| |
| private static short reductionShort(short[] x) { |
| short sum = 0; |
| for (int i = 0; i < x.length; i++) { |
| sum += x[i]; |
| } |
| return sum; |
| } |
| |
| private static char reductionChar(char[] x) { |
| char sum = 0; |
| for (int i = 0; i < x.length; i++) { |
| sum += x[i]; |
| } |
| return sum; |
| } |
| |
| /// CHECK-START: int Main.reductionInt(int[]) loop_optimization (before) |
| /// CHECK-DAG: <<Cons0:i\d+>> IntConstant 0 loop:none |
| /// CHECK-DAG: <<Cons1:i\d+>> IntConstant 1 loop:none |
| /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none |
| /// CHECK-DAG: <<Phi2:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: <<Get:i\d+>> ArrayGet [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: Add [<<Phi2>>,<<Get>>] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: Add [<<Phi1>>,<<Cons1>>] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: Return [<<Phi2>>] loop:none |
| // |
| /// CHECK-START-{ARM,ARM64,MIPS64}: int Main.reductionInt(int[]) loop_optimization (after) |
| /// CHECK-DAG: <<Cons:i\d+>> IntConstant {{2|4}} loop:none |
| /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [{{i\d+}}] loop:none |
| /// CHECK-DAG: <<Phi:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop:B\d+>> outer_loop:none |
| /// CHECK-DAG: <<Load:d\d+>> VecLoad [{{l\d+}},<<I:i\d+>>] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: VecAdd [<<Phi>>,<<Load>>] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: Add [<<I>>,<<Cons>>] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: <<Red:d\d+>> VecReduce [<<Phi>>] loop:none |
| /// CHECK-DAG: <<Extr:i\d+>> VecExtractScalar [<<Red>>] loop:none |
| private static int reductionInt(int[] x) { |
| int sum = 0; |
| for (int i = 0; i < x.length; i++) { |
| sum += x[i]; |
| } |
| return sum; |
| } |
| |
| /// CHECK-START: int Main.reductionIntChain() loop_optimization (before) |
| /// CHECK-DAG: <<Cons0:i\d+>> IntConstant 0 loop:none |
| /// CHECK-DAG: <<Cons1:i\d+>> IntConstant 1 loop:none |
| /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons1>>,{{i\d+}}] loop:<<Loop1:B\d+>> outer_loop:none |
| /// CHECK-DAG: <<Phi2:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop1>> outer_loop:none |
| /// CHECK-DAG: <<Get1:i\d+>> ArrayGet [{{l\d+}},<<Phi2>>] loop:<<Loop1>> outer_loop:none |
| /// CHECK-DAG: Add [<<Phi1>>,<<Get1>>] loop:<<Loop1>> outer_loop:none |
| /// CHECK-DAG: Add [<<Phi2>>,<<Cons1>>] loop:<<Loop1>> outer_loop:none |
| /// CHECK-DAG: <<Phi3:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop2:B\d+>> outer_loop:none |
| /// CHECK-DAG: <<Phi4:i\d+>> Phi [<<Phi1>>,{{i\d+}}] loop:<<Loop2>> outer_loop:none |
| /// CHECK-DAG: <<Get2:i\d+>> ArrayGet [{{l\d+}},<<Phi3>>] loop:<<Loop2>> outer_loop:none |
| /// CHECK-DAG: Add [<<Phi4>>,<<Get2>>] loop:<<Loop2>> outer_loop:none |
| /// CHECK-DAG: Add [<<Phi3>>,<<Cons1>>] loop:<<Loop2>> outer_loop:none |
| /// CHECK-DAG: Return [<<Phi4>>] loop:none |
| // |
| /// CHECK-EVAL: "<<Loop1>>" != "<<Loop2>>" |
| // |
| /// CHECK-START-{ARM,ARM64,MIPS64}: int Main.reductionIntChain() loop_optimization (after) |
| /// CHECK-DAG: <<Set1:d\d+>> VecSetScalars [{{i\d+}}] loop:none |
| /// CHECK-DAG: <<Phi1:d\d+>> Phi [<<Set1>>,{{d\d+}}] loop:<<Loop1:B\d+>> outer_loop:none |
| /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<I1:i\d+>>] loop:<<Loop1>> outer_loop:none |
| /// CHECK-DAG: VecAdd [<<Phi1>>,<<Load1>>] loop:<<Loop1>> outer_loop:none |
| /// CHECK-DAG: Add [<<I1>>,{{i\d+}}] loop:<<Loop1>> outer_loop:none |
| /// CHECK-DAG: <<Red1:d\d+>> VecReduce [<<Phi1>>] loop:none |
| /// CHECK-DAG: <<Extr1:i\d+>> VecExtractScalar [<<Red1>>] loop:none |
| /// CHECK-DAG: <<Set2:d\d+>> VecSetScalars [{{i\d+}}] loop:none |
| /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set2>>,{{d\d+}}] loop:<<Loop2:B\d+>> outer_loop:none |
| /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<I2:i\d+>>] loop:<<Loop2>> outer_loop:none |
| /// CHECK-DAG: VecAdd [<<Phi2>>,<<Load2>>] loop:<<Loop2>> outer_loop:none |
| /// CHECK-DAG: Add [<<I2>>,{{i\d+}}] loop:<<Loop2>> outer_loop:none |
| /// CHECK-DAG: <<Red2:d\d+>> VecReduce [<<Phi2>>] loop:none |
| /// CHECK-DAG: <<Extr2:i\d+>> VecExtractScalar [<<Red2>>] loop:none |
| // |
| /// CHECK-EVAL: "<<Loop1>>" != "<<Loop2>>" |
| // |
| // NOTE: pattern is robust with respect to vector loop unrolling and peeling. |
| private static int reductionIntChain() { |
| int[] x = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 }; |
| int r = 1; |
| for (int i = 0; i < 16; i++) { |
| r += x[i]; |
| } |
| for (int i = 0; i < 16; i++) { |
| r += x[i]; |
| } |
| return r; |
| } |
| |
| /// CHECK-START: int Main.reductionIntToLoop(int[]) loop_optimization (before) |
| /// CHECK-DAG: <<Cons0:i\d+>> IntConstant 0 loop:none |
| /// CHECK-DAG: <<Cons1:i\d+>> IntConstant 1 loop:none |
| /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop1:B\d+>> outer_loop:none |
| /// CHECK-DAG: <<Phi2:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop1>> outer_loop:none |
| /// CHECK-DAG: <<Get:i\d+>> ArrayGet [{{l\d+}},<<Phi1>>] loop:<<Loop1>> outer_loop:none |
| /// CHECK-DAG: Add [<<Phi2>>,<<Get>>] loop:<<Loop1>> outer_loop:none |
| /// CHECK-DAG: Add [<<Phi1>>,<<Cons1>>] loop:<<Loop1>> outer_loop:none |
| /// CHECK-DAG: <<Phi3:i\d+>> Phi [<<Phi2>>,{{i\d+}}] loop:<<Loop2:B\d+>> outer_loop:none |
| /// CHECK-DAG: <<Phi4:i\d+>> Phi [<<Phi2>>,{{i\d+}}] loop:<<Loop2>> outer_loop:none |
| // |
| /// CHECK-EVAL: "<<Loop1>>" != "<<Loop2>>" |
| // |
| /// CHECK-START-{ARM,ARM64,MIPS64}: int Main.reductionIntToLoop(int[]) loop_optimization (after) |
| /// CHECK-DAG: <<Cons:i\d+>> IntConstant {{2|4}} loop:none |
| /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [{{i\d+}}] loop:none |
| /// CHECK-DAG: <<Phi:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop1:B\d+>> outer_loop:none |
| /// CHECK-DAG: <<Load:d\d+>> VecLoad [{{l\d+}},<<I:i\d+>>] loop:<<Loop1>> outer_loop:none |
| /// CHECK-DAG: VecAdd [<<Phi>>,<<Load>>] loop:<<Loop1>> outer_loop:none |
| /// CHECK-DAG: Add [<<I>>,<<Cons>>] loop:<<Loop1>> outer_loop:none |
| /// CHECK-DAG: <<Red:d\d+>> VecReduce [<<Phi>>] loop:none |
| /// CHECK-DAG: <<Extr:i\d+>> VecExtractScalar [<<Red>>] loop:none |
| private static int reductionIntToLoop(int[] x) { |
| int r = 0; |
| for (int i = 0; i < 8; i++) { |
| r += x[i]; |
| } |
| for (int i = r; i < 16; i++) { |
| r += i; |
| } |
| return r; |
| } |
| |
| /// CHECK-START: long Main.reductionLong(long[]) loop_optimization (before) |
| /// CHECK-DAG: <<Cons0:i\d+>> IntConstant 0 loop:none |
| /// CHECK-DAG: <<Long0:j\d+>> LongConstant 0 loop:none |
| /// CHECK-DAG: <<Cons1:i\d+>> IntConstant 1 loop:none |
| /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none |
| /// CHECK-DAG: <<Phi2:j\d+>> Phi [<<Long0>>,{{j\d+}}] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: <<Get:j\d+>> ArrayGet [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: Add [<<Phi2>>,<<Get>>] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: Add [<<Phi1>>,<<Cons1>>] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: Return [<<Phi2>>] loop:none |
| // |
| /// CHECK-START-{ARM64,MIPS64}: long Main.reductionLong(long[]) loop_optimization (after) |
| /// CHECK-DAG: <<Cons2:i\d+>> IntConstant 2 loop:none |
| /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [{{j\d+}}] loop:none |
| /// CHECK-DAG: <<Phi:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop:B\d+>> outer_loop:none |
| /// CHECK-DAG: <<Load:d\d+>> VecLoad [{{l\d+}},<<I:i\d+>>] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: VecAdd [<<Phi>>,<<Load>>] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: Add [<<I>>,<<Cons2>>] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: <<Red:d\d+>> VecReduce [<<Phi>>] loop:none |
| /// CHECK-DAG: <<Extr:j\d+>> VecExtractScalar [<<Red>>] loop:none |
| private static long reductionLong(long[] x) { |
| long sum = 0; |
| for (int i = 0; i < x.length; i++) { |
| sum += x[i]; |
| } |
| return sum; |
| } |
| |
| private static byte reductionByteM1(byte[] x) { |
| byte sum = -1; |
| for (int i = 0; i < x.length; i++) { |
| sum += x[i]; |
| } |
| return sum; |
| } |
| |
| private static short reductionShortM1(short[] x) { |
| short sum = -1; |
| for (int i = 0; i < x.length; i++) { |
| sum += x[i]; |
| } |
| return sum; |
| } |
| |
| private static char reductionCharM1(char[] x) { |
| char sum = 0xffff; |
| for (int i = 0; i < x.length; i++) { |
| sum += x[i]; |
| } |
| return sum; |
| } |
| |
| /// CHECK-START: int Main.reductionIntM1(int[]) loop_optimization (before) |
| /// CHECK-DAG: <<Cons0:i\d+>> IntConstant 0 loop:none |
| /// CHECK-DAG: <<Cons1:i\d+>> IntConstant 1 loop:none |
| /// CHECK-DAG: <<ConsM1:i\d+>> IntConstant -1 loop:none |
| /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none |
| /// CHECK-DAG: <<Phi2:i\d+>> Phi [<<ConsM1>>,{{i\d+}}] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: <<Get:i\d+>> ArrayGet [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: Add [<<Phi2>>,<<Get>>] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: Add [<<Phi1>>,<<Cons1>>] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: Return [<<Phi2>>] loop:none |
| // |
| /// CHECK-START-{ARM,ARM64,MIPS64}: int Main.reductionIntM1(int[]) loop_optimization (after) |
| /// CHECK-DAG: <<Cons:i\d+>> IntConstant {{2|4}} loop:none |
| /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [{{i\d+}}] loop:none |
| /// CHECK-DAG: <<Phi:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop:B\d+>> outer_loop:none |
| /// CHECK-DAG: <<Load:d\d+>> VecLoad [{{l\d+}},<<I:i\d+>>] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: VecAdd [<<Phi>>,<<Load>>] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: Add [<<I>>,<<Cons>>] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: <<Red:d\d+>> VecReduce [<<Phi>>] loop:none |
| /// CHECK-DAG: <<Extr:i\d+>> VecExtractScalar [<<Red>>] loop:none |
| private static int reductionIntM1(int[] x) { |
| int sum = -1; |
| for (int i = 0; i < x.length; i++) { |
| sum += x[i]; |
| } |
| return sum; |
| } |
| |
| /// CHECK-START: long Main.reductionLongM1(long[]) loop_optimization (before) |
| /// CHECK-DAG: <<Cons0:i\d+>> IntConstant 0 loop:none |
| /// CHECK-DAG: <<LongM1:j\d+>> LongConstant -1 loop:none |
| /// CHECK-DAG: <<Cons1:i\d+>> IntConstant 1 loop:none |
| /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none |
| /// CHECK-DAG: <<Phi2:j\d+>> Phi [<<LongM1>>,{{j\d+}}] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: <<Get:j\d+>> ArrayGet [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: Add [<<Phi2>>,<<Get>>] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: Add [<<Phi1>>,<<Cons1>>] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: Return [<<Phi2>>] loop:none |
| // |
| /// CHECK-START-{ARM64,MIPS64}: long Main.reductionLongM1(long[]) loop_optimization (after) |
| /// CHECK-DAG: <<Cons2:i\d+>> IntConstant 2 loop:none |
| /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [{{j\d+}}] loop:none |
| /// CHECK-DAG: <<Phi:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop:B\d+>> outer_loop:none |
| /// CHECK-DAG: <<Load:d\d+>> VecLoad [{{l\d+}},<<I:i\d+>>] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: VecAdd [<<Phi>>,<<Load>>] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: Add [<<I>>,<<Cons2>>] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: <<Red:d\d+>> VecReduce [<<Phi>>] loop:none |
| /// CHECK-DAG: <<Extr:j\d+>> VecExtractScalar [<<Red>>] loop:none |
| private static long reductionLongM1(long[] x) { |
| long sum = -1L; |
| for (int i = 0; i < x.length; i++) { |
| sum += x[i]; |
| } |
| return sum; |
| } |
| |
| private static byte reductionMinusByte(byte[] x) { |
| byte sum = 0; |
| for (int i = 0; i < x.length; i++) { |
| sum -= x[i]; |
| } |
| return sum; |
| } |
| |
| private static short reductionMinusShort(short[] x) { |
| short sum = 0; |
| for (int i = 0; i < x.length; i++) { |
| sum -= x[i]; |
| } |
| return sum; |
| } |
| |
| private static char reductionMinusChar(char[] x) { |
| char sum = 0; |
| for (int i = 0; i < x.length; i++) { |
| sum -= x[i]; |
| } |
| return sum; |
| } |
| |
| /// CHECK-START: int Main.reductionMinusInt(int[]) loop_optimization (before) |
| /// CHECK-DAG: <<Cons0:i\d+>> IntConstant 0 loop:none |
| /// CHECK-DAG: <<Cons1:i\d+>> IntConstant 1 loop:none |
| /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none |
| /// CHECK-DAG: <<Phi2:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: <<Get:i\d+>> ArrayGet [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: Sub [<<Phi2>>,<<Get>>] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: Add [<<Phi1>>,<<Cons1>>] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: Return [<<Phi2>>] loop:none |
| // |
| /// CHECK-START-{ARM,ARM64,MIPS64}: int Main.reductionMinusInt(int[]) loop_optimization (after) |
| /// CHECK-DAG: <<Cons:i\d+>> IntConstant {{2|4}} loop:none |
| /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [{{i\d+}}] loop:none |
| /// CHECK-DAG: <<Phi:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop:B\d+>> outer_loop:none |
| /// CHECK-DAG: <<Load:d\d+>> VecLoad [{{l\d+}},<<I:i\d+>>] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: VecSub [<<Phi>>,<<Load>>] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: Add [<<I>>,<<Cons>>] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: <<Red:d\d+>> VecReduce [<<Phi>>] loop:none |
| /// CHECK-DAG: <<Extr:i\d+>> VecExtractScalar [<<Red>>] loop:none |
| private static int reductionMinusInt(int[] x) { |
| int sum = 0; |
| for (int i = 0; i < x.length; i++) { |
| sum -= x[i]; |
| } |
| return sum; |
| } |
| |
| /// CHECK-START: long Main.reductionMinusLong(long[]) loop_optimization (before) |
| /// CHECK-DAG: <<Cons0:i\d+>> IntConstant 0 loop:none |
| /// CHECK-DAG: <<Long0:j\d+>> LongConstant 0 loop:none |
| /// CHECK-DAG: <<Cons1:i\d+>> IntConstant 1 loop:none |
| /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none |
| /// CHECK-DAG: <<Phi2:j\d+>> Phi [<<Long0>>,{{j\d+}}] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: <<Get:j\d+>> ArrayGet [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: Sub [<<Phi2>>,<<Get>>] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: Add [<<Phi1>>,<<Cons1>>] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: Return [<<Phi2>>] loop:none |
| // |
| /// CHECK-START-{ARM64,MIPS64}: long Main.reductionMinusLong(long[]) loop_optimization (after) |
| /// CHECK-DAG: <<Cons2:i\d+>> IntConstant 2 loop:none |
| /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [{{j\d+}}] loop:none |
| /// CHECK-DAG: <<Phi:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop:B\d+>> outer_loop:none |
| /// CHECK-DAG: <<Load:d\d+>> VecLoad [{{l\d+}},<<I:i\d+>>] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: VecSub [<<Phi>>,<<Load>>] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: Add [<<I>>,<<Cons2>>] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: <<Red:d\d+>> VecReduce [<<Phi>>] loop:none |
| /// CHECK-DAG: <<Extr:j\d+>> VecExtractScalar [<<Red>>] loop:none |
| private static long reductionMinusLong(long[] x) { |
| long sum = 0; |
| for (int i = 0; i < x.length; i++) { |
| sum -= x[i]; |
| } |
| return sum; |
| } |
| |
| // |
| // A few special cases. |
| // |
| |
| // TODO: consider unrolling |
| |
| private static int reductionInt10(int[] x) { |
| int sum = 0; |
| // Amenable to complete unrolling. |
| for (int i = 10; i <= 10; i++) { |
| sum += x[i]; |
| } |
| return sum; |
| } |
| |
| private static int reductionMinusInt10(int[] x) { |
| int sum = 0; |
| // Amenable to complete unrolling. |
| for (int i = 10; i <= 10; i++) { |
| sum -= x[i]; |
| } |
| return sum; |
| } |
| |
| // |
| // Main driver. |
| // |
| |
| public static void main(String[] args) { |
| byte[] xb = new byte[N]; |
| short[] xs = new short[N]; |
| char[] xc = new char[N]; |
| int[] xi = new int[N]; |
| long[] xl = new long[N]; |
| for (int i = 0, k = -17; i < N; i++, k += 3) { |
| xb[i] = (byte) k; |
| xs[i] = (short) k; |
| xc[i] = (char) k; |
| xi[i] = k; |
| xl[i] = k; |
| } |
| |
| // Arrays with all positive elements. |
| byte[] xpb = new byte[M]; |
| short[] xps = new short[M]; |
| char[] xpc = new char[M]; |
| int[] xpi = new int[M]; |
| long[] xpl = new long[M]; |
| for (int i = 0, k = 3; i < M; i++, k++) { |
| xpb[i] = (byte) k; |
| xps[i] = (short) k; |
| xpc[i] = (char) k; |
| xpi[i] = k; |
| xpl[i] = k; |
| } |
| |
| // Arrays with all negative elements. |
| byte[] xnb = new byte[M]; |
| short[] xns = new short[M]; |
| int[] xni = new int[M]; |
| long[] xnl = new long[M]; |
| for (int i = 0, k = -103; i < M; i++, k++) { |
| xnb[i] = (byte) k; |
| xns[i] = (short) k; |
| xni[i] = k; |
| xnl[i] = k; |
| } |
| |
| // Test various reductions in loops. |
| int[] x0 = { 0, 0, 0, 0, 0, 0, 0, 0 }; |
| int[] x1 = { 0, 0, 0, 1, 0, 0, 0, 0 }; |
| int[] x2 = { 1, 1, 1, 1, 0, 0, 0, 0 }; |
| expectEquals(-74, reductionByte(xb)); |
| expectEquals(-27466, reductionShort(xs)); |
| expectEquals(38070, reductionChar(xc)); |
| expectEquals(365750, reductionInt(xi)); |
| expectEquals(273, reductionIntChain()); |
| expectEquals(120, reductionIntToLoop(x0)); |
| expectEquals(121, reductionIntToLoop(x1)); |
| expectEquals(118, reductionIntToLoop(x2)); |
| expectEquals(-1310, reductionIntToLoop(xi)); |
| expectEquals(365750L, reductionLong(xl)); |
| expectEquals(-75, reductionByteM1(xb)); |
| expectEquals(-27467, reductionShortM1(xs)); |
| expectEquals(38069, reductionCharM1(xc)); |
| expectEquals(365749, reductionIntM1(xi)); |
| expectEquals(365749L, reductionLongM1(xl)); |
| expectEquals(74, reductionMinusByte(xb)); |
| expectEquals(27466, reductionMinusShort(xs)); |
| expectEquals(27466, reductionMinusChar(xc)); |
| expectEquals(-365750, reductionMinusInt(xi)); |
| expectEquals(365750L, reductionLong(xl)); |
| expectEquals(-75, reductionByteM1(xb)); |
| expectEquals(-27467, reductionShortM1(xs)); |
| expectEquals(38069, reductionCharM1(xc)); |
| expectEquals(365749, reductionIntM1(xi)); |
| expectEquals(365749L, reductionLongM1(xl)); |
| expectEquals(74, reductionMinusByte(xb)); |
| expectEquals(27466, reductionMinusShort(xs)); |
| expectEquals(27466, reductionMinusChar(xc)); |
| expectEquals(-365750, reductionMinusInt(xi)); |
| expectEquals(-365750L, reductionMinusLong(xl)); |
| |
| // Test special cases. |
| expectEquals(13, reductionInt10(xi)); |
| expectEquals(-13, reductionMinusInt10(xi)); |
| |
| System.out.println("passed"); |
| } |
| |
| private static void expectEquals(int expected, int result) { |
| if (expected != result) { |
| throw new Error("Expected: " + expected + ", found: " + result); |
| } |
| } |
| |
| private static void expectEquals(long expected, long result) { |
| if (expected != result) { |
| throw new Error("Expected: " + expected + ", found: " + result); |
| } |
| } |
| } |
